CLOUD-NATIVE SOFTWARE DEVELOPMENT: Microservices, Containers, Kubernetes, Serverless, and Scalable Cloud Applications (Contemporary Software Engineering Series)

The idea for this book emerged from a simple, recurring observation: engineers and students alike could readily find excellent documentation, blog posts, and reference material on any single cloud-native technology — Kubernetes, Docker, a specific serverless platform — but struggled to find a single, coherent text that connected these technologies to one another and, more importantly, to the underlying architectural principles that make sense of why the cloud-native ecosystem looks the way it does. A reader who understands why statelessness matters, why services should own their own data, and why failure must be designed for rather than merely hoped against, will find that individual technologies such as Kubernetes and serverless computing become far easier to learn, because their design decisions stop looking like arbitrary complexity and start looking like direct, sensible responses to well-understood problems.
This book is therefore organized deliberately around principles first, technologies second. Part I establishes the conceptual foundations of cloud computing and cloud-native architecture before a single container or Kubernetes manifest appears. Parts II through V then develop microservices, containers, Kubernetes, and serverless computing in depth, each building on the principles established earlier and each showing, concretely, how the technology in question operationalizes those principles. Part VI closes the book with the operational disciplines — continuous delivery, observability, security, and performance and cost engineering — without which no amount of architectural elegance survives contact with a real production system at scale.
Every figure in this book was purpose-drawn for this text to illustrate the specific concept under discussion as clearly as possible, and every table is intended as a genuine reference a practitioner might return to while designing a real system, not merely as a textbook illustration. The code examples throughout favor clarity and correctness of concept over completeness; readers building production systems should consult the current official documentation for the specific tools and versions they adopt, since this fast-moving field continues to evolve even as its underlying principles remain stable.
This book assumes a reader who is comfortable with general-purpose programming and basic networking concepts, but assumes no prior exposure to containers, Kubernetes, or any specific cloud provider. It is intended equally for classroom use in an advanced undergraduate or graduate course on cloud computing or distributed systems, and for self-directed study by practicing engineers seeking a structured, principle-first foundation beneath the day-to-day tools of their trade.
I am grateful to the open-source communities behind the Cloud Native Computing Foundation's many projects — Kubernetes, Prometheus, Envoy, OpenTelemetry, and the dozens of others referenced throughout this text — whose freely available documentation, source code, and design discussions made a text of this depth and accuracy possible. Any errors that remain are, of course, my own.
It is my sincere hope that this book equips its readers not merely to operate the specific tools fashionable today, but to reason clearly about distributed systems design well after those specific tools have been superseded by whatever comes next.