20 Linux Commands You Need for the A+ (and Beyond)

CompTIA's A+ certification is one of the top entry-level certifications in the IT industry. It covers a wide range of topics without going too deep. This makes it useful for IT pros looking for a solid foundation to help launch their career.

Because it's an entry-level cert, it may also be the first time some cert-seekers have to understand basic Linux commands. The command line in general can be intimidating, and when you add in a new operating system, it can sound even worse.

Fortunately, there's nothing too difficult about the Linux commands listed in the A+ objectives. A little studying and practice will get you familiar with these commands in no time.

Basic Linux A+ Command List

Objective 1.9 of the CompTIA A+ Core 2 (200-1002) exam calls out 20 different Linux/Mac OS commands.  Those *nix commands are:

1. ls
2. grep
3. cd
4. shutdown
5. pwd
6. passwd
7. mv
8. cp
9. rm
10. chmod
11. chown
12. iwconfig
13. ifconfig
14. ps
15. su
16. sudo
17. apt-get
18. vi
19. dd
20. kill

That gives us a specific set of commands to focus our efforts on. Before we jump into examples, let's cover some basic information on switches and man pages.

Understanding Linux Commands: switches/options

You'll notice that some of our command examples include a dash "-" followed by some characters, like** ls -l.** The dash plus additional characters are commonly referred to as "switches" or "options". These switches are optional (i.e. you can use the command without them). Generally, a switch will modify what a command does in some way.

For example, simply adding the **-l **switch to ls tells us a whole lot more about file permissions.  Often, you can combine switches to apply multiple options at once.

Understanding the concept of switches is an important part of mastering Linux commands.

Understanding Linux: man/info & help

There are tons of different options and ways to use even basic Linux commands. Here, we'll focus on common usage and avoid getting too far into the weeds. However, it's important to know you can get detailed information on command usage straight from a Linux terminal. Generally, this will involve typing **man ** (e.g. man ls), **info **, or command –help. You can also find man pages online, for example this fairly long list on man7.org.

Don't worry about mastering all the different usage scenarios now. Just know that there is a place to look if you ever get stuck working with a command.

Linux Commands: Prompts, Home Directories, Examples

When you are looking at a Linux terminal, you'll see a prompt that usually ends with a dollar sign $ (for normal users) or a pound sign # (for the superuser or root user). Often that prompt is in the form of username@computername: (~ means the user's home directory) You'll get used to this fast, but for beginners it's important to note that the commands are everything after the prompt.

For example, in this article, we're using a user named "cooluser" on an Ubuntu install. Therefore, preceding most of our commands you'll see this:

Remember: There is no need to type anything before the $ if you're practicing with the examples here.

Your prompt will look a little different, usually with a username behind it. The prompts you see in other online examples may differ as well. Some may have different prompts. Some may exclude the prompt altogether. Others may just use the $ or # to indicate if commands are run as a normal user or a superuser/root user.

Avoiding Typos: Tab Completion is Your Friend

When you're working in a command line, it's easy to make typos. On most modern Linux systems, tab completion can help minimize typing errors. The way tab completion works is simple: hitting the TAB key will complete as much of the command as possible for you given what you have typed. This is particularly useful when dealing with different paths on a system.

For example, if we were going to change directory (using cd) from /home/cooluser/ to /home/cooluser/subdirectoryone and there was no other file or directory starting with an "s" in /home/cooluser/, simply typing **cd s **and pressing the TAB key will autocomplete to cd subdirectoryone.

20 Linux Commands: Explanations and Examples

With those prerequisites and tips out of the way, let's dive into the list of Linux commands for the A+ exam. For each command, we'll provide an explanation and examples to help you get started.

We've combined a few of the entries, specifically "pwd vs password", "iwconfig/ifconfig", and "su/sudo", to be consistent with how they are listed on the A+ exam objectives.

Command 1: ls

ls is a very common Linux command. It is used to list files and directories within a directory. When used with different switches, ls can tell you a lot about files and permissions.

ls by itself prints (displays) all the files and directories in your current working directory:

ls /path/to/another/directory/ lists all the files and directories in /path/to/another/directory/ (fill in the path to make sense for your system). You can use this same /path/to/another/directory/ approach with other switches and other commands as well. In this example, we list the files in /tmp/tempfiles/:

**ls -l **lists files and directories as well as their permissions, user that owns the file/directory, group that owns the file/directory last modified date/time, and the total file system blocks used.

**ls -a **includes hidden files, those that start with a ".", in the **ls **output.

Command 2: grep

**grep **looks for specific patterns in text files or other input such as the output of a command. Specifically, grep looks for and displays the lines that match a given regular expression a.k.a. regex.

For example, to find the word "sysadmin" in the plaintext file "learningnotes.txt" we can use grep "sysadmin" learningnotes.txt

If we wanted to narrow that down to times we typo'd sysadmins with an apostrophe, we can use grep “sysadmin’s” learningnotes.txt

To do a case insensitive search, we can use the **-i **switch, like this: **grep -i “sysadmin” learningnotes.txt **(notice in this check, we also found "SysADmIn").

It's also very common to use grep to parse the output (stdout) of a command. To do that, we simply type the command, a pipe "|", and then the grep command we want to apply. For example, **ls | grep “.txt” **will print only files with .txt in their name in the current working directory.

Pro-tip: In practice, a command like find is often better than using **grep **and **ls **together.

Command 3: cd

cd is used to "change directories". If you need to navigate to different directories, cd is likely the tool you'll want. When working with cd, it is important to understand absolute paths vs relative paths. Absolute paths start with a leading /. Relative paths do not start with a leading /. The leading / is the root directory on your system. With relative paths, cd starts from your current working directory.

Let's use an example to get a feel for cd and paths. In our example, our home directory is /home/cooluser. In that directory, there is one subdirectory, /home/cooluser/subdirectoryone. In /home/cooluser/subdirectoryone there is one more subdirectory, /home/cooluser/subdirectoryone/subdirectorytwo.

Let's start at /home/cooluser. From here, we can **cd subdirectoryone **to enter subdirectoryone (pwd as we'll see in a subsequent section prints the current working directory).

From here, we can **cd subdirectorytwo **to move to the next subdirectory.

Now that we're in /home/cooluser/subdirectoryone/subdirectorytwo, let's try to get back to subdirectoryone with cd subdirectoryone

Interestingly, we get a "cd: subdirectoryone: No such file or directory" error. But we know subdirectoryone exists. We also know **cd subdirectoryone **got us to /home/cooluser/subdirectoryone just a few minutes ago. So, what's the difference now?

In our first attempt, subdirectoryone was within our current working directory. That is, it was available to cd to relative to where we were at (/home/cooluser). Once we were in /home/cooluser/subdirectoryone/subdirectorytwo, there is no subdirectoryone relative to our current working directory, so the cd command fails.

We can address this problem by using cd with the absolute path** **of /home/cooluser/subdirectoryone, like this cd /home/cooluser/subdirectoryone.

Alternatively, we can use **cd .. ** to move "up" one directory, like this:

To move to the "root" directory of a system, use cd /

Command 4: shutdown

**shutdown **as you may expect, powers off, halts, or reboots the system depending on the switches you use. The general usage for shutdown is shutdown [options] [time] [wall]. "Wall" is a message to be displayed to users when the shutdown begins.

shutdown by itself is used to power down the system (usually with a default one-minute delay).

**shutdown -H **does a halt instead of a power down.

**shutdown -r **kicks off a reboot

**shutdown now **or **shutdown +0 **shuts down the system immediately. Without the one-minute delay.

**shutdown -r +5 **begins a reboot of the system in five minutes.

**shutdown -c **cancels a pending shutdown command.

Command 5 & 6: pwd vs. passwd

Sometimes, password is abbreviated as pwd. Therefore, you may expect that the **pwd **and **passwd **commands do something similar, but they don't. pwd displays the present working directory. passwd is used for changing passwords.

For example, if we go back to our previous directory examples, when we are in /home/cooluser, **pwd **will print that to the screen.

The passwd command on the other hand will bring us the prompt to change our own password.

If we wanted to change a password for another user named "seconduser" we need sudo privileges, which we have (more on sudo below), and then we just enter sudo passwd seconduser and follow the prompts.

Command 7: mv

The **mv **command is used to move (not copy) files from one place to another. Because of how it works, **mv **is also useful for renaming files. **mv **has a variety of options related to backups and overwriting or not overwriting files, but basic usage is as simple as.

In the example below, we have a "coolpictures.png" file in our current working directory we want to rename to "awesomepics.png". We can do that with the command mv coolpictures.png awesomepics.png.

You can use mv with absolute or relative paths. To move our "accounting.csv" file to /tempdir we can use the command mv accounting.csv /tmpdir.

Similarly, to move our "longessay.docx" file to /home/cooluser/subdirectoryone and rename it "greatessay.docx" while in /home/cooluser, we can use mv longessay.docx subdirectoryone/greatessay.docx.

To move all the files in a directory, you can use an asterisk * can be used as shorthand for "everything here". For example, to move the contents of our current working directory to /tmpdir we can use the command mv * /tmpdir.

Command 8: cp

Once you understand mv, it's easy to understand cp. They work similarly, but **cp **copies instead of moves files. Going back to our original mv coolpictures.png awesomepics.png. example, we can use **cp coolpictures.png awesomepics.png **to make a copy of "coolpictures.png" named "awesomepics.png" without getting rid of the original.

Command 9: rm

**rm **is used to delete or "remove" files. Use caution when working with rm, as you won't always have the benefit of something like a recycle bin on Linux systems.

To remove the file "junkfile.txt" that is in our current working directory, we can use the command rm junkfile.txt

If the file was in a different directory, we could use absolute and/or relative paths to delete it. Like many other commands, **rm **can be used with the asterisk wildcard character.

If you need to delete a directory with files in it, **rm **without any switches won't cut it. You can (with caution!), use rm -r though. For example, from /home/cooluser/subdirectoryone we can use **rm -r subdirectorytwo **to delete /home/cooluser/subdirectoryone/subdirectorytwo and its contents.

Command 10: chmod

Linux file permissions can get a bit complex, which is why we wrote a piece that focuses on chmod and chown[a]. For now, let's focus on the basics of these two commands. Here we'll look at chmod, which is used to modify the read, write, and execute permissions on a file. For example, suppose we wanted to add "execute" permissions for all users to our "interestingscript.sh" file.

We can use the command sudo chmod +x interestingscript.sh to do that. As you can see in the example below, the "x" (for execute) permission was added for the user that owns the file (the "x" that is the fourth character in the **ls -l interestingscript.sh **output), group that owns the file (seventh character), and everyone else (tenth character).

Command 11: chown

chown is how you configure who owns a file. Sticking with our "interestingscript.sh" example, suppose we wanted to change the user that owns the file to "seconduser" and the group to seconduser's group. For that, we can use the command sudo chown seconduser: interestingscript.sh.

If we wanted to just change the user that owns the file, but not the group, we could have omitted the colon :. i.e. use the command sudo chown seconduser interestingscript.sh.

Command 12 & 13: iwconfig vs ifconfig

Before we dive in here, it's worth noting that the **ip **command is becoming more and more common on modern Linux systems. In production environments, you may want to get used to using **ip **instead of ifconfig. In fact, on many modern Linux distributions, you may need to manually install **iwconfig **and ifconfig.

That said, let's focus on the two called out by the A+ exam objectives for now, **iwconfig **and ifconfig. Both of these commands  are used to configure and obtain information on network interfaces. The key difference is that **iwconfig **focuses specifically on wireless interfaces while **ifconfig **is a general utility. There is plenty you can do with **iwconfig **and ifconfig, but we'll focus on the basics here.

To display network interface information such as IP address, broadcast address, and subnet mask for all active interfaces, simply enter the ifconfig command with no switches.

Similarly, to display wireless specific information, like signal level, managed frequency, and access point MAC addresses, simply enter the iwconfig command

To display information on ALL interfaces (active or inactive) use ifconfig -a

Command 14: ps

**ps command is used to get information on process status for running processes. **This command can get a bit confusing because there are two approaches to options. The BSD (Berkeley Software Distribution) style options do not use a dash. On the other hand, Linux/Unix/GNU style options that do use dashes. To keep things consistent, we'll focus on the *nix style here.

**ps **by itself displays all the running processes for the current shell. Here, we can see the PID (Process ID), associated terminal (TTY), amount of CPU time used (TIME), and specific command (CMD) associated with each process.

**ps -e **and **ps –**A give similar output to ps but includes all active processes.

Adding the **-F **switch will provide more detail on running processes. Specifically, with **ps -F **now we see the user ID of the process owner (UID), the process ID (PID), the parent process's PID (PPID), CPU usage (C), set size of memory allocated (SZ), resident set size (RSS) which is the actual memory in use in kilobytes, processor associated with the process (PSR), time the process started (STIME), and the specific name of the command (CMD).

Like with other commands on the list, you can combine options to further modify the output of ps.

Command 15 & 16: su/sudo

The command **su **is used to switch to a different user. The command **sudo **is used to run a command as a specific user, buy default the superuser or root. Generally, to use **sudo **a user must be granted specific permissions, often in a file at /etc/sudoers. Let's take a look at a few **su **and **sudo **examples.

Note: use caution when running commands as a "root" user or superuser. If you don't have a specific reason to do so, try and avoid running commands with elevated privileges.

To run a command as root, we'll use **sudo **and supply our password when prompted. Here, we'll use the **whoami **command which simply prints the current user's username to the screen. Remember that the specific command we use is arbitrary and sudo can be used with most other commands.

To run a command as "seconduser" we can use the command **sudo -u seconduser ** and enter our password when prompted.

If we actually want to switch the account we are using, that's where **su **comes in. For example, to switch to our "seconduser" account, we can use the command su seconduser and input the password for the "seconduser" account. To exit running our shell as "seconduser", we simply type exit.

Command 17: apt-get

**apt-get **is a command used for package management on systems like Debian and Ubuntu that use .deb packages. If you want to do things like install, remove, or update packages, **apt-get **can help.

It's important to remember that apt-get looks for packages in specific repositories. That means in certain situations, you may need to modify the default repositories your system uses or add additional options to your commands. Often, you can find a list of repositories for your system at "/etc/apt/sources.list".

To keep things simple we'll focus on the basic apt-get commands. In many cases, you'll need to run **apt-get **as the superuser to have it work, so we'll begin our examples with sudo.

To install a package from a default repository, you can use the command sudo **apt-get install **. For example, to install the Firefox web browser on Ubuntu, we can use sudo apt-get install firefox.

… and confirm when prompted.

Similarly, to remove (uninstall) a package, we can use sudo **apt-get remove **. Therefore, to uninstall Firefox, we can use sudo apt-get remove firefox.

… and confirm when prompted.

For upgrades, updates, and cleaning up old packages, these three commands come in handy:

Command 18: vi

**vi **is a text editing program that has been around for a long time. Many will tell you they favor other text editors, like nano or vim, but you'll still find **vi **in the wild today. Here's a quick crash course on vi.

To open a file in your current working directory for editing, type **vi **. For example, to edit our "learningnotes.txt" file, we can enter the command vi learningnotes.txt.

That will open the currently blank file in the vi text editor.

Before we begin adding text, we'll press the INSERT key on our keyboard to enter vi's insert mode.

Now that we're in insert mode, we can use our keyboard to type some text.

When we're ready to exit and save the file, first we press the ESC key to exit insert mode. Then we type **:wq and press ENTER **to save and exit (or write & quit).

That's it, our changes have been saved to "learningnotes.txt". We can use cat learningnotes.txt to print the contents of "learningnotes.txt" to the screen and verify.

Command 19: dd

**dd **is the data duplicator command and it is used for converting and copying files. Use cases for **dd **include creating ISO files, creating bootable USB drives, copying master boot records (MBRs), backing up drives, and converting the case of a text file.

Because **dd **is a powerful tool, generally only the superuser can use it. The basic usage of **dd **is

Let's look at a few examples.

To convert the "learningnotes.txt" in our current working directory file from our **vi **example to a version named "LEARNINGNOTES.TXT" with all capital letters, we can use sudo dd if=learningnotes.txt of=LEARNINGNOTES.TXT conv=ucase.

To convert "LEARNINGNOTES.TXT" to an all lowercase version named "lowercasenotes.txt" we can use sudo dd if=LEARNINGNOTES.TXT of=lowercasenotes.txt conv=lcase

While these are very basic examples, **dd **is quite powerful and can be useful for more practical system administration tasks like creating backups or changing the encoding of a file.

Command 20: kill

**kill **is used to stop a running process. If you're familiar with stopping a process using **taskkill **or Task Manager in Windows, **kill **should be easy to understand.

The most basic syntax of **kill **is:

To get the PID of a process with commands we've already covered, **ps **will be helpful. Below, we ran **ps -a **and noticed a **ping **running that we want to kill.

Because the associated PID is 11835, we simply use the command kill 11835 and afterwards, the ping is no longer running.

**Pro tip: **If you already know the name of the process you need a PID for, many Linux systems already have the pidof command that can simplify things. Simply use **pidof **. For example, to get the PID of top, we can use pidof top.

Final Thoughts: There's Plenty More to Learn

It may seem like the Linux commands on the CompTIA A+ are a lot to learn, but with some practice it can be done. After you get the basics down, there is plenty more to learn about the Linux command line. As you start putting your knowledge to practice, you should start getting a better feel for how everything fits together.

You'll also likely run into cases where you need an option or command you haven't used before. Understanding how to read man pages and use your foundational knowledge will help when that time comes. Remember, this is only the beginning.