Quick Start Kubernetes (Nigel Poulton)（Z-Library）

【One-Line Pitch】 A hands-on, no-nonsense introduction to Kubernetes for beginners who want to get a cluster running, deploy a containerized app, and learn the core concepts of orchestration—self-healing, scaling, and rolling updates—without getting lost in theory. 【Book Arc】 - **Opening (~0%–4%)**: Sets expectations for the 2025 edition, outlines what you'll learn (microservices, orchestration, Kubernetes as the "OS of the cloud"), and maps the hands-on journey: build a cluster, containerize an app, deploy it, break it, fix it, scale it, and update it. - **Early (~4%–14%)**: Introduces the "why" of Kubernetes—cloud-native microservices need an orchestrator. Uses the football team analogy to explain how Kubernetes organizes independent microservices into a coherent app, and covers key concepts like self-healing, scaling on demand, and rolling updates. - **Early (~14%–25%)**: Explains Kubernetes' origins (Google's Borg/Omega) and its architecture: control plane nodes (API server, scheduler, store, cloud controller) vs. worker nodes. Covers hosted Kubernetes services (EKS, AKS, GKE, etc.) and the division of responsibility between you and the cloud provider. - **Early (~25%–36%)**: Gets you up and running. Covers installing Docker Desktop (with built-in multi-node Kubernetes) or creating a cluster on Civo Cloud, verifying nodes with `kubectl get nodes`, and downloading the sample app from GitHub. - **Middle (~36%–50%)**: Walks through containerizing the sample Node.js app with a Dockerfile, building and pushing the image to Docker Hub, then deploying it to Kubernetes as a Pod using `kubectl apply`. Explains how to inspect Pods with `kubectl get` and `kubectl describe`. - **Middle (~50%–end)**: Connects the app to the outside world with a LoadBalancer Service, then moves into operational topics: self-healing with Deployments (recovering from app and infrastructure failures), scaling up/down, and performing rolling updates without downtime. 【Key Takeaways】 - **Kubernetes is an orchestrator for cloud-native microservices** (Early): It runs and manages apps made of small, specialized parts that can self-heal, scale, and be updated independently. Think of it as the "OS of the cloud" that organizes messy microservices into useful applications. - **Cloud-native apps must self-heal, scale on demand, and support rolling updates** (Early): These are the three core capabilities Kubernetes provides. Self-healing means Kubernetes constantly compares actual state to your desired state and fixes drift; scaling means growing/shrinking resources automatically based on demand; rolling updates let you change parts of an app without downtime. - **A cluster has two node types: control plane and worker** (Early): Control plane nodes run Kubernetes system services (API server, scheduler, cluster store, cloud controller), while worker nodes run your user applications. Best practice: keep apps off control plane nodes. You're usually responsible for worker nodes, user apps, and the bill on hosted platforms. - **Docker Desktop is the fastest way to get a multi-node cluster locally** (Early): Version 4.38+ includes a built-in multi-node Kubernetes cluster (enable the "kind" option, not the older single-node one). Verify with `kubectl get nodes`—you should see one control-plane and two worker nodes. - **Containerizing an app is straightforward with a Dockerfile** (Middle): The sample app uses a simple Dockerfile: pull a Node base image, copy app files, set working directory, run `npm install`, expose port 8080, and define the start command. Build with `docker build`, then push to a registry like Docker Hub with `docker push`. - **Deploying to Kubernetes is declarative, not imperative** (Middle): You write YAML files (e.g., `pod.yml`) that describe the desired state, then run `kubectl apply -f`. The API server authenticates/authorizes the request, stores the definition, and the scheduler places the Pod on a worker node. Inspect with `kubectl get pods` and `kubectl describe pod`. - **Services connect Pods to the network** (Middle): A LoadBalancer Service (like `svc-lb`) accepts traffic on an external port (e.g., 5555) and forwards it to Pods matching a label selector (e.g., `project=qsk-book`) on their container port (8080). On cloud clusters, this provisions an internet-facing load balancer; on Docker Desktop, it's accessible via localhost. 【Reading Tips】 - **Skim the theory chapters (1–3) if you're in a hurry**: The football team analogy and architecture overview are useful context, but the real value is in the hands-on chapters. If you already know what microservices are, jump to Chapter 4. - **Follow along with the sample app**: Don't just read—clone the `qsk-book` repo, build the image, and deploy it. The book is designed for active learning, and the examples are updated for 2025 Kubernetes versions. - **Use Docker Desktop for local practice, Civo for cloud experience**: Docker Desktop's built-in multi-node cluster is free and fast for local experimentation. If you want to see how a real cloud load balancer works, use Civo (the book includes a $500 credit link). - **Pay attention to the YAML files**: The Pod and Service definitions are the core artifacts. Understand the structure: `apiVersion`, `kind`, `metadata`, and `spec`. The Service's `selector` is the glue that connects traffic to your Pods—this is a common source of confusion. - **Don't skip the "break it" exercises**: The self-healing chapter has you intentionally kill a Pod or fail a node to watch Kubernetes recover. This is the best way to internalize the desired-state model. 【Coverage Limits】 This guide covers the book's opening through the Service deployment (~50% of the book). The later chapters on self-healing, scaling, and rolling updates are summarized conceptually but not detailed step-by-step, as the excerpts do not include their full content.