Production Kubernetes Building Successful Application Platforms (Josh Rosso, Rich Lander, Alex Brand etc.)（Z-Library）

【One-Line Pitch】 A practical field guide for platform engineers and architects who want to move Kubernetes from a promising pilot to a reliable production foundation, covering the hard trade-offs in infrastructure, storage, networking, and identity that textbooks often skip. 【Book Arc】 - **Opening (~0%–9%)**: The authors, VMware engineers with years of enterprise consulting, frame Kubernetes as a foundation, not a finished platform. They stress that most failures come from misunderstanding what Kubernetes will and won't solve, and they introduce the book's core philosophy: focus on patterns and trade-offs, not just tools. - **Early (~9%–25%)**: This section dives into the foundational layers—choosing where to run Kubernetes (cloud, on-prem, bare metal), bootstrapping clusters with tools like kubeadm, and the critical decision of cluster sizing. It covers the realities of node pools, the trade-offs between multiple clusters versus one large one, and the operational gaps you must fill (load balancers, storage, security). - **Early (~25%–34%)**: The focus shifts to deployment models and the practical mechanics of running multiple clusters. This includes strategies for workload migration between clusters (using tools like Velero for reliable snapshots) and the networking and storage prerequisites for a multi-cluster setup, such as shared VPCs and accessible storage services. - **Middle (~38%–47%)**: The book moves into the container ecosystem, explaining the Open Container Initiative (OCI) specifications that ensure compatibility. It then details the container runtime layer, comparing options like containerd and CRI-O, and shows how to interact with them via CRI and tools like crictl. This section also begins tackling storage, distinguishing between block, file, and object storage, and introduces backup strategies with Velero. - **Middle (~47%–53%+)**: The narrative continues into deeper platform concerns, including storage orchestration and the complexities of backup/recovery for stateful applications. The excerpts suggest the book then progresses into advanced topics like custom resources, operators, extending the scheduler, and multitenancy, which are covered in later chapters. 【Key Takeaways】 - **Kubernetes is a foundation, not a finished platform** (Early): The book's central warning is that Kubernetes provides primitives, not solutions. You must plan and build the platform layers—networking, storage, security, and delivery—on top of it. This mindset prevents the common failure of expecting Kubernetes to solve problems it wasn't designed for. - **Interfaces are the key to extensibility** (Early): Kubernetes's power comes from defined contracts like the Container Runtime Interface (CRI). Understanding these interfaces helps you see how plug-ins (e.g., containerd, CRI-O) provide functionality and why the system is so configurable. This is crucial for making informed choices about your stack. - **Infrastructure choice is a trade-off, not a religion** (Early): The decision between cloud, on-prem virtualization, and bare metal should be based on your technical requirements and operational experience. The authors caution against replacing a virtualization stack with Kubernetes without understanding the added operational complexity and risk. - **Cluster sizing is a strategic decision** (Early): The number of worker nodes in a production cluster is a distinct question from how many are needed for workloads. The "one big cluster" is a rare unicorn; most organizations need a model that accounts for resilience, team boundaries, and operational blast radius. - **Workload migration requires a reliable source of truth** (Early): Redeploying from version control is ideal but often unrealistic due to in-place changes. Tools like Velero, which snapshot resources through the Kubernetes API, are invaluable for reliable, namespace-by-namespace migrations between clusters. - **Container standards ensure portability** (Middle): The Open Container Initiative (OCI) specifications for runtime, image, and distribution are what make containers portable. Understanding these specs helps you navigate the ecosystem and ensure your container solutions are compatible, avoiding vendor lock-in. - **Storage is not one-size-fits-all** (Middle): Applications expect different storage types—file, block, or object—each with its own trade-offs. Choosing the right underlying storage and its Kubernetes integration is a core platform decision that directly impacts application performance and design. - **Backup and recovery are a platform service with limits** (Middle): Offering restore features as a platform service is valuable, but application-specific complexity (e.g., apps that can't restart cleanly) often requires developer involvement. Tools like Velero provide the primitives (snapshots, hooks), but you must define the orchestration flow around them. 【Reading Tips】 - **Skim the early philosophy, deep-read the trade-offs**: The opening chapters set the mindset, but the real value is in the detailed comparisons (e.g., cluster models, storage types). Focus your attention on the "trade-off" discussions and decision frameworks. - **Treat tool mentions as examples, not endorsements**: The authors explicitly state they focus on patterns over tools. When you see a tool like kubeadm or Velero, understand the problem it solves and the pattern it demonstrates, rather than memorizing its commands. - **Use the chapter summaries as a map**: The table of contents and summaries at the end of each chapter (e.g., on Service Meshes, Identity, Multitenancy) are excellent for navigating to the specific topics most relevant to your current challenges. - **Pay special attention to the "gaps"**: The book repeatedly highlights what Kubernetes does *not* provide (e.g., load balancer API, sophisticated storage integration). These gaps are your checklist for what you need to build or buy to make Kubernetes viable for production. 【Coverage Limits】 This guide is based on excerpts covering roughly the first half of the book. It does not cover the later chapters on advanced topics like custom resources, operators, extending the scheduler, multitenancy, and identity, which are listed in the table of contents but not detailed in the source material.