Programming Kubernetes Developing Cloud-Native Applications (Michael Hausenblas, Stefan Schimanski)（Z-Library）

【One-Line Pitch】 A hands-on guide for developers who want to build applications that live *inside* Kubernetes—not just run on it—by speaking directly to the API server. Best for Go developers and AppOps admins ready to move past YAML and start writing controllers, operators, and custom resources. 【Book Arc】 - **Opening (~0%–10%)**: Frames what "programming Kubernetes" actually means—distinguishing cloud-native apps that are aware of and interact with the API server from off-the-shelf software merely deployed on a cluster. Sets scope, prerequisites (Go, Git, package management), and the extension points the book will cover. - **Early (~10%–30%)**: Introduces the Kubernetes API and its inner structure, then moves into the Go programming interface—client-go and API objects—as the foundation for everything that follows. A motivational "cloud-native at" example previews custom resources and controllers. - **Middle (~30%–55%)**: Explains controllers and operators in depth: the control loop (read state → change the world → update status), informers, work queues, watches, and the event-driven, edge-triggered architecture that makes Kubernetes scale. This is the conceptual core of the book. - **Late (~55%–85%)**: Shifts to custom resources as the central extension mechanism, including code generators and tags to control them, then builds toward writing custom controllers and operators and making them production-ready. - **Ending (~85%–100%)**: Extends the API surface itself by implementing a custom API server, rounding out the extension toolkit beyond CRDs and controllers. 【Key Takeaways】 - **"Programming Kubernetes" means writing apps that talk to the API server** (Early): the book draws a clear line between COTS/bespoke apps that ignore Kubernetes and cloud-native apps that query and update resource state—the latter gain portability and declarative control. - **Go is the default language for Kubernetes-native development** (Early): the authors justify this with a Unix/C analogy—Kubernetes and most cloud-native tooling are written in Go, so even non-Go developers benefit from reading it. - **The control loop is the universal pattern** (Middle): read resource state → change the world → update status, repeated forever. Every controller, however simple or complex, reduces to these three steps. - **Kubernetes is edge-driven, not level-driven** (Middle): event-based triggers via watches scale far better than polling, which is why informers and work queues exist—and why understanding watches matters for correct controllers. - **Informers and work queues are the practical machinery** (Middle): informers watch desired state and resync periodically to prevent drift; work queues handle retries and requeueing on errors. - **Custom resources are the central extension tool** (Late): CRDs let you define your own API objects, and code generators with tags automate the boilerplate—essential for anyone building operators. - **Operators encode operational knowledge** (Late): an operator is a controller plus custom resources that captures application lifecycle management, and the book emphasizes making them production-ready rather than demo-grade. - **You can extend the API surface itself** (Ending): implementing a custom API server goes beyond CRDs when you need deeper integration—the most advanced extension point covered. 【Reading Tips】 - **Deep-read the controller/control-loop chapters** (Middle): this is the conceptual hinge of the book; if you understand informers, work queues, and edge-vs-level triggers, the later operator material falls into place. - **Skim the front matter and prerequisites** (Opening): the setup, acknowledgments, and tooling notes are quick reads—confirm you have Go, Git, and a recent cluster (Minikube or kind) and move on. - **Have a cluster ready before the custom resource chapters**: the excerpts note that advanced CRD features and conversion require specific Kubernetes versions (1.13–1.15), so version mismatches will block hands-on practice. - **Treat the code examples as the real text**: the book ships manifests and scripts on GitHub; cloning the repos and running them chapter-by-chapter will teach you far more than reading alone. - **Don't skip the motivational example** (Early): the "cnat" custom resource + controller walkthrough is a miniature of the entire book's arc—return to it after finishing to see how much you've learned. 【Coverage Limits】 These excerpts cover the book's framing, prerequisites, controller/operator concepts, and extension-point overview, but do not include detailed chapter content on client-go APIs, code generator tags, or custom API server implementation. Specific code patterns and version-dependent features are only referenced, not shown.