Kubernetes in Action (Marko Lukša)（Z-Library）

# Kubernetes in Action — Reading Guide ## 【One-Line Pitch】 A hands-on, example-driven guide for intermediate developers who want to master Kubernetes from the ground up—starting with Docker basics and progressing through pods, controllers, services, and cluster operations. If you're a developer who's heard of Kubernetes but never deployed a containerized app, this book gets you operational fast. ## 【Book Arc】 - **Opening (~0%–9%)**: Introduces why monolithic apps are giving way to microservices and how containers (especially Docker) solve environment drift. Explains Kubernetes as a "helmsman" that manages distributed applications across clusters, decoupling apps from specific machines. - **Early (~9%–25%)**: Covers hands-on Docker fundamentals—building images, running containers, inspecting them with `docker exec` and `docker inspect`—then moves to setting up a cluster (Minikube/GKE) and creating your first pods. Establishes the core mental model: pods, nodes, and how containers relate to both. - **Early (~25%–34%)**: Dives into pod creation via YAML/JSON descriptors, `kubectl create`, retrieving pod definitions, viewing logs, and using labels and annotations. Introduces node selectors (e.g., scheduling only on nodes with SSDs or GPUs) as a way to express infrastructure constraints. - **Middle (~34%–47%)**: Explores controllers that manage pods: liveness probes (HTTP, TCP, exec) for self-healing, ReplicationControllers and ReplicaSets for maintaining replica counts, and the more expressive `matchExpressions` label selectors. Covers node-failure response and introduces Jobs and CronJobs for batch workloads. - **Late (~47%–end, per TOC)**: Extends into services for discovery and communication, then covers advanced topics: monitoring, tuning, scaling, securing clusters, zero-downtime updates, and extending Kubernetes with custom API objects (CRDs), the Service Catalog, and platforms like OpenShift and Helm. ## 【Key Takeaways】 - **Containers solve environment drift** (Early): Docker packages your app with its entire filesystem—libraries, dependencies, even the OS—so it behaves identically on dev and production machines, regardless of the host Linux distribution. This is the foundation everything else builds on. - **Pods are the atomic unit of scheduling** (Early): A pod is a group of containers that share the same logical machine (IP, namespaces), while containers in different pods appear isolated. You can't manage individual containers directly—only pods—so think in pod terms from day one. - **Declarative YAML is the Kubernetes API** (Early): You create, inspect, and modify resources via `kubectl create/get -f` with YAML or JSON. The full pod definition returned by `kubectl get po -o yaml` reveals fields Kubernetes adds automatically—learning to read these is essential. - **Labels and annotations organize everything** (Early): Labels are queryable key-value pairs used for selectors and scheduling (e.g., `nodeSelector` for SSD/GPU nodes); annotations carry non-queryable metadata like descriptions or creator info. Mastering both makes cluster collaboration practical. - **Liveness probes enable self-healing** (Middle): HTTP GET, TCP socket, and exec probes let Kubernetes restart unhealthy containers automatically. The book's example—an app that fails after five requests—shows exactly how a probe detects and recovers from failure. - **ReplicaSets improve on ReplicationControllers** (Middle): The key upgrade is expressive selectors via `matchExpressions` (In, NotIn, Exists, DoesNotExist), letting you match pods by label keys and values with far more precision than simple equality. - **Jobs and CronJobs handle batch workloads** (Middle): For one-off or scheduled tasks, set `startingDeadlineSeconds` to enforce start deadlines, and design jobs to be idempotent—since CronJobs may occasionally create duplicate or zero runs. ## 【Reading Tips】 - **Skim Chapter 1 if you know Docker**: The opening container/microservices discussion is useful context, but if you've built images before, jump to the pod chapters (~25%) where the Kubernetes-specific material begins. - **Deep-read the liveness probe and ReplicaSet sections (~34%–44%)**: These are the most practical, with concrete YAML listings and failure scenarios. They teach you how Kubernetes keeps apps alive—the core value proposition. - **Follow along with the code archive**: The book references specific folders (e.g., `Chapter04/kubia-unhealthy`) and pre-built images on Docker Hub. Running these examples is far more effective than reading them. - **Watch for version-specific commands**: The book targets Kubernetes 1.4-era syntax (e.g., `kubectl create`). If you're on a newer version, some commands may be deprecated—check your cluster's docs when things don't work. - **Use the appendices for cluster setup**: Appendix B (multi-node with kubeadm) and Appendix A (multiple clusters with kubectl) are practical references—skim them before you need them, then return when setting up your own environment. ## 【Coverage Limits】 This guide covers the book's first half (through controllers and batch workloads) in detail; later sections on services, security, monitoring, scaling, and custom API extensions are summarized from the table of contents and may not reflect the full depth of those chapters. ##