The Kubernetes Book (Nigel Poulton)（Z-Library） (1)

【One-Line Pitch】 A practical, hands-on guide to Kubernetes that takes you from core concepts like Pods and Deployments to advanced topics like WebAssembly and storage, ideal for developers and operators who want to deploy, scale, and manage cloud-native applications with confidence. 【Book Arc】 - **Opening (~0%–4%)**: Introduces Kubernetes as an orchestrator for containerized microservices, explaining its origins at Google and contrasting the declarative model (desired state) with the traditional imperative approach, setting the stage for all subsequent chapters. - **Early (~12%–19%)**: Dives deep into Pods, the fundamental unit of deployment, covering their lifecycle, immutability, and multi-container patterns like init containers and sidecars, with hands-on YAML examples for creating and managing them. - **Early (~27%–31%)**: Explores Deployments and Services, showing how to scale, update, and roll back applications using ReplicaSets, and how Services use labels and selectors for loose coupling and traffic routing, including LoadBalancer types and EndpointSlices. - **Middle (~38%–46%)**: Covers advanced workload types, including a full hands-on with WebAssembly (Wasm) on Kubernetes using shims and RuntimeClasses, plus service discovery via cluster DNS and Namespaces for partitioning the address space. - **Late (~54%)**: Focuses on Kubernetes storage, explaining the Container Storage Interface (CSI), persistent volumes (PVs), persistent volume claims (PVCs), and StorageClasses for dynamic provisioning, with practical guidance on reclaim policies like Delete and Retain. 【Key Takeaways】 - **Declarative model is king** (Opening): Describe your desired end state in YAML, and Kubernetes controllers reconcile the observed state to match, making deployments reproducible and version-controllable—unlike imperative scripts. - **Pods are the atomic unit** (Early): Every app runs in a Pod, which is mortal and immutable; to change or fix an app, you create a new Pod, not patch the old one, which is a mindset shift from traditional server management. - **Init containers sequence startup** (Early): Define init containers under `spec.initContainers` to run setup tasks before app containers start, ensuring dependencies like service discovery are ready first. - **Sidecars are now native** (Early): Kubernetes v1.28+ supports native sidecar containers (beta in v1.32), enabling reliable start/stop ordering alongside app containers, used by projects like Istio and Argo CD. - **Services provide stable endpoints** (Early): Services use label selectors to maintain an up-to-date list of healthy Pods, so scaling, rollouts, and failures don't break client access—traffic always reaches a matching Pod. - **Wasm is a lightweight alternative** (Middle): WebAssembly apps compile to tiny OCI images (kilobytes vs. megabytes) and run on Kubernetes via containerd shims like Spin, offering faster startup and smaller footprints. - **Storage is pluggable via CSI** (Late): The Container Storage Interface standardizes storage drivers, and StorageClasses dynamically provision volumes based on PVCs, with reclaim policies (Delete vs. Retain) determining data lifecycle. 【Reading Tips】 - **Skim the theory, deep-read the hands-on**: Chapters 2 and 4 lay foundations, but the real learning is in the YAML examples and `kubectl` commands—follow along with your own cluster (Docker Desktop or k3d) to cement concepts. - **Focus on Pod lifecycle early**: Understanding Pod phases (pending, running, etc.) and immutability is critical; revisit Chapter 4 if later chapters feel confusing, as everything builds on it. - **Practice Service discovery with Namespaces**: The FQDN format (`<object>.<namespace>.svc.cluster.local`) is a common stumbling block; run the hands-on to see how DNS and EndpointSlices work in practice. - **Treat Wasm as an optional deep-dive**: If you're new to Kubernetes, skim the Wasm chapter (Chapter 9) and return later—it's advanced but shows the platform's flexibility. - **Take away the storage cheat sheet**: Chapter 11's summary on PVs, PVCs, and StorageClasses is a quick reference for real-world deployments; note the danger of the default Delete reclaim policy. 【Coverage Limits】 This guide synthesizes excerpts covering roughly the first half to mid-book (Chapters 1–11), including Pods, Deployments, Services, Wasm, DNS, and storage. Later chapters on ConfigMaps, Secrets, and StatefulSets are listed in the table of contents but not detailed in the source material.