Learning Modern Linux A Handbook for the Cloud Native Practitioner (Michael Hausenblas)（Z-Library）

【One-Line Pitch】 A practical field guide to using Linux as a modern programming and operations environment rather than just an admin chore—written for cloud native developers, architects, DevOps practitioners, and SREs who want to work fluently across embedded boards, VMs, containers, and immutable distros. 【Book Arc】 - **Opening (~0%–10%)**: Sets the stage by defining "modern environments" (from Raspberry Pi to cloud VMs), tracing Linux's history from the 1991 Torvalds email through commercial adoption, and framing the book's goal of programming Linux, not just administering it. - **Early (~10%–30%)**: Builds the conceptual foundation—the kernel as hardware abstraction and API provider, CPU architectures (x86, ARM, RISC-V), core kernel components (memory, networking, filesystems, device drivers), syscalls, kernel modules, and eBPF as a modern extension mechanism. - **Early–Middle (~30%–50%)**: Moves into daily practice with terminals, escape sequences, shells (POSIX/sh, bash, fish), variables and environment handling, and modern command-line replacements like exa and bat, plus terminal multiplexing with screen and tmux. - **Middle (~50%–70%)**: Covers scripting and portability, access control from file permissions to capabilities, and filesystems as a fundamental building block—the layer where isolation, namespaces, and cgroups begin to matter. - **Late (~70%–90%)**: Applies the stack to real workloads: Linux networking and tooling, running applications via containers, systemd, modern filesystems, and immutable distros such as Flatcar and Bottlerocket, plus data sharing with SSH, rsync, and cloud sync. - **Ending (~90%–100%)**: Culminates in observability—how to monitor and manage workloads on modern Linux, tying the earlier kernel, shell, filesystem, and network knowledge into operational practice. 【Key Takeaways】 - **The kernel is an API, not the whole OS** (Early): It abstracts hardware differences and exposes syscalls; understanding this boundary clarifies why Linux is portable across architectures and environments. - **Namespaces and cgroups are the machinery behind containers** (Early): Visibility (namespaces) and isolation (cgroups) are separate dimensions—grasping this distinction explains how containers and VMs differ in their guarantees. - **The shell is a programming environment, not just a prompt** (Early–Middle): Shell vs. environment variables, POSIX portability, and child-process inheritance are the details that make scripts reliable rather than fragile. - **Modern CLI tooling repays the learning curve** (Middle): Replacements like exa and bat, plus multiplexers like tmux, turn terminal work from friction into a durable, session-based workflow. - **Access control extends well beyond file permissions** (Middle): Capabilities and related mechanisms matter once you move from single-user admin to multi-tenant, cloud native systems. - **Filesystems are a foundational building block** (Middle): They underpin isolation, containers, and immutable distro designs—not just storage. - **Networking is a layered stack you should be able to reason about** (Late): Sockets, TCP/UDP, and IP form the basis for both debugging and designing cloud native workloads. - **Observability is the end goal, not an afterthought** (Ending): Managing workloads on modern Linux means instrumenting and understanding the system, not just keeping it running. 【Reading Tips】 - **Skim the history and kernel-architecture chapters if you already know Linux internals**, but read the syscall and eBPF sections carefully—they frame everything later. - **Deep-read the shells, scripting, and terminal chapters hands-on**: type the commands, test variable scoping, and try tmux rather than just reading about it. - **Treat the access control and filesystem chapters as reference material** you'll return to when debugging permissions or container isolation issues. - **The networking and observability chapters are the payoff**—read them with your own workloads in mind, and connect them back to namespaces/cgroups from earlier. - **Use the book's code repository alongside the text**; the excerpts reference downloadable examples, and the material is designed for practice, not passive reading. 【Coverage Limits】 This guide is synthesized from stratified excerpts covering roughly the first half of the book in detail (introduction, kernel, shells, terminals, scripting) with lighter coverage of later chapters on networking, containers, systemd, immutable distros, and observability. Specific chapter titles, figures, and detailed examples from the second half are not fully represented in the excerpts.