This module gathers the Linux topics that sit off the main path, ordered by increasing depth: advanced editors, reproducible package management with Nix, then the inner workings of the kernel. None of these topics is required for an administration skill: they are deeper dives, to follow when the need arises. Intended audience: Linux administrators comfortable with the fundamentals who want to widen their toolbox and understand what happens underneath containers.
The module has nineteen lessons, this page included. The three blocks are independent: you can read the kernel internals without ever having touched Nix.
Advanced text editors
The editors met earlier in the course, nano and vi in the Fundamentals then Vim in Operate, are enough to fix things. But daily work benefits from a more comfortable editor: Micro, simple and modern for those Vim puts off; Neovim, the extensible rewrite of Vim; or advanced Vim itself, with splits, macros and plugins, to use its full power.
Micro is a modern terminal editor you can use without any learning curve. Neovim takes Vim and makes it extensible, configurable and plugin-oriented. Advanced Vim shows what you gain by staying on Vim: split windows, macros and plugins.
Nix and NixOS
Nix is a package manager of a different kind: it makes installations reproducible and isolated, up to describing a whole system in a single file with NixOS. It is a real change of model, which takes twelve lessons: an entry page, then eleven progressive guides, from the ecosystem to flakes and DevOps use cases.
The entry page of the Nix series explains what Nix changes and in which order to learn it; it details each of the eleven guides. The progression starts from the ecosystem and installation, goes through the data model (store, profiles and generations, which make rollback possible), the modern and classic commands, the language and the NixOS configuration, then development environments, nixpkgs pinning, flakes and DevOps use cases.
Kernel mechanics: cgroups, namespaces, capabilities
The course ends with three kernel mechanisms that administrators use every day without naming them. Cgroups cap the memory and CPU of a group of processes, which systemd drives for every service. Namespaces isolate what a process sees: its PIDs, its network, its mount points. Capabilities split the powers of root into separate privileges. Together, they form the basis of every container.
Each mechanism has its guide. Cgroups limit and measure memory, CPU and I/O. Namespaces isolate what a process sees: PIDs, network, mounts, users. Capabilities split the powers of root into privileges granted one by one.
Where did installation, WSL2 and advanced storage go?
This page used to be a catch-all for topics that have since found their place in the course. Installing a server, setting up WSL2 and identifying your system now open the course, in the Discover Linux module. Quotas, Btrfs and the device commands have joined the Storage module. Their pages are here:
- Install a Linux server and WSL2, Linux on Windows;
- Identify your Linux system;
- Disk quotas, Btrfs and Device commands.
Key points
- This module gathers the Linux deeper dives, off the main path, ordered by increasing depth.
- Micro, Neovim and advanced Vim go beyond the troubleshooting editor.
- Nix makes installations reproducible, over a series of twelve lessons.
- Cgroups, namespaces and capabilities are the kernel building blocks that systemd and containers rely on.