Operating Systems, Linux, and Containers — A Practical Guide

Contents

96 chapters, one page each. Prefer one long page? Read the whole book on one page.

1. What you will be able to do at the end1 min
2. How this guide is organised1 min
3. Contents4 min
4. Part 0 — Start here
5. 0.1 Who this is for1 min
6. 0.2 The learning flow1 min
7. 0.3 Build your lab1 min
8. 0.4 The little computer science you need1 min
9. 0.5 How to read a manifest/command you've never seen1 min
10. 0.6 How not to get stuck1 min
11. 0.7 The series: OS → networking → security → HTTPS2 min
12. 0.8 The Go labs: the OS from inside a program1 min
13. Part 1 — What an operating system actually does
14. Chapter 1 — The OS as a resource manager and a liar3 min
15. Chapter 2 — Kernel space vs. user space, and the system call4 min
16. Chapter 3 — A program's whole life, from ./app to exit code4 min
17. Part 2 — Processes, threads, and the CPU
18. Chapter 4 — What a process actually is3 min
19. Chapter 5 — Process states and the process lifecycle3 min
20. Chapter 6 — fork() and exec() : how new processes are born4 min
21. Chapter 7 — Threads: sharing everything except the stack3 min
22. Chapter 8 — Scheduling: who gets the CPU, and for how long3 min
23. Chapter 9 — Interrupts, context switches, and why they're not free3 min
24. Part 3 — Memory management
25. Chapter 10 — Virtual memory: every process's private lie4 min
26. Chapter 11 — Paging, page faults, and the TLB4 min
27. Chapter 12 — The memory hierarchy: registers to disk, and why it exists4 min
28. Chapter 13 — Memory allocation and the OOM killer4 min
29. Part 4 — I/O and storage
30. Chapter 14 — The I/O stack: from read() to the disk platter4 min
31. Chapter 15 — Filesystems: inodes, directories, and journaling5 min
32. Chapter 16 — Caching, buffering, and disk scheduling4 min
33. Part 5 — Concurrency and inter-process communication
34. Chapter 17 — Race conditions at the OS level4 min
35. Chapter 18 — Locks, semaphores, and deadlock4 min
36. Chapter 19 — Pipes, sockets, shared memory, and message queues4 min
37. Chapter 20 — Signals: the OS's tap on the shoulder4 min
38. Part 6 — Boot and the kernel
39. Chapter 21 — From power button to login prompt4 min
40. Chapter 22 — Init systems, kernel modules, and device drivers5 min
41. PHASE 2 — Linux fundamentals
42. Part 7 — The filesystem hierarchy and navigation
43. Chapter 23 — Everything is a file (almost)4 min
44. Chapter 24 — The Filesystem Hierarchy Standard, and why /etc isn't random3 min
45. Chapter 25 — Permissions, ownership, and links4 min
46. Part 8 — Essential commands, in depth
47. Chapter 26 — File and directory operations you'll use daily4 min
48. Chapter 27 — Text processing: grep , sed , awk , and pipes4 min
49. Chapter 28 — Redirection and the pipeline as a design pattern4 min
50. Chapter 29 — Finding things: find , locate , which , grep -r3 min
51. Chapter 30 — Package management: how software gets onto a Linux box3 min
52. Part 9 — Process management in practice
53. Chapter 31 — Watching and controlling processes: ps , top , htop , kill4 min
54. Chapter 32 — Job control: foreground, background, and nohup4 min
55. Chapter 33 — systemd and services: how "always running" actually works3 min
56. Chapter 34 — Logs: journalctl and where output really goes4 min
57. Part 10 — Users, permissions, and basic hardening
58. Chapter 35 — Users, groups, and sudo4 min
59. Chapter 36 — The permission model, beyond chmod 7774 min
60. Part 11 — Networking on Linux
61. Chapter 37 — How a Linux box sees the network4 min
62. Chapter 38 — The tools: ss , curl , dig , tcpdump , and a firewall's basics3 min
63. Part 12 — Shell scripting and automation
64. Chapter 39 — Bash scripting fundamentals4 min
65. Chapter 40 — Cron, environment variables, and gluing things together4 min
66. Part 13 — Performance and troubleshooting
67. Chapter 41 — Reading load average, vmstat , and iostat correctly4 min
68. Chapter 42 — strace , lsof , and answering "why is this stuck"4 min
69. Chapter 43 — Resource limits: ulimit and your first taste of cgroups5 min
70. PHASE 3 — Containerization: Docker and Kubernetes
71. Part 14 — Container fundamentals
72. Chapter 44 — What a container actually is (namespaces + cgroups + a filesystem)5 min
73. Chapter 45 — Containers vs. virtual machines, honestly compared4 min
74. Chapter 46 — Images and layers: why containers start in milliseconds4 min
75. Part 15 — Docker in depth
76. Chapter 47 — Running your first containers, and understanding what happened4 min
77. Chapter 48 — Writing a good Dockerfile4 min
78. Chapter 49 — Volumes and data: what survives a container's death4 min
79. Chapter 50 — Container networking: how containers talk to the world3 min
80. Chapter 51 — Docker Compose: running more than one container together3 min
81. Chapter 52 — Registries and image security basics4 min
82. Part 16 — Kubernetes fundamentals
83. Chapter 53 — Why Kubernetes exists (the problem Docker alone doesn't solve)4 min
84. Chapter 54 — The control plane and the node: Kubernetes' architecture4 min
85. Chapter 55 — Pods, Deployments, and ReplicaSets4 min
86. Chapter 56 — Services and how traffic finds a pod4 min
87. Chapter 57 — Configuration: ConfigMaps, Secrets, and environment3 min
88. Chapter 58 — Scheduling and scaling4 min
89. Part 17 -- Kubernetes in practice
90. Chapter 59 -- Reading cluster state and debugging a pod that won't start5 min
91. Chapter 60 -- Deployment patterns: rolling updates, health checks, rollbacks4 min
92. Chapter 61 -- Helm and packaging Kubernetes applications4 min
93. Part 18 -- Capstone projects
94. Chapter 62 -- Project 1: build and profile a small program, OS-level4 min
95. Chapter 63 -- Project 2: containerize a real application properly4 min
96. Chapter 64 -- Project 3: deploy that application to Kubernetes with health checks4 min
97. Chapter 65 -- Project 4: diagnose and fix a planted incident, end to end4 min
98. Part 19 -- Advanced Linux operations and expert practice
99. Chapter 66 -- Production Linux mental models: fleet, drift, and failure domains2 min
100. Chapter 67 -- systemd beyond start/stop: dependencies, timers, sandboxing, and debugging1 min
101. Chapter 68 -- Storage operations: LVM, RAID, filesystem growth, backups, and recovery2 min
102. Chapter 69 -- Advanced Linux networking: namespaces, routing, nftables, and packet paths2 min
103. Chapter 70 -- Observability and performance: perf, flame graphs, eBPF, and OpenTelemetry2 min
104. Chapter 71 -- Linux security hardening: SELinux/AppArmor, auditd, capabilities, and least privilege2 min
105. Chapter 72 -- Incident response and refactoring on real Linux systems2 min
106. Part 20 -- Systems programming in Go: the OS from inside a program
107. Chapter 73 -- Go meets the kernel: system calls, threads, and the runtime5 min
108. Chapter 74 -- Processes from Go: exec, exit codes, signals, and PID 15 min
109. Chapter 75 -- CPU limits: GOMAXPROCS, cgroups, and throttling4 min
110. Chapter 76 -- Memory limits: the Go heap, GOMEMLIMIT, and the OOM killer4 min
111. Chapter 77 -- Files that survive crashes: page cache, fsync, and atomic replacement5 min
112. Chapter 78 -- File descriptors and the netpoller: holding thousands of connections3 min
113. Chapter 79 -- Reading /proc from Go: build your own ps4 min
114. Chapter 80 -- A container runtime in 150 lines of Go6 min
115. Chapter 81 -- Profiling Go on Linux: pprof, the execution tracer, and perf5 min
116. Chapter 82 -- Capstone: shipping a well-behaved Go service (image, systemd, Kubernetes)5 min
117. Part 21 -- Where to go next
118. Chapter 83 -- Honest gaps and a study plan6 min
119. Chapter 84 -- Staying current5 min
120. Continue the series1 min
121. Appendix A -- Glossary (plain language)
122. Appendix B -- Command cheat sheet
123. Appendix C -- Troubleshooting playbook ("the server is slow")
124. Appendix D -- Further reading, and how this guide's facts were verified
125. Appendix E -- Answers to "Check yourself"