Using Essential Tools

By Sander van Vugt

Date: Jul 3, 2023

Return to the article

The following topics are covered in this chapter:

• Basic Shell Skills

• Editing Files with vim

• Understanding the Shell Environment

• Finding Help

The following RHCSA exam objectives are covered in this chapter:

• Use input-output redirection (>, >>, |, 2>, etc.)

• Access a shell prompt and issue commands with correct syntax

• Create and edit text files

• Locate, read, and use system documentation including man, info, and files in /usr/share/doc

This chapter is dedicated to coverage of the basic Linux skills that everyone should have before attempting to take the RHCSA exam.

“Do I Know This Already?” Quiz

The “Do I Know This Already?” quiz enables you to assess whether you should read this entire chapter thoroughly or jump to the “Exam Preparation Tasks” section. If you are in doubt about your answers to these questions or your own assessment of your knowledge of the topics, read the entire chapter. Table 2-1 lists the major headings in this chapter and their corresponding “Do I Know This Already?” quiz questions. You can find the answers in Appendix A, “Answers to the ‘Do I Know This Already?’ Quizzes and Review Questions.”

Table 2-1 “Do I Know This Already?” Section-to-Question Mapping

1. Which of the following commands enables you to redirect standard output as well as standard error to a file?

1. 1&2> file

2. > file 2>&1

3. >1&2 file

4. 1>2& file

2. You want to set a local variable that will be available for every user in every shell. Which of the following files should you use?

1. /etc/profile

2. /etc/bashrc

3. ~/.bash_profile

4. ~/.bashrc

3. A user has created a script with the name myscript. The user tries to run the script using the command myscript, but it is not started. The user has verified that the script permissions are set as executable. Which of the following is the most likely explanation?

1. An internal command is preventing the startup of the script.

2. Users are not allowed to run scripts.

3. The directory that contains the script is not in the $PATH variable.

4. The script does not have appropriate permissions.

4. You need the output of the command ls to be used as input for the less command. Which of the following examples will do that for you?

1. ls > less

2. ls >> less

3. ls >| less

4. ls | less

5. A user by accident has typed a password, which now shows as item 299 in history. Which of the following do you recommend to ensure the password is not stored in history?

1. Remove the ~/.bash_history file and type history -c.

2. Type history -c.

3. Remove the ~/.bash_history file.

4. Type history -d 299.

6. Which of the following is not a valid method to repeat a command from history?

1. Press Ctrl-r and start typing a part of the command.

2. Type ! followed by the first letters in the command.

3. Type ! followed by the number of the command as listed in history.

4. Press Ctrl-x followed by the number in history.

7. For which of the following items can Bash completion be used?

1. Commands

2. Files

3. Variables

4. All of the above

8. Which of the following commands enables you to replace every occurrence of old with new in a text file that is opened with vim?

1. :%s/old/new/g

2. :%r/old/new/

3. :%s/old/new/

4. r:/old/new

9. Which approach works best if during the login process you want to show a message to all users who have just logged in to a shell session on your server?

1. Put the message in /etc/issue.

2. Put the message in /etc/motd.

3. Put the message in /etc/profile.

4. Put the message in /etc/bashrc.

10. You are using man -k user, but you get the message “nothing appropriate.” Which of the following solutions is most likely to fix this for you?

1. Type sudo updatedb to update the mandb database.

2. Type sudo makewhatis to update the mandb database.

3. Type sudo mandb to update the mandb database.

4. Use man -K, not man -k.

Foundation Topics

Basic Shell Skills

The shell is the default working environment for a Linux administrator. It is the environment where users and administrators enter commands that are executed by the operating system. Different shells for Linux are available, but Bash is the most common shell. So, when we are talking about “the shell” in this book, we are actually talking about the Bash shell. This chapter provides an overview of some of the items that you will encounter when working with the shell.

Understanding Commands

Working with the shell is all about working with command syntax. Typically, command syntax has three basic parts: the command, its options, and its arguments.

The command is the command itself, such as ls. This command shows a list of files in the current directory. To modify the behavior of the command, you can use options. Options are a part of the program code, and they modify what the command is doing. For instance, when you use the -l (lowercase letter l, not number 1) option with the ls command, a long listing of filenames and properties is displayed.

The word argument is a bit confusing. Generally speaking, it refers to anything that the command addresses, so anything you put after the command is an argument (including the options). Apart from the options that can be used as an argument, commands can have other arguments as well, which serve as a target to the command.

Let’s have a look at an example: the command ls -l /etc. This command has two different arguments: -l and /etc. The first argument is an option, modifying the behavior of the command. The second argument is a target, specifying where the command should do its work. You’ll find these three elements in nearly all commands you work with in a Linux environment.

Executing Commands

The purpose of the Linux shell is to provide an environment in which commands can be executed. The shell takes care of interpreting the command that a user has entered correctly. To do this, the shell makes a distinction between three kinds of commands:

• Aliases

• Internal commands

• External commands

An alias is a command that a user can define as needed. Some aliases are provided by default; type alias on the command line to get an overview. To define an alias, use alias newcommand=‘oldcommand’ (as in the default alias ll=‘ls -l --color=auto’ that has already been created on your system). Aliases are executed before anything else. So, if you have an alias with the name ll but also a command with the name ll, the alias will always take precedence for the command, unless a complete pathname like /usr/bin/ls is used.

An internal command is a command that is a part of the shell itself and, as such, doesn’t have to be loaded from disk separately. An external command is a command that exists as an executable file on the disk of the computer. Because it has to be read from disk the first time it is used, it is a bit slower. When a user executes a command, the shell first looks to determine whether it is an internal command; if it is not, it looks for an executable file with a name that matches the command on disk. To find out whether a command is a Bash internal command or an executable file on disk, you can use the type command. Use for instance type pwd to find out that the pwd command that will be executed is really an alias.

To change how external commands are found by the shell, use the $PATH variable. This variable defines a list of directories that is searched for a matching filename when a user enters a command. To find out which exact command the shell will be using, you can use the which command. For instance, type which ls to find out where the shell will get the ls command from. An even stronger command is type, which will also work on internal commands and aliases.

You should notice that, for security reasons, the current directory is not in the $PATH variable and Linux does not look in the current directory to see whether a specific command is available from that directory. That is why you need to start a command that is in the current directory but nowhere in the $PATH by including ./ in front of it. The dot stands for the current directory, and by running it as ./, you tell Bash to look for the command in the current directory. Although running commands this way is not very common, you will have to do it to run scripts that you’ve created in your current directory.

The $PATH variable can be set for specific users, but in general, most users will be using the same $PATH variable. The only exception to this is the user root, who needs access to specific administration commands. In Exercise 2-1, you learn some of the basics about working with commands.

I/O Redirection

By default, when a command is executed, it shows its results on the screen of the computer you are working on. The computer monitor is used as the standard destination for output, which is also referred to as STDOUT. The shell also has default standard destinations to send error messages to (STDERR) and to accept input (STDIN). Table 2-2 gives an overview of all three.

Table 2-2 Standard Input, Output, and Error Overview

So if you run a command, that command would expect input from the keyboard, and it would normally send its output to the monitor of your computer without making a distinction between normal output and errors. Some commands, however, are started in the background and not from a current terminal session, so these commands do not have a monitor or console session to send their output to, and they do not listen to keyboard input to accept their standard input. That is where redirection comes in handy. Redirection is also useful if you want to work with input from an alternative location, such as a file.

Programs started from the command line have no idea what they are reading from or writing to. They just read from what the Linux kernel calls file descriptor 0 if they want to read from standard input, and they write to file descriptor number 1 to display non-error output (also known as “standard output”) and to file descriptor 2 if they have error messages to be output. By default, these file descriptors are connected to the keyboard and the screen. If you use redirection symbols such as <, >, and |, the shell connects the file descriptors to files or other commands. Let’s first look at the redirectors < and >. Later we discuss pipes (the | symbol). Table 2-3 shows the most common redirectors that are used from the Bash shell.

Table 2-3 Common Bash Redirectors

In I/O redirection, files can be used to replace the default STDIN, STDOUT, and STDERR. You can also redirect to device files. A device file on Linux is a file that is used to access specific hardware. Your hard disk, for instance, can be referred to as /dev/sda in most cases, the console of your server is known as /dev/console or /dev/tty1, and if you want to discard a command’s output, you can redirect to /dev/null. Note that to access most device files, you need to have root privileges.

Using Pipes

Whereas an I/O redirector is used as an alternative for a keyboard and computer monitor, a pipe can be used to catch the output of one command and use that as input for a second command. If a user runs the command ls, for instance, the output of the command is shown onscreen, because the screen is the default STDOUT. If the user uses ls | less, the commands ls and less are started in parallel. The standard output of the ls command is connected to the standard input of less. Everything that ls writes to the standard output will become available for reading from standard input in less. The result is that the output of ls is shown in the less pager, where the user can browse up and down through the results easily.

As a Linux administrator, you will use pipes a lot. Using pipes makes Linux a flexible operating system; by combining multiple commands using pipes, you can create “super” commands that make almost anything possible. In Exercise 2-2, you use I/O redirectors and pipes.

History

A convenient feature of the Bash shell is the Bash history. Bash is configured by default to keep the last 1,000 commands a user used. When a shell session is closed, the history of that session is updated to the history file. The name of this file is .bash_history and it is created in the home directory of the user who started a specific shell session. Notice that the history file is written to only when the shell session is closed; until that moment, all commands in the history are kept in memory.

The history feature makes it easy to repeat complex commands. There are several ways of working with history:

• Type history to show a list of all commands in the Bash history.

• Press Ctrl-r to open the prompt from which you can do backward searches in commands that you have previously used. Just type a string and Bash will look backward in the command history for any command containing that string as the command name or one of its arguments. Press Ctrl-r again to repeat the last backward search.

• Type !number to execute a command with a specific number from history.

• Use history -d number to delete a specific command from history. Notice that this command will renumber all other lines in history: if you’ve removed line 31, the line previously numbered as line 32 will now be line 31.

• Type !sometext to execute the last command that starts with sometext. Notice that this is a potentially dangerous command because the command that was found is executed immediately!

In some cases it might be necessary to wipe the Bash history. This capability is useful, for instance, if you’ve typed a password in clear text by accident. If that happens, you can type history -c to clear the current history. Commands from this session won’t be written to the history file when you exit the current session. If you want to remove both the current history and the contents of the .bash_history file, then type history -w immediately after running the history -c command. Alternatively, use history -d number to remove a specific command from history.

Exercise 2-3 guides you through some history features.

Bash Completion

Another useful feature of the Bash shell is command-line completion. This feature helps you to find the command that you need, and it also works on variables and filenames.

Bash completion is useful when you’re working with commands. Just type the beginning of a command and press the Tab key. If there is only one option for completion, Bash will complete the command automatically for you. If there are several options, you need to press Tab once more to get an overview of all the available options. In Exercise 2-4, you learn how to work with these great features.

Editing Files with vim

Managing Linux often means working with files. Most things that are configured on Linux are configured through files. To complete administrative tasks, you often need to change the contents of a configuration file with a text editor.

Over the years, many text editors have been created for Linux. One editor really matters, though, and that is vi. Even if some other text editors are easier to use, vi is the only text editor that is always available. That is why as a Linux administrator you need to know how to work with vi. One common alternative is vim, or “vi improved”; it is a complete rewrite of vi with a lot of enhancements that make working with vi easier, such as syntax highlighting for many configuration files, which makes it easy to recognize typing errors that you have made. Everything that you learn in this section about vim works on vi as well.

An important concept when working with vim is that it uses different modes. Two of them are particularly important: command mode and input mode. These modes often cause confusion because in command mode you can just enter a command and you cannot edit the contents of a text file. To change the contents of a text file, you need to get to input mode.

The challenge when working with vim is the vast number of commands that are available. Some people have even produced vim cheat sheets, listing all available commands. Do not use them. Instead, focus on the minimal number of commands that are really important. Table 2-4 summarizes the most essential vim commands. Use these (and only these) and you’ll do fine on the RHCSA exam.

Table 2-4 vim Essential Commands

Now you know the most essential commands for working with vim. Exercise 2-5 gives you the opportunity to test them.

Understanding the Shell Environment

When you are working from a shell, an environment is created to ensure that all that is happening is happening the right way. This environment consists of variables that define the user environment, such as the $PATH variable discussed earlier. In this section, you get a brief overview of the shell environment and how it is created.

Understanding Variables

The Linux shell environment consists of many variables. Variables are fixed names that can be assigned dynamic values. An example of a variable is $LANG, which in my shell is set to en_US.UTF-8. This value (which may differ on your system) ensures that I can work in the English language using settings that are common in the English language (think of how date and time are displayed).

The advantage of working with variables for scripts and programs is that the program only has to use the name of the variable without taking interest in the specific value that is assigned to the variable. Because different users have different needs, the variables that are set in a user environment will differ. To get an overview of the current variables defined in your shell environment, type the env command, which will show environment variables that are used to set important system settings. Example 2-1 shows some lines of the output of this command.

Example 2-1 Displaying the Current Environment

[user@server1 ~]$ env
MAIL=/var/spool/mail/user
PATH=/usr/local/bin:/bin:/usr/bin:/usr/local/sbin:/usr/sbin:/home/
user/.local/bin:/home/user/bin
PWD=/home/user
LANG=en_US.UTF-8
HISTCONTROL=ignoredups
SHLVL=1
HOME=/home/user
LOGNAME=user
LESSOPEN=||/usr/bin/lesspipe.sh %s
_=/bin/env
OLDPWD=/etc

As you can see from Example 2-1, to define a variable, you type the name of the variable, followed by an equal sign (=) and the value that is assigned to the specific variable. To read the value of a variable, you can use the echo command (among others), followed by the name of the variable, as in echo $PATH, which reads the current value of the $PATH variable and prints that to STDOUT. For now, you do not have to know much more about variables. You can read about more advanced use of variables in Chapter 19, “An Introduction to Automation with Bash Shell Scripting.”

Recognizing Environment Configuration Files

When a user logs in, an environment is created for that user automatically. This happens based on the following four configuration files, where some script code can be specified and where variables can be defined:

• /etc/profile: This is the generic file that is processed by all users upon login.

• /etc/bashrc: This file is processed when subshells are started.

• ~/.bash_profile: In this file, user-specific login shell variables can be defined.

• ~/.bashrc: In this user-specific file, subshell variables can be defined.

As you have seen, in these files a distinction is made between a login shell and a subshell. A login shell is the first shell that is opened for a user after the user has logged in. From the login shell, a user may run scripts, which will start a subshell of that login shell. Bash allows for the creation of a different environment in the login shell and in the subshell, but to make sure the same settings are used in all shells, it’s a good idea to include subshell settings in the login shell as well.

Using /etc/motd and /etc/issue

To display messages during the login process, Bash uses the /etc/motd and the /etc/issue files. Messages in /etc/motd display after a user has successfully logged in to a shell. (Note that users in a graphical environment do not see its contents after a graphical login.) Using /etc/motd can be a convenient way for system administrators to inform users about an issue or a security policy, for example.

Another way to send information to users is by using /etc/issue. The contents of this file display before the user logs in from a text-based console interface. Using this file provides an excellent means of specifying login instructions to users who are not logged in yet.

In Exercise 2-6, you can practice the topics that have been discussed in this section.

Finding Help

On an average Linux system, hundreds of commands are available—way too many to ever be able to remember all of them, which is why using the help resources on your computer is so very important. The man command is the most important resource for getting help about command syntax and usage. Apart from that, you can show a compact list of command options by using command --help.

Using --help

The quickest way to get an overview of how to use a command is by running the command with the --help option. Nearly all commands will display a usage summary when using this option. In this summary you’ll see all options that can be used with the command. Notice that there is no strict order for the options; you can use them in any order you’d like.

The list of options that is shown in this way is of use mainly when you already have a generic understanding of how to use the command and need a quick overview of options available with the command—it doesn’t give detailed information that will help users who don’t know the command yet.

Using man

When using the Linux command line, you will at some point consult man pages. The man command is what makes working from the command line doable. If you do not know how a command is used, the man page of that command will provide valuable insight. This section covers a few man essentials.

To start with, the most important parts of the man page in general are at the bottom of the man page. Here you’ll find two important sections: In many cases there are examples; if there are no examples, there is always a “See Also” section. The topics you find here are related man pages, which is useful if you have just not hit the right man page. To get to the bottom of the man page as fast as possible, use the G command. You can also type /example to search the man page for any examples. Figure 2-1 shows what the end of a man page may look like.

Finding the Right man Page

To find information in man pages, you can search the mandb database by using apropos or man -k. If the database is current, getting access to the information you need is easy. Just type man -k, followed by the keyword you want to search for. This command looks in the summary of all man pages that are stored in the mandb database. If you get “nothing appropriate” when running this command, consult the section “Updating mandb” later in this chapter. Example 2-2 shows a partial result of this command.

Example 2-2 Searching man Pages with man –k

[root@server1 ~]# man -k partition
addpart (8)       - simple wrapper around the "add partition" ioctl
cfdisk (8)        - display or manipulate disk partition table
cgdisk (8)        - Curses-based GUID partition table (GPT)
manipulator
delpart (8)       - simple wrapper around the "del partition" ioctl
fdisk (8)         - manipulate disk partition table
fixparts (8)       - MBR partition table repair utility
gdisk (8)         - Interactive GUID partition table (GPT)
manipulator
iostat (1)        - Report Central Processing Unit (CPU) statistics
and in...
kpartx (8)        - Create device maps from partition tables
mpartition (1)      - partition an MSDOS hard disk
os-prober (1)       - Discover bootable partitions on the local
system
partprobe (8)       - inform the OS of partition table changes
partx (8)         - tell the Linux kernel about the presence and
numbering...
pvcreate (8)       - initialize a disk or partition for use by LVM
pvresize (8)       - resize a disk or partition in use by LVM2
resizepart (8)      - simple wrapper around the "resize partition"
ioctl
sfdisk (8)        - partition table manipulator for Linux
sgdisk          (- Command-line GUID partition table (GPT)
manipulator fo...
systemd-efi-boot-generator (8) - Generator for automatically mounting
the EFI...
systemd-gpt-auto-generator (8) - Generator for automatically
discovering and ..

Based on the information that man -k is giving you, you can probably identify the man page that you need to access to do whatever you want to accomplish. Be aware, however, that man -k is not perfect; it searches only the short summary of each command that is installed. If your keyword is not in the summary, you’ll find nothing and get a “nothing appropriate” error message.

When using man -k to find specific information from the man pages, you’ll sometimes get a load of information. If that happens, it might help to filter down the results a bit by using the grep command. But if you want to do that, it is important that you know what you are looking for.

Man pages are categorized in different sections. The most relevant sections for system administrators are as follows:

• 1: Executable programs or shell commands

• 5: File formats and conventions

• 8: System administration commands

There are also sections that provide in-depth details about your Linux system, such as the sections about system calls and library calls. When using man -k, you’ll get results from all of these sections. To limit the results that display, it makes sense to use grep to show only those sections that are relevant for what you need. So, if you are looking for the configuration file that has something to do with passwords, use man -k password | grep 5, or if you are looking for the command that an administrator would use to create partitions, use man -k partition | grep 8.

Another useful man option is -f. The command man -f <somecommand> displays a short description of the item as found in the mandb database. This description may help you when deciding whether this man page contains the information you are looking for.

Updating mandb

As previously mentioned, when you use the man -k command, the mandb database is consulted. This database is automatically created through a scheduled job. Occasionally, you might look for something that should obviously be documented, but all you get is the message “nothing appropriate.” If that happens, you might need to update the mandb database manually. Doing that is easy: Just run the mandb command as root without any arguments. It will see whether new man pages have been installed and update the mandb database accordingly.

Assume that you are looking for a command, using man -k, but all you get is the message “nothing appropriate” and you do not remember how to fix it. Exercise 2-7 shows what you can do in such cases.

Using info

Apart from the information that you’ll find in man pages, another system provides help about command usage. This is the info system. Most commands are documented in man pages, but some commands have their main documentation in the info system and only show a short usage summary in the man page. If that is the case, the “See Also” section of the man page of that command will tell you that “The full documentation for…is maintained as a Texinfo manual.” You then can read the info page using the command pinfo or info. Both commands work, but in pinfo, special items such as menu items are clearly indicated, which is why using pinfo is easier.

When working with info, take a look at the top line of the viewer. This shows the current position in the info document. Particularly interesting are the Up, Next, and Previous indicators, which tell you how to navigate. Info pages are organized like web pages, which means that they are organized in a hierarchical way. To browse through that hierarchy, type n to go to the next page, p to go to the previous page, or u to move up in the hierarchy.

In an info page, you’ll also find menus. Each item that is marked with an asterisk (*) is a menu item. Use the arrow keys to select a specific menu item. This brings you down one level. To get back up again, type u. This brings you back to the original starting point in the pinfo hierarchy. Figure 2-2 shows what an info page looks like.

Exercise 2-8 shows an example of such a command, and in this exercise you learn how to get the information out of the info page.

Using /usr/share/doc Documentation Files

A third source of information consists of files that are sometimes copied to the /usr/share/doc directory. These files are available in particular for services and larger systems that are a bit more complicated. You will not typically find much information about a command like ls, but some services do provide useful information in /usr/share/doc.

Some services store very useful information in this directory, like rsyslog, bind, Kerberos, and OpenSSL. For some services, even sample files are included.

Summary

In this chapter, you read about essential Linux administration tasks. You learned about some of the important shell basics, such as redirecting I/O, working with history, and managing the environment. You also learned how to edit text files with the vim editor. In the last part of this chapter, you learned how to find information using man and related commands.

Exam Preparation Tasks

As mentioned in the section “How to Use This Book” in the Introduction, you have several choices for exam preparation: the end-of-chapter labs; the memory tables in Appendix C; Chapter 27, “Final Preparation”; and the practice exams.

Review All Key Topics

Review the most important topics in the chapter, noted with the Key Topic icon in the margin of the page. Table 2-5 lists a reference of these key topics and the page number on which each is found.

Table 2-5 Key Topics for Chapter 2

Complete Tables and Lists from Memory

Print a copy of Appendix C, “Memory Tables” (found on the companion website), or at least the section for this chapter, and complete the tables and lists from memory. Appendix D, “Memory Tables Answer Key,” includes completed tables and lists to check your work.

Define Key Terms

Define the following key terms from this chapter and check your answers in the glossary:

shell

Bash

internal command

external command

$PATH

STDIN

STDOUT

STDERR

redirection

file descriptor

device file

pipe

environment

variable

login shell

subshell

Review Questions

The questions that follow are meant to help you test your knowledge of concepts and terminology and the breadth of your knowledge. You can find the answers to these questions in Appendix A.

1. What is a variable?

2. Which command enables you to find the correct man page based on keyword usage?

3. Which file do you need to change if you want a variable to be set for user bob when this user logs in?

4. When analyzing how to use a command, you read that the documentation is maintained with the Techinfo system. How can you read the information?

5. What is the name of the file where Bash stores its history?

6. Which command enables you to update the database that contains man keywords?

7. How can you undo the last modification you have applied in vim?

8. What can you add to a command to make sure that it does not show an error message, assuming that you do not care about the information that is in the error messages either?

9. How do you read the current contents of the $PATH variable?

10. How do you repeat the last command you used that contains the string dog somewhere in the command?

End-of-Chapter Lab

You have now learned about some of the most important basic skills that a Linux administrator should have. Apply these skills by doing the following end-of-chapter lab. End-of-chapter labs have no solutions; you should be able to complete the end-of-chapter labs without any additional help.

Lab 2.1

1. Modify your shell environment so that on every subshell that is started, a variable is set. The name of the variable should be COLOR, and the value should be set to red. Verify that it is working.

2. Use the appropriate tools to find the command that you can use to change a user password. Do you need root permissions to use this command?

3. From your home directory, type the command ls -al wergihl * and ensure that errors as well as regular output are redirected to a file with the name /tmp/lsoutput.

© 2024 Pearson Education, Pearson IT Certification. All rights reserved.

800 East 96th Street, Indianapolis, Indiana 46240