Free through lesson 3

Linux for Beginners

From preparing your learning environment through file operations, text processing, permissions, how the shell works, processes and systemd, networking and shell scripting. Fifty lessons that take you to the point where you can log into a server and find things out for yourself. Every piece of command output was produced by actually running it.

Start from lesson 1 Unlock every course

Curriculum

The 50 lessons are grouped into seven chapters. Working through them in order is the best way, but you are welcome to dip into whatever interests you. Note: these commands cannot run inside the browser. Use the practice container you build in lesson 1, or the macOS terminal or WSL.

Chapter 1 — Getting started (lessons 1–6)

From building a practice environment you can break, through reading the prompt, the filesystem, cd and ls, looking things up in the manual, and working with files. Come out the other side and you can learn the rest by doing.

Preparing your learning environment

Sorting out what the word Linux actually refers to, then building a practice environment in a container that you can rebuild in seconds whatever you do to it.

Free

Terminals and shells

What the characters in your prompt mean, and the four commands that tell you who you are and where you are.

Free

The filesystem, absolute and relative paths

The structure of one tree rooted at /, what the main directories are for, and when to use each kind of path.

Free

Reading cd and ls properly

The two commands you will use forever. In particular, what each of the seven columns of ls -l represents.

How to read the manual

Look options up locally instead of memorising them. The structure of man, and type for finding out what a command really is.

File operations and the rm accident

Create, copy, move, delete. This is also where the irreversible accidents happen.

Chapter 2 — Files and text (lessons 7–14)

Look inside, rewrite, join, search, count. Every Linux tool is a part that takes input and produces output, and you use them in combination. You finish by actually crunching an access log.

Looking inside a file

When to use cat, less, head and tail, and tail -f, the one you reach for most during an incident.

The bare minimum of vi

The two modes, and :q! for escaping when you have made a mess. Start with just this.

Standard I/O and redirection

The difference between > and >>, and the fact that errors travel on a separate stream from standard output.

Pipes and filters

A mechanism that does nothing but feed the left-hand output into the right-hand input, and how to build up a long one-liner.

Searching with grep

The four options -i, -n, -v and -r, plus the context flags (-A, -B, -C) that are essential during an investigation.

Finding files with find and xargs

Finding files by criteria and acting on what you find. What you must always do before deleting.

Aggregating with sort, uniq and cut

The standard pattern behind 80% of log analysis: extract the column, sort, uniq -c, sort -rn.

[Project] Analyse an access log

Combining everything so far to get who did what and how it failed out of a real log.

Chapter 3 — Users and permissions (lessons 15–20)

Who can do what to which file. You come to understand what "Permission denied" means, and learn a fix that is not "it worked when I set 777". Nobody is handed a server without going through this chapter.

Users and groups

That the system manages users as numbers, how to read /etc/passwd, and the trap when adding someone to a group.

Reading permissions

Taking the ten characters of -rw-r--r-- apart. The x on a directory means something entirely different.

Changing permissions with chmod

Numeric versus symbolic notation, the trap in -R, and why 777 is not an option.

Ownership, chown and umask

Only root can change an owner. umask decides the permissions of files you create.

sudo and root

root is really just UID 0. The redirection sudo cannot help with, and how to work around it.

Special permissions

SUID, SGID and the sticky bit. Why passwd can write to /etc/shadow, and why /tmp is safe.

Chapter 4 — How the shell works (lessons 21–28)

Variables, PATH, config files, expansion, quoting and exit status. Once you know what the shell does before your command even runs, you can work out for yourself why something is not working.

Shell variables and environment variables

Why you cannot put a space around the =, and that a variable is not passed to child processes unless you export it.

How PATH works

How a command is found, and why you have to write ./script.sh.

Shell configuration files

What belongs in .bashrc versus .profile. Editing them alone does not take effect.

Aliases and history

Two tools that cut your typing. Ctrl+R in particular changes your working speed noticeably.

Wildcards and brace expansion

It is the shell doing the expanding, not the command. Which is why you can check before you run.

Quoting and escaping

When in doubt, use double quotes. Except awk and sed programs, which take single.

Command substitution and arithmetic expansion

Embedding a result with $(command). $(()) handles integers only.

Exit status and the && / || operators

Zero is success, non-zero is failure. The opposite of "0 is false" in other languages.

Chapter 5 — Processes and services (lessons 29–36)

See what is running, stop it, keep it running, read its logs. When someone says "the server is slow" or "the service will not come up", you will know where to start.

Processes and ps

What the columns of ps aux mean. Read RSS rather than VSZ, and the problem of grep matching itself.

Job control

&, fg and bg, and why your job dies when the ssh session drops. In practice, use tmux.

Signals and kill

kill does not mean force-quit. Why -9 must not be your first move.

Checking resources

Compare load average against the core count. In free, read available rather than free.

Managing services with systemd

start and enable are different things. When to restart and when to reload.

How to read the logs

Narrow the range with journalctl first, then widen it. Read rotated logs with zcat and zgrep.

Disk usage

When to use df and when du. Why deleting something does not free space, and inode exhaustion.

Scheduling with cron

The syntax, and the number one cause of a cron job failing: a different environment.

Chapter 6 — Networking and operations (lessons 37–46)

The tools for working through "it will not connect" from the top down, plus transfers, packages, archives and text processing. Only the things you reach for every day when you look after a server.

Checking network configuration

ip addr and ip route. It is entirely normal for ifconfig not to be installed.

Checking connectivity

Ping failing does not mean the host is down. Work through it from the top.

Ports and ss

ss -tlnp shows what is listening on which port. The difference between 0.0.0.0 and 127.0.0.1.

curl and wget

The standard shape of a health check, and the problem that without -f even a 404 counts as success.

Connecting remotely with SSH

Creating a key pair, and how permissions that are too loose get your connection refused.

Transferring files with scp and rsync

rsync sends only the differences. The traps of the trailing slash and --delete.

Package management (apt and dnf)

update and upgrade are different things. How to find out which package a command came from.

Archives and compression

tar only gathers; it does not compress. The three forms czf, tzf and xzf, and the habit of looking inside before extracting.

Substitution with sed

Without g it replaces only the first match. -i cannot be undone.

Working with columns in awk

How it runs { } for each line. An associative array aggregates by key in a single line.

Chapter 7 — Shell scripting (lessons 47–50)

Collect the commands you keep typing into a file. Conditionals and loops, and set -euo pipefail to keep accidents from happening. The chapter closes by drawing all 50 lessons together as a map.

Shell scripting basics

The shebang and the executable bit. Telling the three causes of "it will not run" apart by exit status.

Conditionals and loops

[ is a command, so it needs spaces. Use = for strings and -eq for numbers.

Arguments and error handling

Put set -euo pipefail at the top. That alone prevents a great many accidents.

Wrapping up and what to learn next

Pulling three investigation procedures together as a map, and deciding where to go from here.

Once you have finished all 50 lessons, learn to carry your whole environment around in a container with Docker. Membership unlocks every course.