Best practices for using 'sudo su'

Question

I have been using the terminal for a while now and sometimes (actually, a lot of times) I use a command, like:

cp /etc/test ~/testFolder/

and I get this error:

cp: cannot open `/etc/test` for reading: Permission denied

That's the moment I remember that I forgot the sudo command before it, so I press Up arrow and then CTRL+A to go to the beggining of the line and insert a sudo there:

sudo cp /etc/test ~/testFolder/

There are even worse scenarios where you use vim to edit a file, you forget sudo command and don't see the warning when the program starts, you edit the entire file and in the end, you can't save it!

When you realize you're doing it so many times, it becomes annoying, specially if you're like me and used to type commands without the sudo. There is a way to solve this problem, when you start the terminal, just type sudo su to use commands as root user, but some say it's more likely to make mistakes that you'll regret forever.

My question is, what's the best practice for executing commands as root? Using sudo and missing it everytime or automatically use sudo bash and having the risk of destroying the entire system?

Answer 1

Relax. Firstly, rm -rf * or anything such like run as a regular user in your home directory is equally catastrophic. System can easily be restored, but it's your data that matters. In the fifteen years or so that I use Linux I had no major disaster that could have been avoided by not using root.

(Well, if you are a sysadmin, especially on a production server, then it is another matter. Just clench your teeth and do it properly; see the horror story of @jmartin2279 in another answer to this question).

Secondly, if you have a different prompt (by default root prompt ends with a hash, #, but you can make it colorful), it will remind you that you are not running as a regular user.

Thirdly, you are an intelligent human being, so you do regular backups. You do, don't you? You know what they say: there are two types of people, those who do backups and those who will.

Finally, get off my lawn, in the olde days we had no stinking su or sudo, we were memorizing passwords of twenty random characters every month and we LIKED IT! (and sometimes, we had half an hour chat over a single command line before pressing "enter")

However, vim always warns you that you are editing a read only file ("/etc/passwd" [readonly] in the status line). Also, if you cannot write to a file, you can always :w /tmp/whatever.

Answer 2

Best practice is to only use root when you need it. by using sudo su, you are indeed giving the devil access to the kingdom. it was annoying to me at first, but remembering to use sudo in front of a command has saved me from making massive mistakes. I have had an experience where using sudo su has ruined everything, in a work environment.

Story time

We where using a CentOS server to run an application. the server was old, and had been turned into a VM because its hardware was dead/dying. We had a raid corruption occur and the VM was damaged. our backups were damaged to so only hope to recover data was mount VM and try to pull it all. I used sudo su and got to work. i recovered about 10% when i accidentally ran the wrong command, it wiped the database and we lost the application and all data. I have never run sudo su again, and I won't. lesson learned the hard way.

Answer 3

Back in the days before I used a sudo system (read: ancient Red Hat), I used several techniques to remind me when I was running as root: a red prompt, "root" in the title bar, etc. These days I run sudo and have no prompt change. I've never ever had a problem from operating as root that would have been solved by having to prepend sudo to a command.

I've got a shortcut for editing files. I've got a bash script similar to the following in ~/bin/vi (and ~/bin is the first entry in my $PATH):

#!/bin/bash
if [[ ! -w "$1" ]]; then
  exec sudo vim "$@"
else
  exec vim "$@"
fi

I'm typing this from memory, so beware of bugs. The idea is that if the first file named I'd un-writeable then it automatically uses sudo. Obviously this approach isn't perfect, but it's been good enough for a number of years.