Cloud Native DevOps with Kubernetes Building, Deploying, and Scaling Modern Applications in the Cloud, 2nd Edition (Justin Domingus, John Arundel)（Z-Library）

【One-Line Pitch】 A practical, beginner-friendly guide to running containerized applications on Kubernetes, from first principles through production-grade deployment pipelines. Best for developers and ops engineers who want to understand cloud native infrastructure by building it, not just reading about it. 【Book Arc】 - **Opening (~0%–10%)**: Frames the cloud revolution and why containers beat VMs—smaller images, shared layers, no virtualization overhead—then introduces Kubernetes as the "operating system of the cloud native world" and the DevOps movement behind it. - **Early (~10%–35%)**: Hands-on fundamentals: building and running your first container with Docker, naming and pushing images, then moving into what Kubernetes is and how to get a cluster (self-hosted vs. managed). - **Middle (~35%–55%)**: The buy-vs-build decision. Makes the case for managed Kubernetes via the "Run Less Software" philosophy—outsource undifferentiated heavy lifting—and covers cluster architecture, control plane, and worker nodes. - **Late (~55%–80%)**: Working with Kubernetes objects in practice: managing pods, labels and selectors, affinities, desired state, and the resource/lifecycle mechanics that keep workloads running. - **Ending (~80%–100%)**: Security, observability, and operational concerns—pod security contexts, capabilities, volumes, secrets—plus the tooling and practices for deploying and scaling real applications. - **Throughline**: A single example cloud native application is built step by step, with its infrastructure, dev environment, and continuous deployment pipeline, so concepts arrive attached to something you can run. 【Key Takeaways】 - **Containers are the unit of everything** (Early): packaging, deployment, reuse, scaling, and resource allocation—one image runs anywhere with a compatible kernel, which is why they replace the VM-centric model. - **Containers beat VMs on size and speed** (Early): a well-built container image can be ~100x smaller than a VM image, and virtualized workloads run roughly 30% slower due to emulation overhead. - **Kubernetes is "necessarily complex," not needlessly so** (Early): its many moving parts exist to deliver resiliency, efficiency, and extensibility at scale—so expect a learning curve, but one with a purpose. - **Prefer managed Kubernetes** (Middle): installing, securing, upgrading, and keeping clusters reliable is undifferentiated heavy lifting; GKE, EKS, and AKS do it cheaper than most teams can themselves. - **"Run Less Software" as a decision filter** (Middle): choose boring, standard technology, outsource what doesn't differentiate you, and spend your scarce engineering time on your actual business. - **Self-hosting is a real commitment** (Middle): high availability, security, and node management separate a demo cluster from production; kops and Kubespray are the mature tools if you must host your own. - **Desired state is the operating model** (Late): you declare what you want and Kubernetes reconciles toward it—labels, selectors, and affinities are how you steer that reconciliation. - **Security and observability are first-class, not afterthoughts** (Ending): pod security contexts, capabilities, service accounts, volumes, and image pull secrets shape how safely and visibly workloads run. 【Reading Tips】 - **Skim the container/Docker chapter if you're already fluent**—the book explicitly invites you to jump to "Hello, Kubernetes" where the Kubernetes content begins. - **Deep-read the buy-vs-build chapter** even if you're not the decision-maker; the "Run Less Software" framing is the book's most transferable idea and will shape how you evaluate tooling. - **Type the commands, don't just read them**: the authors deliberately teach by having you build and run things, and the example app is on GitHub—following along is where the value lands. - **Treat the security and observability sections as a checklist** to revisit once you have a cluster running, since they matter most in production, not in a demo. - **Keep the cluster-architecture material as reference**: you don't need to memorize control plane internals, but knowing what a managed service handles for you clarifies what you still own. 【Coverage Limits】 The excerpts are heavily weighted toward the book's opening and middle (containers, cluster choices, buy-vs-build), with only table-of-contents-level glimpses of the later security, observability, and deployment-pipeline chapters. Specific tooling, configuration examples, and the full example application's later stages are not covered in detail here.