echo $PATH<\/pre>\nFor, in my case, the output is:<\/p>\n
\/usr\/local\/sbin \/usr\/local\/bin \/usr\/sbin \/usr\/bin \/sbin \/bin \/usr\/games \/usr\/local\/games<\/pre>\n(The output formatting may vary depending on the shell that is being used; in this case, zsh<\/strong> has been used).<\/p>\nSo, whenever we execute a command, the system will look in those directories trying to find an executable with that name.<\/p>\n
You may have already noticed that the echo<\/code> command is actually an executable file stored in one of those directories (concretely, in \/bin<\/code> directory).<\/code><\/p>\n1.1. What happens if we have different commands in different places?<\/h3>\n
Perhaps you have already thought about what happens if we have executables with the same name, in locations that are added to the path. Don’t worry, nothing bad will happen to your system. But, in any case, this is something that has to be taken into account since we may get unexpected results when we execute a command. Sometimes, specially for new Linux users, this can be a headache.<\/p>\n
The “priority” is defined by the value itself of the PATH<\/code> variable. So, for the value above, the first place the system would look would be the \/usr\/local\/sbin<\/code> directory; then, \/usr\/local\/bin<\/code>, and so on.<\/p>\n1.2. Knowing what we are executing<\/h3>\n
Another question we can make to ourselves many times, related to the previous one, is which executable are we actually executing. Of course, we can search in the directories defined in the path looking for the first coincidence, but this is a considerable overhead.<\/p>\n
For this, there’s an executable called which<\/code>. This executable script returns the path of the given executable name that would be executed:<\/p>\nwhich <executable><\/pre>\nFor example, if we want to know which Python binary we would execute, we would execute:<\/p>\n
which python<\/pre>\nWhich would generate the following output:<\/p>\n
\/usr\/bin\/python<\/pre>\n1.3. Looking for executables in the path<\/h3>\n
Another interesting thing can be to know all the existing locations for the given executable, besides the “first” executable, the one returned by which<\/code>.<\/p>\nThe command for this is called whereis<\/code>. Actually, this command does more than what said above: it looks not only for executables, but also for source code and manual pages.<\/p>\nIt works the same as with which<\/code>:<\/p>\nwhereis <executable><\/pre>\nSo, following with the previous example of Python:<\/p>\n
whereis python<\/pre>\nThe output, in this case, would be:<\/p>\n
python: \/usr\/bin\/python2.7 \/usr\/bin\/python3.5m \/usr\/bin\/python3.5 \/usr\/bin\/python \/usr\/lib\/python2.7 \/usr\/lib\/python2.6 \/usr\/lib\/python3.5 \/etc\/python2.7 \/etc\/python3.5 \/etc\/python \/usr\/local\/lib\/python2.7 \/usr\/local\/lib\/python3.5 \/usr\/include\/python2.7 \/usr\/include\/python3.5m \/usr\/share\/python \/usr\/share\/man\/man1\/python.1.gz<\/pre>\n2. Most important Linux commands<\/h2>\n
Now that we know how the Linux commands mechanism works, it’s time to see which are the must-know commands.<\/p>\n
2.1. User management<\/h3>\n
User management is a task every systems administrator has to deal with quite usually. Let’s see which are the most important commands for this.<\/p>\n
2.1.1. Creating users<\/h4>\n
For adding users, we have two commands: useradd<\/code> and adduser<\/code>. The first one if the low level, native Linux binary; and the second, a friendly wrapper built on the top of this first one.<\/p>\nNative binary: <\/strong>useradd<\/strong><\/p>\nTo create a user with useradd<\/code>, in its most basic way, it’s just about executing:<\/p>\nsudo useradd john_doe<\/pre>\nThis method has some downsides: no home directory has been created or the shell is sh<\/code> instead of bash<\/code>. And even worse, the user has not a password. Using this command, it’s always advisable to use the following options:<\/p>\nsudo useradd john_doe -m -s \/bin\/bash\r\n# And, then, set a password!\r\nsudo passwd john_doe<\/pre>\nFriendly wrapper: adduser<\/strong><\/p>\nIn any case, generally, this is not the advised way to create users. adduser<\/code> is much more friendly. For example, just executing the following:<\/p>\nsudo adduser john_doe<\/pre>\nWe can interactively set the password, personal information, creation of the home directory, etc.<\/p>\n
2.1.2. Removing users<\/h4>\n
As same as for adding users, for deleting them, we have two options: the native binary, and a friendlier script.<\/p>\n
Native binary: userdel<\/strong><\/p>\nFor deleting users, just execute:<\/p>\n
sudo userdel john_doe<\/pre>\nFor deleting the user as long with its home directory:<\/p>\n
sudo userdel -r john_doe<\/pre>\nFriendly wrapper: deluser<\/strong><\/p>\nFor just deleting the user:<\/p>\n
sudo deluser john_doe<\/pre>\nAnd with its home directory:<\/p>\n
sudo userdel --remove-home john_doe<\/pre>\nAnd also every file owned by him:<\/p>\n
sudo userdel --remove-home --remove-all-files john_doe<\/pre>\n2.1.4. List all the users<\/strong><\/p>\nThe users are defined in the \/etc\/passwd<\/code> file, so we can check them with<\/p>\ncat \/etc\/passwd<\/pre>\n2.1.5. List all the groups<\/strong><\/p>\nThe same as with the users, but in this case with \/etc\/group<\/code> file:<\/p>\ncat \/etc\/group<\/pre>\n2.1.6. List the groups a user belongs to<\/strong><\/p>\nFor this, we can use the groups<\/code> command, specifying the user:<\/p>\ngroups <user><\/pre>\nIf we don’t specify any user, the current one ($USER<\/code>) will be used.<\/p>\n2.2. Permissions<\/h3>\n
Another completely essential task is to manage the file permissions. As you probably already know, the permissions in Linux are configured for three “groups”: the owner of the file, the group the owner of the file belongs to, and the rest of users.<\/p>\n
This section will show how to use the commands regarding the permissions.<\/p>\n
2.2.1. Changing files permissions: chmod<\/h4>\n
For changing the permissions within files and directories, chmod<\/code> command is used. For this, we have two options: the octal representation, or the symbolic one.<\/p>\nOctal representation<\/strong><\/p>\nFor using the octal representation, we have to know the following:<\/p>\n
\n0<\/code> for no permission.<\/li>\n1<\/code> is for execution permission.<\/li>\n2<\/code> is for write permission.<\/li>\n4<\/code> is for read permission.<\/li>\n<\/ul>\nKnowing this, is just a matter of combining the digits to set the permission. For example:<\/p>\n
sudo chmod 750 foo.txt<\/pre>\nWould result in:<\/p>\n
Read, write and execute permission for the user owning the file (7<\/code>).<\/p>\nRead and execution permission for the users belonging to the group the owner of the file belongs to (5<\/code>).<\/p>\nNo permission for any others (0<\/code>).<\/p>\nSymbolic representation<\/strong><\/p>\nIn the symbolic representation letters and arithmetic operators are used:<\/p>\n
For the users<\/strong>, the symbols are the following:<\/p>\n\nu<\/code>: file owner.<\/li>\ng<\/code>: file owner\u2019s group.<\/li>\no<\/code>: other users.<\/li>\na<\/code>: all users.<\/li>\n<\/ul>\nThe actions<\/strong> are represented with the same symbols that we have seen before:<\/p>\n\nr<\/code>: read.<\/li>\nw<\/code>: write.<\/li>\nx<\/code>: execute.<\/li>\n<\/ul>\nAnd the operators to set the permissions are:<\/p>\n
\n=<\/code>: sets the permissions as specified, overwriting any other previous permissions.<\/li>\n+<\/code>: adds permissions.<\/li>\n-<\/code>: removes permissions.<\/li>\n<\/ul>\nTaking this into account, the equivalent for the example seen for the octal representation, would be:<\/p>\n
sudo chmod u=rwx,g=rx,o-rwx foo.txt<\/pre>\nFor this specific case, we have to type much more than with the octal representation. But for same cases is more useful. For example, to edit the permissions for all, or for a specific group:<\/p>\n
sudo chmod a+w foo.txt<\/pre>\nThe previous command will set write permissions for all the users.<\/p>\n
Note<\/strong>:<\/strong> if we are changing the permissions for directories, we can use the -R<\/code> option to apply those specified permissions to all the objects inside the directory.<\/p>\n2.2.2. Changing files ownerships: chown<\/h4>\n
On the other hand of the permissions, we have the group assignment, which is actually easier than the file permissions. It’s just about:<\/p>\n
sudo chown <owning-user>[:<owning-group>] <file|directory><\/pre>\nFor example, to change just the owning user of a file:<\/p>\n
sudo chown john_doe foo.txt<\/pre>\nAnd, for changing also the group owner:<\/p>\n
sudo chown john_doe:john_doe foo.txt<\/pre>\nNote<\/strong>:<\/strong> if we are changing the permissions for directories, we can use the -R<\/code> option to apply those specified permissions to all the objects inside the directory.<\/p>\n2.2.3. Login as other user: su<\/strong><\/p>\nIf at any moment we want to login with another user, we will have to use the su<\/code> command. This is actually very easy: for example, to login as root<\/code> command:<\/p>\nsu - root<\/pre>\nThen, we will be asked for the password of the given user.<\/p>\n
2.2.4. Executing a command as superuser: sudo<\/strong><\/p>\nThis command, one of the first things learned when starting to use Linux, is for executing a certain command as superuser, as we already have seen before in this tutorial.<\/p>\n
2.3. Networking<\/h3>\n
From while to while, we also have to deal with network related stuff. Let’s some commands for this.<\/p>\n
2.3.1. Interface configuration: ifconfig<\/h4>\n
Probably the first network command one learns. ifconfig<\/code> stands for i<\/strong>nterf<\/strong>ace config<\/strong>uration<\/em>. It’s easiest usage is without any option, to show the information regarding every interface present in the system:<\/p>\nifconfig<\/pre>\nTo show the information related to a specific interface, we can specify it. For example, for eth0<\/code>:<\/p>\nifconfig eth0<\/pre>\nWe can also set the interfaces down\/up (this action requires root permissions):<\/p>\n
sudo ifconfig eth0 up\r\nsudo ifconfig eth0 down<\/pre>\nThe remaining useful command would be for assigning IP addresses to the given interface, e.g.:<\/p>\n
sudo ifconfig eth0 192.168.1.30<\/pre>\n2.3.2. Network statistics: netstat<\/h4>\n
This is probably the most used command in this scope. Let’s see the most useful examples:<\/p>\n
List all the ports<\/strong><\/p>\nnetstat -a | more<\/pre>\nList just TCP ports<\/strong><\/p>\nnetstat -at<\/pre>\nList just UDP ports<\/strong><\/p>\nnetstat -au<\/pre>\nList listening TCP ports<\/strong><\/p>\nnetstat -lt<\/pre>\nList listening UDP ports<\/strong><\/p>\nnetstat -lu<\/pre>\nShow the process associated to the port<\/strong><\/p>\nJust adding -p<\/code>:<\/p>\nnetstat -p\r\nnetstat -ltp<\/pre>\n2.4. Navigation and file management<\/h3>\n
These are probably the first learned commands. In any case, let’s see them.<\/p>\n
Navigating through directories: cd<\/strong><\/p>\nJust for changing the directory. We can specify relative or absolute paths:<\/p>\n
cd foo\r\ncd \/home\/julen\/foo\r\ncd # For going to $HOME.<\/pre>\nDeleting things: rm<\/strong><\/p>\nFor both files and directories:<\/p>\n
rm foo.txt\r\nrm -d foo # -d option is needed for directories.\r\nrm -d -r foo # -r to remove recursively, if the directory is not empty.<\/pre>\nCreating files: touch<\/strong><\/p>\nJust for creating a files:<\/p>\n
touch foo.txt\r\ntouch foo.txt foo2.txt<\/pre>\nCreating files with content in one command: echo ><\/strong><\/p>\nUseful for when we want to create files with contents in the fly:<\/p>\n
echo 'file content' > foo.txt<\/pre>\nFiles and directories listing: ls<\/strong><\/p>\nOne of the most used Linux commands. For example:<\/p>\n
ls # Simple output, just list the files in the current directory.\r\nls -a # List also hidden files (starting with '.').\r\nls -l # Detailed output (permissions, owner, etc.).\r\nls -lh # List also the size.<\/pre>\nCreating links: ln<\/strong><\/p>\nFor creating links between files. In most of the cases, it’s for creating just symbolic links (a pointer to another file, with a different i-node). The usage is the following:<\/p>\n
ln -s <source-file-or-directory> <dest-link><\/pre>\nFor example:<\/p>\n
ln -s a b<\/pre>\nb<\/code> will be a symbolic link to a<\/code>.<\/p>\n2.5. Finding things<\/h3>\n
A very typical scenario is that when we have to look for something that we don’t know where it is. In this section we will see commands that will make our life easier in this aspect.<\/p>\n
2.5.1. Finding inside files: grep<\/h4>\n
When we need to look for string inside logfiles, source code, etc. grep<\/code> will make the work for us. The syntax is the following:<\/p>\ngrep \"<string>\" <file><\/pre>\nFor example:<\/p>\n
grep \"bar\" foo.txt<\/pre>\nLooking recursively in every files of the given directory<\/strong><\/p>\ngrep -R \"bar\" foo\/<\/pre>\nShowing the line number where each coincidence is<\/strong><\/p>\ngrep -n \"bar\" foo.txt<\/pre>\nCase insensitiveness
\n<\/strong><\/p>\ngrep -i \"BaR\" foo.txt<\/pre>\n2.5.2. Finding files in the system: find<\/h4>\n
On the other hand, for finding files, we have the powerful find<\/code> command, with the following syntax:<\/p>\nfind <path> <expression><\/pre>\nFinding by literal name<\/strong><\/p>\nfind \/home -name foo.txt<\/pre>\nCase insensitiveness<\/strong><\/p>\nfind \/home -iname foo.txt<\/pre>\nFinding by file extension<\/strong><\/p>\nfind \/home -name *.txt<\/pre>\n