Linux
The minimum you need before anything else works: filesystem, permissions, processes, pipes.
Your own environment on Windows
Install WSL, set up a user, and figure out where to keep your files so you can do the tasks locally.
One command, a reboot, your own user. A real Linux environment next to Windows, no second computer and no manual VM setup.
Where to keep your files, why a project in a Windows folder is slow, how to open the code in an editor, and what to do about permissions.
Basics
Why DevOps runs on Linux, and why 99% of servers run it too.
What lives where: /etc, /var, /usr, /home, /opt. Why everything is a file.
A short quiz on the first two lessons. 5 questions, you can retake it.
Reinforce the filesystem: type the commands and run the drill on the topic.
PID, ps/top, what SIGTERM and SIGKILL mean, and how to stop a process cleanly.
rwx, octal, owners and groups. Why a script won't run even after chmod +x.
Chain commands together, send output to a file, and catch stderr along with stdout.
Six questions on processes, permissions, and pipes. Wraps up the first track.
Booting
What happens from pressing the power button to login: firmware, bootloader, kernel, initramfs, systemd, udev.
An overview of the whole boot chain: from firmware to PID 1.
POST, BIOS vs UEFI, and MBR and GPT disk layouts.
What the bootloader does and where GRUB lives.
initramfs: a temporary root in memory.
systemd as init: targets, unit files, and parallel boot.
udev: how the system finds devices and populates /dev.
Quiz on the boot track. 5 questions, you can retake it.
Processes in depth
Lifecycle, states, signals, zombies, daemons, and watching processes.
How a process is born: fork, exec, exit, and the process tree.
Process states R/S/D/T/Z and where to find them.
Signals in depth: what gets caught and what doesn't.
Zombies and orphans: where they come from and how reaping clears them.
Daemons and background processes: setsid, nohup, disown.
Observing processes: ps, lsof, strace, /proc.
Quiz on the processes track. 5 questions, retakes allowed.
File system in depth
File types, links, /proc and /sys, tmpfs, partitions, swap, RAID.
Seven file types in Linux and the first character in ls -l.
Hard and symbolic links, and inodes.
The virtual filesystems /proc and /sys.
tmpfs: a filesystem in memory.
Disk partitions and swap.
RAID 0, 1, 5, 10: fault tolerance and capacity.
A quiz for the filesystem track. 5 questions, retake anytime.
Memory
Virtual memory, pages, page cache, swap, and the OOM killer.
Why a process needs a virtual address space, and what pages, page tables, and the MMU are.
How anonymous memory differs from file-backed memory, what page cache is, and why free shows little free memory.
How swap works, what swappiness controls, and the rules the OOM killer uses to pick a victim.
Quiz on the memory track. 6 questions, retakes allowed.
Isolation
Namespaces, cgroups, and how an ordinary process becomes a container.
namespaces: how the kernel hides the rest of the system from a process.
cgroups: how they limit CPU, memory, and IO.
A container as an ordinary process: namespaces + cgroups + capabilities.
Quiz on the isolation track. 5 questions, retakes allowed.
Tools
How users and groups work in Linux, where they are stored, and how sudo grants precise permissions without handing out root.
How to inspect a server's network setup: interfaces and addresses via ip, open ports via ss, and the routing table.
Basic regex syntax: anchors, classes, quantifiers, groups. Searching with grep -E and replacing with sed.
How to pack and unpack tar archives, how archiving differs from compression, and which formats you'll run into at work.
Team processes
Administration
How systemd starts and keeps services running: unit files, systemctl, autostart, and dependencies.
Where systemd stores logs and how to read them: journalctl, filtering by unit, time, and priority, and following in real time.
How to install and update software across distros: repositories, update vs upgrade, and the difference between apt, dnf, and apk.
How to run jobs on a schedule: the five-field crontab format, common mistakes, and where the output goes.
What environment variables are, how processes set and inherit them, and why app config lives in the environment.
Where disk space goes and why you get "disk full": df vs du, mount points, inodes, and deleted-but-open files.
How to parse JSON in the shell: jq for filtering fields, arrays, and API output without eyeballing it.
What an inode is, why "there's space but the file won't create", and how a hard link differs from a symlink.
What an fd is, where "too many open files" comes from, and how to find a descriptor leak.
Soft and hard limits, the open-files limit under load, and where to raise them for services.
Security
How key-based login replaces passwords: the key pair, authorized_keys, ssh-agent. Why it is more secure and how to set it up.
~/.ssh/config with host aliases, ProxyJump through a bastion, and why agent forwarding is dangerous.
How to protect the main entry point: disable passwords and root login, change the defaults, and close off the rest in sshd_config.
Where vulnerabilities in images come from, how scanners work, and why a scanner is a process and one signal among others, not a verdict.
The principle of least privilege in practice: roles instead of personal permissions, separation of duties, and why it limits the damage.
Operations
Where to keep passwords and keys: the problem with secrets in code, external stores vs file encryption, and rotation.
How to review outages without hunting for someone to blame: the incident lifecycle, blameless postmortems, and working on root causes.
Backups
What protects against what: RAID and replication vs. backup, RPO and RTO, snapshots, databases, and restic.
RAID, replication, and snapshots look like insurance, but they protect against different things. We break down which data loss scenario each mechanism actually covers.
How much data you can afford to lose, and how fast the system must come back up. How these requirements determine backup frequency and storage method.
Three copies, two kinds of media, one copy off-site. What immutable storage adds, and why zero verification errors became part of the scheme.
How restore chains work, how deduplication differs from an incremental backup, and how the grandfather-father-son retention scheme works.
How a snapshot happens in a second, how copy-on-write differs from a copy, and why the difference between crash-consistent and application-consistent matters for a database.
Mirroring, parity, and striping in plain terms. Degradation, rebuild, the risk of a second failure, and why RAID belongs in a backup track.
How pg_dump differs from copying the cluster's files, why you need a WAL archive, and how to restore to the minute before a bad query.
File backup with deduplication and encryption: init, backup, snapshots, restore, forget with prune, and check.
Nine questions on RPO and RTO, the 3-2-1 rule, snapshots, RAID, PITR, and restic. You can retake it.