Learn Linux

Basic

Start here. The ideas everything else is built on, from the first command.

• Files & the Filesystem: One tree, rooted at /. Learn to move around it, read a listing, and see what a file name really points at. (about 35 minutes)
• Permissions & Ownership: An owner, a group and nine bits decide every "Permission denied". Learn to read them, change them, and work out which rule said no. (about 35 minutes)
• Users, Groups & sudo: A user is a number, a group is a list of numbers, and sudo is a rule file. Read all three and you can say exactly who may do what. (about 32 minutes)
• Processes & Signals: A process is a program running, with a number, a parent, an owner and a state. Signals are how you talk to one, and the process table is where you read what happened. (about 32 minutes)
• The Shell, Pipes & Redirection: What the shell does to a line before any program runs, the three streams every process gets, and how small tools are joined into pipelines. (about 35 minutes)
• Archives & Compression: Bundle a directory with tar, squeeze it with gzip, xz or zstd, and get it back intact: what each tool really saves, what it costs, and the ways an archive bites when you extract it. (about 30 minutes)
• Environment & Dotfiles: Shell variables versus the environment, how PATH finds a program, which startup files each kind of shell reads, and why a command works for you but not under sudo, in a script or for a colleague. (about 30 minutes)

Intermediate

What you need to run it for real: the moving parts and the ways they fail.

• Text Tools: grep, sed, awk: Find lines, cut columns, count and rank, rewrite text and add up numbers: a web server's log and a config file, investigated from the command line. (about 35 minutes)
• systemd & Services: A server is a set of programs that must start in order, stay up and leave a log. systemd is the program that does all three. (about 32 minutes)
• Packages & Repositories: Software on a server comes from a signed catalogue, not from a download page. Learn to read what apt does, and what it leaves behind. (about 32 minutes)
• Disks, Partitions & LVM: From raw blocks to a mounted filesystem, a full disk at 3 a.m., and a volume you can grow without downtime. (about 35 minutes)
• Host Networking: One machine's view of the network: its addresses, routes, names and sockets, and how to tell refused from timed out from unresolved. (about 35 minutes)
• SSH & Keys: Log in to other machines without passwords, read every refusal ssh can give you, and harden sshd without locking yourself out. (about 35 minutes)
• Bash Scripting: Turn a release you type by hand into a script you can trust: arguments and options, conditions and loops, functions, exit codes, set -euo pipefail with traps, tracing, quoting and the portability traps. (about 35 minutes)
• Scheduling: cron & Timers: Run things later and on a schedule with cron and systemd timers, and find out why a job did not run: lost output, a different environment, a stray %, overlapping runs and a machine that was off. (about 34 minutes)

Advanced

Production depth: hardening, recovery and the trade-offs behind the design.

• Namespaces & cgroups: Build a container by hand from ordinary processes: namespaces for what it can see, cgroups for what it may use, and the Kubernetes name for each piece. (about 35 minutes)
• Syscalls, Capabilities & seccomp: A program can do nothing on its own. Watch it ask the kernel, then see how root's power is split up and how a filter decides which requests get through. (about 35 minutes)
• Logs & Troubleshooting: A method for a machine that misbehaves, then six incidents to practise it on: CPU, memory, disk, a service, the network and a permission. (about 35 minutes)
• Performance: CPU, Memory & I/O: Load, saturation, iowait, page cache, swap, steal and queue depth: make each kind of slowness on purpose, learn its fingerprint, then triage a real one in sixty seconds. (about 35 minutes)
• Boot, Kernel & Modules: Firmware, GRUB, kernel, initramfs, systemd: what each stage reads, what survives a reboot, how to rescue a machine that will not boot, and how kernel modules load. (about 35 minutes)
• SELinux & AppArmor: A page with mode 644 still returns 403, and root is still told no. Learn the second lock on every door: read the denial, fix the label or the profile, and never switch the lock off. (about 35 minutes)

Learn Linux by using a real shell

Almost every server, container and cloud machine you will touch runs Linux. Knowing the Linux command line is the difference between reading an error and understanding it: why a file is "Permission denied" when its mode looks right, why a service will not start, why a disk is full, why a machine is slow.

These lessons put a simulated Ubuntu machine in your browser with a real shell. You type the same commands you would on a server, see the real output, and watch the machine change: files and permissions, users and sudo, processes and signals, pipes and text tools, systemd services, packages, disks and LVM, networking, SSH, cron, Bash scripting, performance, the boot process, containers and SELinux. Every lesson asks you to predict what a command will do before it runs, then has you break the machine and fix it.

The course starts at your first command and ends where Linux system administration and on-call work really happen: reading load averages, recovering a machine that will not boot, and finding out why the security policy said no when the file permissions said yes.

After these lessons you can

• Move around the filesystem and read ls -l, permissions and ownership without guessing
• Manage users, groups and sudo safely, and recover from a broken sudoers file
• Run, inspect and stop processes and systemd services, and read their logs with journalctl
• Write Bash scripts that fail safely, with set -euo pipefail, traps and shellcheck
• Diagnose a slow machine with top, vmstat, iostat and the USE method
• Fix a machine that will not boot, and explain what SELinux or AppArmor denied

Who it is for

Beginners who have never opened a terminal, developers who use Linux every day without being sure what is happening underneath, and engineers preparing for DevOps, SRE or platform roles and for the Kubernetes certifications that build on Linux.

Common questions

Do I need to install Linux to follow these lessons?

No. Each lesson runs a simulated Ubuntu machine inside your browser, with a real shell you can type into. Nothing is installed and nothing on your computer is changed.

Is this enough to get a Linux system administrator job?

It covers the day-to-day work interviewers ask about: permissions, processes, services, storage, networking, scripting, scheduling, performance, boot and access control. Pair it with practice on a real machine and you will be able to explain what you are doing, not just repeat commands.

Which Linux distribution is used?

Ubuntu 24.04, the most common server distribution. The SELinux lesson also uses a Red Hat style machine, because that is where SELinux is switched on by default.