A practical, server-focused guide to Linux — what each subsystem does, how the pieces fit together, when to reach for them, and where the failure modes are.
14 chapters 78 topics covered 15 hours audio Knowledge check on every topic
About This Course
Linux has a reputation for being a pile of arcane commands. Part of that is real — the surface area is enormous. Most of it is how it is usually taught: tutorials hand you commands to copy without the model underneath, so the moment something deviates from the recipe you are stuck. This course takes the opposite path.
It explains Linux from the kernel up, in the order that makes the pieces click. It starts with what the kernel is and the boundary it guards, then files and the filesystem, the shell and the text tools that compose into real work, then users and permissions, processes, packages, services, networking, storage, scripting, security, performance, and finally the kernel internals that containers are built from.
Every topic follows the same structure: what it is, how it works, when to use it, when not to, the common mistakes, and the best practices. Where two approaches compete, the course compares them and says when each one fits rather than leaving that work to you.
Who This Is For
Engineers who run, build on, or administer Linux servers, and those preparing to. The beginner can read it in order to build a mental model from zero; the experienced admin can jump to a topic to fill a gap or settle a decision. The focus is the server — the command line, services, networking, storage, and security — not the desktop.
What You Should Already Know
How to reach a shell — an SSH session or a terminal window is enough
The idea that a computer has a CPU, memory, and disks, and runs programs as processes
Roughly what a network is — an IP address, a port, a client talking to a server
No prior Linux administration experience required
How the Course Is Built
The fourteen chapters move from foundations outward. The early chapters teach the model — the kernel, files, the shell, text processing — because everything later leans on them. The middle chapters cover the daily work of running a server: users and permissions, processes, packages, systemd, networking, and storage. The later chapters take on scripting, hardening, performance troubleshooting, and the kernel-level features that underpin containers.
The examples lead with Debian and Ubuntu — apt, Netplan, AppArmor, ufw — because that is what most servers run, with the Red Hat equivalents called out wherever they diverge. A few principles run through every chapter, and they are worth stating up front.
Understand before you memorize
Linux rewards a mental model over memorized flags. Every tool is explained from the problem it solves before the options it takes, so you can reason about the cases no tutorial covered.
Everything is a file
Devices, kernel state, processes, and sockets are all reached through the filesystem. One set of tools works across all of them — which is why the same skills go a very long way.
The trade-offs are the point
A filesystem or a firewall that is right for one server is wrong for another. The course says which, and explains when not to reach for something.
Production is operations
A server you can trust differs from a demo in the unglamorous work: permissions, backups, patching, monitoring, and recovery paths. That work gets its own chapters.
What Linux actually is — a kernel plus a userland — and the boundary the kernel guards. Distributions and release models, the boot chain from firmware to systemd, and how a terminal, shell, and session fit together.
The single rooted tree and the standard that organizes it. Inodes and metadata, navigating and managing files, hard and symbolic links, mounting and /etc/fstab, and the filesystem types worth knowing.
How bash turns a line of text into a running command. Expansion and globbing, pipes and redirection, quoting, the environment, and job control — the mechanics behind every later chapter.
The composable filters that turn logs and config into answers. Viewing and paging, grep and regular expressions, sed and awk, find and xargs, and the field tools that count and report.
The access model that protects a multi-user system. Accounts and groups, permission bits and umask, ownership, the special bits, ACLs, and privilege through sudo and PAM.
What a process really is and how the kernel controls it. The fork/exec model, signals, monitoring with ps and top, scheduling priority, and reading process state through /proc.
How software is installed, tracked, and patched. Packaging concepts and repositories, apt and dpkg, the dnf/rpm equivalents, building from source, and the universal formats.
The init system that brings the machine up and keeps services alive. PID 1 and systemd, unit files, managing services, targets, timers, and the journal.
Turning commands into reliable programs. Script structure, variables and arguments, conditionals, loops and functions, exit codes and error handling, and scheduling with cron.
Reducing the attack surface of a server. SSH hardening, mandatory access control with SELinux and AppArmor, auditing, intrusion prevention, and patching and secrets.
Finding the bottleneck instead of guessing. A method first, then CPU and memory, disk and I/O, network troubleshooting, and tracing with strace and lsof.
The kernel features you tune and build on. Modules, sysctl, the namespaces and cgroups behind every container, containers from first principles, and eBPF.