Lab 2: Command Line Basics, Filesystem Navigation, and Package Management

Login to the ITC NetLab website using your previously established username and password.

Click the blue "New Lab Reservation" button and schedule a lab reservation for this course right now.

If you have a currently active reservation you will see a green "Enter Lab" button on your list of reservations. Click the green "Enter Lab" button. If not, you will need to make a reservation (see above) and then click the "Enter Lab" button.

Your virtual machines (VMs) will automatically power on when your reservation begins.

If your Linux VM has been powered off for some time since you checked the IP address in a previous lab you may have received a new IP address, so be sure to check your current IP address on the ens192 interface using the local console in Netlab again just like in the previous lab.

Connect to ITCnet from the computer you will be using as your administrative PC. In most cases this means connecting to the ITC Student VPN (unless you are using the Netlab Windows Administrative PC).

Run the PuTTY software on your computer (or the Windows Administrative PC) and enter in the IP address of your Linux server VM in the "Host Name" box and click the "Open" button.

Remember that just like using the local console to login to your server it is normal that nothing will appear when you are typing in your password. Just continue typing it and press enter when you have entered it to login.

Linux has a built in system of manual pages which contain important and useful information about the operating system as well as most software and commands installed on the system. These pages are accessed by running the man <command> command where <command> is replaced by the command or manual page name you want more information on.

Run the man file-hierarchy command to open the manual page explaining the filesystem hierarchy. The beginning of it looks something like this:

ben@2480-Z:~$ man file-hierarchy
FILE-HIERARCHY(7)               file-hierarchy               FILE-HIERARCHY(7)

NAME
       file-hierarchy - File system hierarchy overview

DESCRIPTION
       Operating systems using the systemd(1) system and service manager are
       organized based on a file system hierarchy inspired by UNIX, more
       specifically the hierarchy described in the File System Hierarchy[1]
       specification and hier(7), with various extensions, partially
       documented in the XDG Base Directory Specification[2] and XDG User
       Directories[3]. This manual page describes a more generalized, though
       minimal and modernized subset of these specifications that defines more
       strictly the suggestions and restrictions systemd makes on the file
       system hierarchy.

       Many of the paths described here can be queried with the systemd-
       path(1) tool.

GENERAL STRUCTURE
       /
           The file system root. Usually writable, but this is not required.
           Possibly a temporary file system ("tmpfs"). Not shared with other
           hosts (unless read-only).

       /boot/
           The boot partition used for bringing up the system. On EFI systems,
           this is possibly the EFI System Partition (ESP), also see systemd-
           gpt-auto-generator(8). This directory is usually strictly local to
           the host, and should be considered read-only, except when a new

You can navigate through and read the rest of the manual page using the up/down arrow keys on your keyboard to move one line at a time or the Page Up/Page Down keys to move a full screen at a time up and down. There are also ways to search through a manual page and do more complex navigation of the page which you can get information on by pressing the h key on your keyboard (press q to return to the manual page).

Take a few minutes to read through and familiarize yourself with the Linux File system hierarchy overview manual page.

When you are finished looking at the manual page press the q key on your keyboard to return to the command line of your server.

Anytime you are at a command prompt in Linux you are working from some location in the filesystem hierarchy, this is called your current working directory (abbreviated sometimes as cwd). You can see what your current working directory is using the pwd command which stands for "print working directory". In this case "print" means to print to the screen (not to a printer).

Run the pwd command like this:

ben@2480-Z:~$ pwd
/home/ben
ben@2480-Z:~$

In the example above you can see that my present location in the filesystem hierarchy is /home/ben or, in other words, the "ben" directory inside of the "home" directory inside of the root directory. You should see something similar but with your own username in place of ben.

The ls command is used to list the files in a directory you can find out more about the ls command by reading it’s manual page with man ls. Remember that the q key will exit out of a manual page and return you to the command line.

Run the ls command to get a basic listing of the contents of the current directory:

ben@2480-Z:~$ ls
ben@2480-Z:~$

So, it looks like there is nothing in our home directory, but is that really true? Like most operating systems files and directories can be "hidden" in Linux. This is not a security measure, but just a way to keep some files out of the way and prevent them from cluttering up directory listings. In Linux any file or directory starting with a period is a hidden file or directory that does not show up in regular directory listings.

Try running the ls -a command which will show you hidden files and directories too:

ben@2480-Z:~$ ls -a
.   .bash_history  .bashrc   .profile
..  .bash_logout   .lesshst  .sudo_as_admin_successful
ben@2480-Z:~$

Now you can see that there are in fact some files or directories inside of your home directory. Let’s get a "long" listing instead of a regular listing to get some more details about them:

ben@2480-Z:~$ ls -al
total 28
drwx------ 2 ben  ben  4096 Mar 13 20:27 .
drwxr-xr-x 3 root root 4096 Mar  8 16:38 ..
-rw------- 1 ben  ben    56 Mar 12 14:38 .bash_history
-rw-r--r-- 1 ben  ben   220 Mar  8 16:38 .bash_logout
-rw-r--r-- 1 ben  ben  3526 Mar  8 16:38 .bashrc
-rw------- 1 ben  ben    20 Mar 13 20:27 .lesshst
-rw-r--r-- 1 ben  ben   807 Mar  8 16:38 .profile
-rw-r--r-- 1 ben  ben     0 Mar  8 16:44 .sudo_as_admin_successful
ben@2480-Z:~$

That’s more like it! This listing gives lots of useful information including the permissions that are set on the file, the owner of the file, the group that owns the file, the size of the file, and the last time it was modified. We’ll explore permissions and ownership of files and directories later in the course.

For now it is helpful to know that the first character on each line indicates if the item is a file or directory. A file starts with a - and a directory starts with a d. So, if you see the a first column that looks like drwx------ or drwxr-xr-x you know it is a directory, but if you see a first column that looks like -rw-r—​r-- or -rw-r—​r-- you know it is a file. Don’t worry about all the r, w, and x letters or dashes occuring after the first position, those are information about the permissions. It’s just the first position that indicates whether it is a directory or file.

We can use the wget command to download a file from a website like:

ben@2480-Z:~$ wget https://info.ihitc.net/shakespeare.tar.gz
--2024-03-13 20:51:25--  https://info.ihitc.net/shakespeare.tar.gz
Resolving info.ihitc.net (info.ihitc.net)... 185.199.108.153, 185.199.111.153, 185.199.109.153, ...
Connecting to info.ihitc.net (info.ihitc.net)|185.199.108.153|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 2061602 (2.0M) [application/gzip]
Saving to: ‘shakespeare.tar.gz’

shakespeare.tar.gz   100%[===================>]   1.97M  --.-KB/s    in 0.05s

2024-03-13 20:51:26 (38.6 MB/s) - ‘shakespeare.tar.gz’ saved [2061602/2061602]

Check that the shakespeare.tar.gz file exists:

ben@2480-Z:~$ ls -al
total 2048
drwx------ 3 ben  ben     4096 Mar 13 20:51 .
drwxr-xr-x 3 root root    4096 Mar  8 16:38 ..
-rw------- 1 ben  ben       56 Mar 12 14:38 .bash_history
-rw-r--r-- 1 ben  ben      220 Mar  8 16:38 .bash_logout
-rw-r--r-- 1 ben  ben     3526 Mar  8 16:38 .bashrc
-rw------- 1 ben  ben       20 Mar 13 20:27 .lesshst
-rw-r--r-- 1 ben  ben      807 Mar  8 16:38 .profile
drwxr-xr-x 2 ben  ben     4096 Mar 13 20:45 sample-files
-rw-r--r-- 1 ben  ben  2061602 Mar 13 17:16 shakespeare.tar.gz
-rw-r--r-- 1 ben  ben        0 Mar  8 16:44 .sudo_as_admin_successful

There are many ways to do this. You may have seen the .. "direcotry" in the ls -al file listing. It’s not really a directory but a common and useful command line "shortcut" to move one directory up in the filesystem hierarchy which can be used as part of most paths on the command line so cd .. will change your working directory up one level. In this case that would put you in your home directory because you are currently one level below your home directory.

Other ways to do this would include giving the "full path" to your home directory (from the root, so starting with a /) like cd /home/ben or using the shortcut to the current user’s home directory which is a ~ (tilde) like cd ~. Both of these would work regardelss of what directory you are currently in on the system.

Again, note the / on the end of sample-files/ indicating we want to put it in a directory named sample-files instead of renaming shakespeare.tar.gz to a file called sample-files.

Start by moving up one directory (back to sample-files).

Try using the same rm command we used to delete a file.

ben@2480-Z:~/sample-files$ rm Shakespeare/
rm: cannot remove 'Shakespeare/': Is a directory
ben@2480-Z:~/sample-files$

Note the error message that rm doesn’t seem to be the right tool for this. rm is designed for removing files, not directories.

Try using the rmdir (remove directory) command instead

ben@2480-Z:~/sample-files$ rmdir Shakespeare/
rmdir: failed to remove 'Shakespeare/': Directory not empty
ben@2480-Z:~/sample-files$

Linux sure seems to be picky, rmdir won’t delete the directory unless it is empty first! On second thought we wouldn’t accidentally want to delete a directory full of files so maybe that’s a good idea. We certainly could go back into the Shakespeare directory and remove all the files first and then remove the directory. Doing that one at a time would be pretty tedius though so there is another shortcut which allows us to do something to all of the files in a directory. The * (asterisk) is called a wildcard and can be used to do something to every file in a directory. So, we could get rid of the Shakespeare directory like this (but wait don’t do it yet, there is another way!):

ben@2480-Z:~/sample-files$ ls -al
total 2028
drwxr-xr-x 3 ben ben    4096 Mar 18 16:01 .
drwx------ 3 ben ben    4096 Mar 18 15:54 ..
drwxr-xr-x 2 ben ben    4096 Nov  4  2004 Shakespeare
-rw-r--r-- 1 ben ben 2061602 Mar 13 17:16 shakespeare.tar.gz
ben@2480-Z:~/sample-files$ cd Shakespeare/
ben@2480-Z:~/sample-files/Shakespeare$ rm *
ben@2480-Z:~/sample-files/Shakespeare$ ls -al
total 8
drwxr-xr-x 2 ben ben 4096 Mar 18 16:14 .
drwxr-xr-x 3 ben ben 4096 Mar 18 16:01 ..
ben@2480-Z:~/sample-files/Shakespeare$ cd ..
ben@2480-Z:~/sample-files$ rmdir Shakespeare/
ben@2480-Z:~/sample-files$ ls -al
total 2024
drwxr-xr-x 2 ben ben    4096 Mar 18 16:15 .
drwx------ 3 ben ben    4096 Mar 18 15:54 ..
-rw-r--r-- 1 ben ben 2061602 Mar 13 17:16 shakespeare.tar.gz

The biggest problem with this method is what if there are many layers of subdirectories inside of the Shakespeare directory. Using this method we would have to go through all the directories and remove all the files followed be each level of directory until we got up to removing the Shakespeare directory. That has the potential to be a lot of work, so there must be another way!

Linux has a powerful (but obviously dangerous) command, the "recursive remove" command, which removes a directory as well as all of the files and subdirectories it contains. You must be careful with this command because, used incorrectly, you could obviously delete everything on your hard drive with a single command. We want to remove the Shakespeare directory and everything it contains so we can use the rm -r Shakespeare/ command like this:

ben@2480-Z:~/sample-files$ ls -al
total 2028
drwxr-xr-x 3 ben ben    4096 Mar 18 16:18 .
drwx------ 3 ben ben    4096 Mar 18 15:54 ..
drwxr-xr-x 2 ben ben    4096 Nov  4  2004 Shakespeare
-rw-r--r-- 1 ben ben 2061602 Mar 13 17:16 shakespeare.tar.gz
ben@2480-Z:~/sample-files$ rm -r Shakespeare/
ben@2480-Z:~/sample-files$ ls -al
total 2024
drwxr-xr-x 2 ben ben    4096 Mar 18 16:18 .
drwx------ 3 ben ben    4096 Mar 18 15:54 ..
-rw-r--r-- 1 ben ben 2061602 Mar 13 17:16 shakespeare.tar.gz
ben@2480-Z:~/sample-files$

If you didn’t run that command yet do the recursive remove now and remove the Shakespeare directory.

There is no "rename" command in Linux. Instead we just use the move command and move the file or directory from the old name to a new name. In this case that would look like mv Shakespeare/ shakespeare/

It is often the case that there are multiple uses for a command. One such command on Linux is the touch command. If you read the manual page for touch you will see that it is really designed to "change file timestamps", in other words to set the last modified time of a file to be the current time. In fact, this is why it is called touch in the first place, because it just "touches" the file which changes the last modified date.

However, it would be a mistake to think this is the most common use for the touch command. You see, when you use the touch command to try and update the timestamp on a file which does not actually exist yet touch will create a new empty file with that name. So, the most common use of touch is actually to create new empty files.

Try creating a new file named test-file using the touch command and verify that it now exists like:

ben@2480-Z:~/sample-files$ ls -al
total 2024
drwxr-xr-x 2 ben ben    4096 Mar 18 16:18 .
drwx------ 3 ben ben    4096 Mar 18 16:37 ..
-rw-r--r-- 1 ben ben 2061602 Mar 13 17:16 shakespeare.tar.gz
ben@2480-Z:~/sample-files$ touch test-file
ben@2480-Z:~/sample-files$ ls -al
total 2024
drwxr-xr-x 2 ben ben    4096 Mar 18 16:38 .
drwx------ 3 ben ben    4096 Mar 18 16:37 ..
-rw-r--r-- 1 ben ben 2061602 Mar 13 17:16 shakespeare.tar.gz
-rw-r--r-- 1 ben ben       0 Mar 18 16:38 test-file
ben@2480-Z:~/sample-files$

Note that the new file has a timestamp which matches the current date and time and also that it has a size of 0 because it is an empty file.

Remember you may not be in your home directory right now (remember how to check your working directory).

If you are not working in your home directory and you just use mkdir archive-experiments the archive-experiments directory will get created inside of the current working directory and not your home directory!

Solutions to this could involve changing your working directory to your home directory first or you could provide a full path to the directory you want to create like mkdir /home/ben/archive-experiments or even use the ~ (tilde) shortcut to your logged in user’s home directory like mkdir ~/archive-experiments

As we mentioned before the * (asterisk) is called a wildcard and can be used to do something to every file in a directory. In this case we’re asking TAR to include every file in the current working directory in the ~/archive-experiments/samplebackup1.tar.tz file.

What happened? What kind of mess could this make when you extract a TAR file that contined hundreds of files when it was created this way?

You may be wondering why we did not put a slash after ~/sample-files as you might expect for a directory (e.g. ~/sample-files/). In some older versions of TAR putting a slash on the end meant to put the files from that directory into the file but not the directory itself (just like when we created logbackup1.tar.gz with the asterisk wildcard). By leaving the slash off the end we are telling TAR to put the log directory,as well as it’s contents, into the TAR file so that when we extract it we will get a log directory made with the files going into it. Even though new versions of TAR automatically prevent you from creating TAR files without a directory path it is still best practice to make sure that you are including a directory as part of the TAR file.

What happened? If you extracted a tar file made this way you could potentially end up with several more levels of directories than you really want. In this case we got an extra var directory inside of experiments but if we were archiving something with a deeper path we would have even more extra subdirectories. You can actually see this during the tar file creation if you have verbose output enabled you saw that all the files being added to the tar had var/log/ in front of the filename. There are at least two ways to handle this which we will look at.

The first way, and probably the easiest to remember is to just change our working directory to one level above the directory we want to archive and create the archive like this:

ben@2480-Z:~/archive-experiments$ cd ~
ben@2480-Z:~$ tar -czvf archive-experiments/samplebackup3.tar.gz sample-files
sample-files/
sample-files/shakespeare.tar.gz
sample-files/test-file4
sample-files/shakespeare/
sample-files/shakespeare/All's Well That Ends Well.txt
sample-files/shakespeare/3 King Henry VI.txt
[...OUTPUT OMITTED...]
sample-files/shakespeare/The Winter's Tale.txt
sample-files/shakespeare/The Comedy of Errors.txt
sample-files/test-file2
sample-files/test-file3
sample-files/test-file

You can see in the verbose output from the tar command that all of the lines indicating the files being saved into the archive just begin with sample-files/ (a relative path) compare that with the output we got from the ways we were running tar before:

ben@2480-Z:~$ tar -czvf ~/archive-experiments/samplebackup2.tar.gz ~/sample-files
tar: Removing leading `/' from member names
/home/ben/sample-files/
/home/ben/sample-files/shakespeare.tar.gz
/home/ben/sample-files/test-file4
/home/ben/sample-files/shakespeare/
/home/ben/sample-files/shakespeare/All's Well That Ends Well.txt
/home/ben/sample-files/shakespeare/3 King Henry VI.txt
[...OUTPUT OMITTED...]
/home/ben/sample-files/shakespeare/The Winter's Tale.txt
/home/ben/sample-files/shakespeare/The Comedy of Errors.txt
/home/ben/sample-files/test-file2
/home/ben/sample-files/test-file3
/home/ben/sample-files/test-file

In that output from one of the ways we previously ran the tar command you can see each file is listed with the full path (/home/ben/sample-files/) in fact, on the first line there is a warning tar: Removing leading `/' from member names so they are actually being stored as home/ben/sample-files/ which is exactly how they unpacked (a new home/ben/sample-files directory was created inside of our archive-experiments directory) ! So you can see when you create the tar file exactly how the files will be unpacked.

The second way to create the tar file to work the way we want (in case we don’t want to change our working directory ourselves) is to run a tar command with the -C <directory> option. This will have tar temporarily change the working directory itself. Doing things this way would look like:

ben@2480-Z:~/archive-experiments$ tar -czvf samplebackup4.tar.gz -C /home/ben sample-files
sample-files/
sample-files/shakespeare.tar.gz
sample-files/test-file4
sample-files/shakespeare/
sample-files/shakespeare/All's Well That Ends Well.txt
sample-files/shakespeare/3 King Henry VI.txt
[...OUTPUT OMITTED...]
sample-files/shakespeare/The Winter's Tale.txt
sample-files/shakespeare/The Comedy of Errors.txt
sample-files/test-file2
sample-files/test-file3
sample-files/test-file
ben@2480-Z:~/archive-experiments$

You can see in the output above that the files are being included in the archive file in the same way as they were when we changed our working directory to the parent directory (/home/ben) of the one we wanted to archive first but we could just have tar do it for us.

Type exit to close the connection while leaving your Linux server VM running.