Linux bash tutorial

This tutorial is designed to walk you through the basic commands you need in order to understand the Linux Bash program. Follow the steps one after each other to fully grasp the concept. Each step builds on the results of the previous one.

Table of contents:

• Step 00 - Opening a terminal
• Step 01 - The first command
• Step 02 - Navigating file system
• Step 03 - The two special folders
• Step 04 - Creating files and folders
• Step 05 - Deleting files and folders
• Step 06 - Copying and moving files and folders
• Step 07 - Reading files
• Step 08 - Finding files
• Step 09 - Searching the content of a file
• Step 10 - TAB-Completion, stopping a stuck program, and clearing the screen
• Step 11 - Getting help (RTFM)
• Step 12 - A basic file editor
• Step 13 - Variables and the environment
• Step 14 - Permanent settings
• Step 15 - Redirecting command output
• Step 16 - Stepping into the history
• Step 17 - Permissions system
• Step 18 - Changing permissions
• Step 19 - Making files executable
• Step 20 - Shell scripting
• Exercise - Test your knowledge

Step 0 - Opening a terminal

Open a terminal. In Windows you can try out the Powershell and SSH to log into a Linux system or you use the Windows sub system for Linux (WSL). Under Mac and Linux, you can simply search for terminal and use that.

In any case, you will need a Linux style terminal for this tutorial. If you do not have access to such a system, you can apply for an SCC, or NHR test account, which is detailed on this page.

This now is your working environment and the playground we will explore in the next steps.

Step 1 - The first command

You should have a blinking or solid courser now. This program now requires you to type a command via keyboard and press Enter or Return to run it. Mouse input is only partially possible and will not be covered here.

Please try out the commands:

echo Hallo
echo Hallo world
echo "Hallo world"
echo "Hallo\nword"
echo -e "Hallo\nword"

What did you observe? This was your first command.

A command usually follows this syntax: command <-OPTIONS> <--LONG_OPTIONS> <ARGUMENTS>

The options can use one dash or two dashes. Generally (according to the POSIX standard) short options with a single letter use a single dash and longer options use two dashes. You will learn a very many commands during the next few steps.

Step 2 - Navigating file system

We will now explore the file system. For this we need a few commands. Please try out the following commands:

ls
ls -l
ls -l -h
ls -a
ls -la
ls -la --color

What do you see? This command is the list command, which lists the contents of a folder. The output will depend on where you are currently located in the file system and it might also be empty for a fresh account in our system.

If you want to find out where you are, use the command pwd. What do you see? This command is called print working directory.

Under a UNIX file system folders are separated by a / sign, in fact the root of the file system is also called /. You can get there using our next set of commands

cd /
ls -l
cd ~
ls -la
cd /etc
ls -la
cd $HOME
pwd
ls -la

The new command is called cd and stands for change directory. This is your main tool to navigate through the file system.

With this set of commands you navigated to three different locations. You have now seen the root of the file system located at /, and you have seen the special folder called etc. Also you have seen two ways to get back to where you were before, which is called the home directory $HOME, for which ~ is an alias. This home directory is always your starting point. Every user has one and this is where you store your own files and folders.

Step 3 - The two special folders

You may have already noticed the two folder . and .., which are special folders that are everywhere.

The . folder is the current one. Try out cd . multiple times and do the pwd command after every try. You should be able to do this infinitely, since you change into the folder you are currently in every time.

The .. folder is the folder up in the file system, meaning on folder higher in the structure. For example, if you are in the folder /home/user/my-folder/ you can run the command cd .. and if you run the command pwd you will find yourself in the folder /home/user/. Try it out for yourself by running these commands:

pwd
cd ..
pwd
ls -la
cd ..
pwd
ls -la

Do this until you reach the root of the file system.

What you have done now is addressing the file system in a relative way. You addressed the next folder from the current folder.

Going from the root of the file system and navigating like this cd /home/user/my-folder is called absolute addressing.

Both way are useful and using them depends on the system. Addressing absolute is very stable on the same system and is always correct unless the folders do not exist any more. Addressing relatively is more versatile and independent of the system.

Step 4 - Creating files and folders

Now that you know how to navigate the file system, it is time to start creating files and folders yourself. An easy way for creating files is the touch command. Try out this set of commands:

cd $HOME
pwd
ls -l
touch myfile.txt
touch another_file
touch also a file
touch "also a file"
ls -l

What did you observe? You should now have 6 new files, but why so many?

Now lets create a folder. The command for this operation is called mkdir, which stands for make directory. Try out this set of commands:

cd $HOME
pwd
ls -la
mkdir demo.folder
mkdir another folder
mkdir "another folder"
mkdir another\ folder2
mkdir -p demo.folder
ls -la

How many folders do you have now? 4? The option -p only creates a folder if is does not exist.

This should demonstrate that spaces in the arguments lead to each word being it’s own file or folder. You can avoid that by using quotations marks, or just avoid space in names completely and replace it with for example and underscore _ or a dash - or another symbol. You can also use a . but starting with a dot has a different effect. Try out these commands:

cd $HOME
mkdir tryout
cd tryout
ls -la
touch .hidden_file
ls -l
ls -la

Step 5 - Deleting files and folders

Now that you have many files you might want to get rid of some of them. The command to do this is called rm and stands for remove. Try out these commands:

cd $HOME
mkdir demo2
cd demo2
ls
touch demo.file
ls
rm demo.file
ls
touch demo.file2
ls
rm -f demo.file2
ls 
touch demo.file3
ls
rm -i demo.file3
ls

This commands deletes files without regard for safety. If you would like to be asked for conformation, you need to use the option -i. This can be overwritten by the option -f, which forces the deletion.

Removing folders works similarly. Try out these commands:

cd $HOME
mkdir demo-delete
cd demo-delete
pwd
cd ..
pwd
ls
rm -ri demo-delete
ls

mkdir demo-delete2
cd demo-delete2
pwd
touch some_file
cd ..
pwd
rm -ri demo-delete2
ls

mkdir demo-delete3
cd demo-delete3
touch some_other-file
cd ..
pwd
ls
rm -rf demo-delete3
ls

In order to delete folders you need to use the recursive flag rm -r. Also, in this example we experimented with interactive and force mode to observe the differences.

If you do not always want to write the recursive flag, you can use the command: rmdir.

Step 6 - Copying and moving files and folders

Often it is needed to copy files or to move them to another part of the file system. For moving files the command is called mv and it works the same for files and folders. Try out this set of commands:

cd $HOME
mkdir second_folder
mkdir first_folder
mv second_folder first_folder/
touch super_file
mv super_file first_folder/second_folder/
ls
ls first_folder
ls first_folder/second_folder
rm -ri first_folder
ls

Here we created two folders, moved one into the other and moved a file into the second folder. Also, we removed the entire part of the tree with a single command.

Now, for copying we use the copy command: cp. This one works differently to the move command and requires a recursive flag for folders: cp -r. Try out these commands:

cd $HOME
mkdir second_folder
mkdir first_folder
cp -r second_folder first_folder/
ls
rm -r second_folder
touch super_file
cp super_file first_folder/second_folder/
ls
ls first_folder
ls first_folder/second_folder
rm -ri first_folder
ls
rm -i super_file
ls

Since copy creates a duplicate this operation could take a while for large files or folders. If you only want to move something, using the mv command is much faster since the file content is not touched but only the indexing of where it is located in the file system changes.

Step 7 - Reading files

Now you know how to create, copy, move, and delete files and folders. This looks a bit academic without actually reading the content of files.

The easiest way to read the content of a file is by using the command: cat. It will print the content of a file into the terminal.

If the files are a bit long, you can also try to use the two program head and tail which give you the first few or last few lines. You can set the number of lines by using the -n <number> option.

In case you want to read the full file and also move up and down to actually read it, you can use the program called less. This is called a pager program because it can display full pages of a file and also scroll up and down. In order to get out of that program, you can simply press the q button. Try of these commands:

cd $HOME
cat /etc/aliases
cp /etc/aliases ./
cat aliases
head -n 2 aliases
head -n 10 aliases
head aliases
tail -n 2 aliases
tail -n 10 aliases
tail aliases
less aliases
rm aliases

Step 8 - Finding files

Finding files is very useful especially if you remember a portion of the name and would like to find out where you have stored it. The write of this tutorial has lost many files in deep file system structures and so far always found them again using these commands.

You can use two different commands for this operation. The first is called locate and the second is called find. The locate command is a bit simpler since you just specify the portion of the name you remember and it will look starting from the directory you are in right now. This command may not be installed on all systems. The find command has many more options and can be used for very convoluted searches but generally is the better command if you need something specific. In order to explore these command, try out this set:

cd $HOME
mkdir folder1
mkdir folder1/folder10
mkdir folder1/folder11
mkdir folder1/folder12
mkdir folder1/folder13
mkdir folder1/folder14
mkdir folder2
mkdir folder2/folder20
mkdir folder2/folder21
mkdir folder2/folder22
mkdir folder2/folder23
mkdir folder2/folder24
cp /etc/passwd folder1/folder13

locate passwd
find . -name "passwd" 
find . -name "*pass*" 
find . -name "*sswd" 
find . -name "*ssw*" 

ls
rm -rf folder1
rm -rf folder2
ls

Try to compare the results and you may also copy the file to a different location and see if both are found. Similarly, you can rename the file and see if the patters match somehow.

You may have noticed the * symbol, which is used as a wildcard here. It can be used to be replaced by any number of characters and is very useful if you only know part of the name or are looking for something specific like all files ending with *.txt.

Step 9 - Searching the content of a file

Now that we can find files, we can also search the content of a file. This can be done with the very useful command called grep. Many scripts and advanced use cases involve this command so it must be useful. This example will explore the file searching abilities of this command, but it can do a lot more.

For now, what we cant to do is look for a specific pattern in a file. This can be done with this syntax: grep PATTERN FILE, where pattern can also be a regular expression. Try out these examples for a quick idea:

grep root /etc/passwd
grep -i RooT /etc/passwd
grep -n root /etc/passwd
grep -v root /etc/passwd

This command cannot only operate on files, it can also check in a path for files containing a pattern. For simplicity, we will recreate the setup of the last step and run the grep command:

cd $HOME
mkdir folder1
mkdir folder1/folder10
mkdir folder1/folder11
mkdir folder1/folder12
mkdir folder1/folder13
mkdir folder1/folder14
mkdir folder2
mkdir folder2/folder20
mkdir folder2/folder21
mkdir folder2/folder22
mkdir folder2/folder23
mkdir folder2/folder24
cp /etc/passwd folder1/folder13
cp /etc/passwd folder2/folder22/passright
cp /etc/passwd folder2/folder23/passwrong

grep -R root ./
grep -R root folder1/
grep -R root folder2/

ls
rm -rf folder1
rm -rf folder2
ls

Step 10 - TAB-Completion, stopping a stuck program, and clearing the screen

You have now written or copied many lines of folder instructions, especially for navigating, but there is a fast and easy way to do it. The bash offers an autocompletion feature. If a command or path can be expanded automatically, pressing the tab key will complete it until it is no longer unique. In case nothing happens, you can press the key again or press it twice to begin with. If there are multiple matching option, this will print them and you can select which to use by writing the next letter. You can explore this with by navigating folders:

cd $HOME
mkdir folder
mkdir folder/folder1
mkdir folder/folder2
mkdir folder/folder1/folder3
mkdir folder/folder1/folder4
mkdir folder/folder1/folder5
cd fol <TAB>
cd folder/folder <TAB><TAB>
rm -rf folder

Sometimes a program is running and blocking the bash from processing further inputs. This can be intentional, but it can also be a program that is stuck. You can always interrupt the currently running program by pressing the key combination CTRL+c. You can explore this with the following example that uses the sleep command. This command simply waits for the amount of time specified. Try out these commands:

sleep 30 <CTRL>+c

Now that you have many commands on your screen, you may want to clear it so you do not loose the next commands in a wall of text. This can be done with the clear command. Go ahead and try it.

Step 11 - Getting help (RTFM)

You have learned many commands, especially the sleep command. Have you ever wondered what time options you have with this command? The easiest solution is to use the very comprehensive help options.

Most commands have a built in help option following this syntax COMMAND --help, COMMAND -h, or COMMAND help. Alternatively, you can always check the manual 😉.

This manual can be reached using the man command. It will open the manual page in a pager program such as less. As described above, you can always get out using the q button and searching can be done by pressing the / (forward slash) and entering the word you are looking for.

Can you find the option to use the sleep command for 5 hours? There are multiple ways to do this. Try out the manual for the other commands.

Step 12 - A basic file editor

So far we have only been reading files, but what about editing? There are several command line editor which range from easy to use (nano), to very powerful (emacs), to strange and handy if you know what you are doing (vim). This page has been written using vim just because the editor likes it. Feel free to explore the other editors, but we will focus on nano.

You can open the editor either with or without a filename as the argument. Navigating the lines can be done by using the ARROW keys. Typing works like any other editor.

The options for saving and others are written at the bottom of the editor page with their key codes and you may need to know that this symbol ^ represents the CTRL. Here are some of the more important ones with their key combinations:

• CTRL+o Saving the file, supply the name or accept overwriting the file name
• CTRL+x Exit the editor, you will be prompted to save the file or discard changes
• CTRL+u Paste from the clipboard at the cursor location
• CTRL+w Search in the document
• CTRL+a/e Jump to line start/end
• CTRL+y/v Scroll page up/down
• ALT+u/e Undo/Redo changes

Explore the other option on your own and consult the manual for further information.

Step 13 - Variables and the environment

As with every program, you have the ability to use variables. In fact, you have already used one, which is called $HOME. You can always check the content of variables by using the echo command. Try out these commands to check some variables:

echo $HOME
echo $SHELL
echo $PATH
echo -e ${PATH//:/\\n}

Something new here is that the curly brackets have more abilities. In this case, they replace the colon symbol : with a line break symbol \n. We will not explores this feature further but just tease that is exists.

There are very many variables already set as part of the environment this bash program is running in. You can see them all of them by using the printenv command.

At this point, we assume you have some basic understanding of programming and know what variables are and how they function. Setting variables yourself can be very useful for storing and processing information. You can simply assign a value to a variable using the = sign, but make sure that there is no space between the name of the variable and the = as well as to the values behind it. Try out these commands:

HALLO=World
echo $HALLO

HALLO=WORLD
echo Hallo $HALLO 

HALLO="Hallo\n world"
echo $HALLO
echo -e $HALLO

These variables are only visible for this bash session for now. If you want to use them in other programs and scripts, you need to make them known to the environment. This can be done by using the export command. Once exported, you can find the variable using the printenv command. Removing commands can be done using the unset command Try out these commands:

HALLO=world
echo $HALLO
export HALLO
export myvar2="I have some more information"

printenv
printenv | grep -i HALLO
printenv | grep -i myvar

unset HALLO

printenv
printenv | grep -i HALLO
printenv | grep -i myvar

unset myvar2

This example does one more operation called a redirect or pipe with the | symbol. This will be explained in a later step but it shows again why the grep command is very useful.

Step 14 - Permanent settings

There are some locations/files where you can store your variables to be available each time you open a terminal or log into a server. One such file is called .bashrc and it is located in your home directory, reachable via the $HOME variable. You can freely edit this file using for example nano. There you can put all the exports and variables you like and they will always be available in a new terminal session.

One more interesting option to set in this file are aliases. You may have noticed that there are several commands, which have option you always use. For these you can assign aliases, for example one important one is alias rm='rm -i'. This will set the rm command up to always ask for permission to delete files, “much safer”. Some more interesting aliases are listed below, try them out:

alias rm='rm -i'
alias ls='ls --color'
alias ll='ls --color -l -h'
alias la='ls --color -a'
alias lla='ls --color -la -h'

alias cd..='cd ..'
alias ..='cd ..'
alias cd~='cd ~'
alias cd ='cd $HOME'

Try putting these changes into the $HOME/.bashrc file. Loading changed of that file into the currently used environment can be done using the source command like this: source $HOME/.bashrc.

Step 15 - Redirecting command output

You have already seen one redirect, via the | symbol, which is called a pipe. This takes the output the you would have seen printed in the terminal and redirect it as input into another program. The example you have already seen is piping some output into the grep command for filtering. The example was printenv | grep HOME and you also have access to all the option the grep command offers. For example you could also try this command, which should give a similar output: printenv | grep -i home.

There is one more interesting set of symbols, which are the chevrons >, >>, <, and <<. These are designed to redirect file output into commands or command output into files. For example you can quickly create files like this: printenv > my_env.txt. Now you can explore the content of this file using one of the tools you have already learned.

These also work with a command like echo. Try out these commands to explore the difference between > and >>:

echo "This is interesting" > my-file.txt
cat my-file.txt
echo "This is also interesting" > my-file.txt
cat my-file.txt

echo "This is interesting" > my-file.txt
cat my-file.txt
echo "This is also interesting" >> my-file.txt
cat my-file.txt

rm -i my-file.txt

echo "This is interesting" >> my-file.txt
cat my-file.txt
echo "This is also interesting" >> my-file.txt
cat my-file.txt

cat < my-file.txt

rm -i my-file.txt

Using one of the chevrons will create a file and override the content if it already existed and two chevrons will append to the file. You need to be careful using a single chevron, since you cannot recover deleted content. Make sure you either always manually delete the file and always user double chevrons or take great care before executing any command. It was at this moment, when the writer remembered many painful hours of recovering files overridden by being tired or distracted and forgetting a chevron.

Using the backwards chevrons does the same but takes a file and give the output to a command. The example above is a bit academic but using cat < my-file.txt at least demonstrated the use of them. Generally, the forward chevrons are used much more often.

Step 16 - Stepping into the history

The bash keeps a history of all the commands you have used in the past. You can scroll through them by pressing the UP-ARROW key. Similarly, you can print the entire history using the history command. Since this will be a rather long output, feel free to use your knowledge about redirecting and filtering to get only relevant commands. This can be done with grep for example: history | grep cat. You can clear the entire history with the -c option.

There are also some useful short cuts you can take with the history. For example the command !! (called: bang-bang) will run the last command again. Similarly the command !N will run the Nth command again. Or you can give part of the command as well like so:

• !TEXT: Will run the last command starting with “TEXT”
• !?TEXT: Will run the last command containing “TEXT”

Step 17 - Permissions system

This is now a more advanced concept. We include it here because it is very important to understand who can see and edit your files.

Every user has a username (for example: uxxxxx) and belongs to a few groups (for example: GWDG). The user is unique but might share a group with other, like the writers colleges who are also working for the GWDG. This allows on to create a file and allow the colleges to either read it or even write to it, without anyone else even know that this file exists. In order to set this up, you need to understand how Linux is using these permission.

Every folder and file has a permission system, which can be display using ls -l and you may have already seen it before. The output may look like this:

drwxr-x--- 2 uxxxxx GWDG 4096 Jan 27 11:20 test
-rw-r----- 1 uxxxxx GWDG    0 Jan 27 11:20 test.txt

The permission output is always in front, you also get information about who owns the file in this case uxxxxx and which group this files belongs to GWDG. These information are followed by the size and the last change date.

We will focus on the permissions for now. The first part contains a single letter followed by three triplets and we will simplify the output a bit:

The first letter indicates if this is a folder or not. The first triplet are the permission for the owner/user, the second triplet are for the group, and the last triplet is for everyone else. As you can see, there are three option for each triplet and they are rwx. The ones that are not used have a - instead of the option, showing that this permission is disabled.

• Reading a file or folder is only allowed if the r option is set.
• Writing to a file or folder is only allowed if the w option is set.
• Executing a file or entering a folder is only allowed if the x option is set.

Each of these apply separately to the owner, group, and everyone. In the example above, you can see that the file test.txt can be read and written to by the owner/user. The group can only read the file, and everyone else can not even read it.

The same applies to the folder, but since it is a folder it also requires the x option to be set, so the owner/user or the group can enter it.

Step 18 - Changing permissions

Let say you have a folder you would like to share with your group and they should be able to edit files you have in that folder. The group, you want to share it with is called GWDG and your user is a member of that group. The command to update the permissions is called chmod. It takes two arguments, the first is the permission you would like to set and the second is the file or folder you would like to update. Let’s start with the permissions. You can update the permission for either the owner/user u, the group the file belongs to g, everyone outside the group o, or all three a. Additionally, you have the option to give permission +, take away permission -, or set them to something specific =. Here are some examples and observe the change after every command:

cd $HOME
mkdir demo-perm
cd demo-perm
touch file.txt
ls -l

chmod u-w file.txt
ls -l
chmod u+w file.txt
ls -l

chmod g-w file.txt
ls -l
chmod g+w file.txt
ls -l

chmod a-w file.txt
ls -l
chmod a+w file.txt
ls -l

chmod u=rw file.txt
ls -l
chmod g=rw file.txt
ls -l

chmod u=rw file.txt
chmod g=r file.txt
chmod o= file.txt
ls -l

cd ..
ls -l
chmod -R a+w demo-perm
ls -l
ls -l demo-perm

rm -rf demo-perm

You have also now seen that you can change the permission of all files in a folder by using the -R flag, which runs the command recursively over the folder.

Step 19 - Making files executable

If you have been looking for programs online, you may have come across the request that you make this program executable if you would like to try it. This is also handled by permissions, remember the x option. This option allows folders to be entered and allows the bash to run a file like a program. This option can be set by the command chmod u+x file.txt.

We will explore a possible use case for this permission in the next step. As with all things, you need to be careful which files you make executable since you may accidentally allow a virus or malicious program to run if you do not know what the program actually does.

Step 20 - Shell scripting

You have seen many commands and explored many options for changing files. You also know about variables and have maybe wondered if you can create programs using the bash. Short answer, YES!

A bash program is called a script since the bash runs through it like a list of commands and executes them one after the other. Usually, the filename contain the ending .sh to make it clear that this is a program for the bash (or shell). This file always starts with a line like this #!/bin/bash, which is called the bang pattern and tells which program needs to be used for executing the commands. This also works for other types of interpreters like perl #!/usr/bin/perl or for example python #!/usr/lib64/python. Take care with the paths to the programs, they need to accurate. You can find default paths using the whereis command, which you can try out for the bash whereis bash.

After this initial line, you can write every valid command for the bash, for example a script could looks like this:

#!/bin/bash

#Always go home first
cd $HOME

#Set some initial variables
FOLD=my-folder
FILES=my-files

mkdir $FOLD
ls
cd $FOLD

#Create some files
touch "$FILES"
touch "$FILES"1
touch "$FILES"1
touch "$FILES"2
ls -l > $HOME/result.txt

As you can see, the marker for a comment is the # symbol.

You can copy this script into a file and change the permissions to make it executable. Say, you copied it into the file called my-script.sh, you can set the x permission by running the command chmod u+x my-script.sh. Now that the script has the correct permission, you can run it using the ./ logic. Meaning, you can run the script like so: ./my-script.sh.

A bash script can also handle if statement or for loops, but this is a tale for another tutorial (coming soon™).

Exercise - Test your knowledge

Now that you know about a lot of different commands, you can test you knowledge. We have prepared an exercise for you. In order to get this exercise, you will need to use a new command. This time, we will only give you the command and you can use the manual to find out about the programs abilities.

git clone https://gitlab-ce.gwdg.de/hpc-team-public/bash-tutorial.git

Now you should have a folder called bash-tutorial. Change into it and read the file called README.md. It contains all the information you need for doing this exercise.

The reason for using git here is that generally, code or other work is often distributed using this method.

If you would like to share some feedback with us regarding this tutorial, you can write us an Email and put [GWDG Academy] into the title.