What do you think?
Rate this book
Kubernetes: Up and Running: Dive into the Future of Infrastructure
Kubernetes radically changes the way applications are built and deployed in the cloud. Since its introduction in 2014, this container orchestrator has become one of the largest and most popular open source projects in the world. The updated edition of this practical book shows developers and ops personnel how Kubernetes and container technology can help you achieve new levels of velocity, agility, reliability, and efficiency.
Kelsey Hightower, Brendan Burns, and Joe Beda—who’ve worked on Kubernetes at Google and beyond—explain how this system fits into the lifecycle of a distributed application. You’ll learn how to use tools and APIs to automate scalable distributed systems, whether it’s for online services, machine learning applications, or a cluster of Raspberry Pi computers.
Create a simple cluster to learn how Kubernetes works Dive into the details of deploying an application using Kubernetes Learn specialized objects in Kubernetes, such as DaemonSets, jobs, ConfigMaps, and secrets Explore deployments that tie together the lifecycle of a complete application Get practical examples of how to develop and deploy real-world applications in Kubernetes278 pages, Kindle Edition
First published January 31, 2016
605 people are currently reading
1604 people want to read
Ratings & Reviews
Friends & Following
Create a free account to discover what your friends think of this book!
Community Reviews
Displaying 1 - 30 of 123 reviews
May 19, 2018
You cannot make a book about 'death by yaml' any more interesting.
July 22, 2017
Anyone who had any contact with K8s knows that there's no one better qualified to create a book about it than K. Hightower. So when I've started reading I've already new that it will be either good or very good, nothing less. Apparently, I was right - it's a solid 4.5 & it may get even better in a printed version (I've read an unreleased version with all the chapters, but before the final editing, w/o some diagrams, etc.).
Good stuff? It's definitely successful in introducing the reader into the tech. Clear, proper pace, gets to a sufficient level of detail (at least IMHO). So, basically it meets its primary goal. Drawbacks? There was definitely the need for good diagrams (not present in my version) - hopefully they will be there in the printed one. I also believe that providing some more context, e.g. by comparing K8s to alternative solutions like Docker Swarm, Mesos or Nomad could really help in building the big picture of what kind of needs K8s can fulfil, where it would be a good fit & where not so.
Anyway, it is definitely the best available resource on Kubernetes, so if you're interested in learning a bit about it, this book is a safe bet.
Good stuff? It's definitely successful in introducing the reader into the tech. Clear, proper pace, gets to a sufficient level of detail (at least IMHO). So, basically it meets its primary goal. Drawbacks? There was definitely the need for good diagrams (not present in my version) - hopefully they will be there in the printed one. I also believe that providing some more context, e.g. by comparing K8s to alternative solutions like Docker Swarm, Mesos or Nomad could really help in building the big picture of what kind of needs K8s can fulfil, where it would be a good fit & where not so.
Anyway, it is definitely the best available resource on Kubernetes, so if you're interested in learning a bit about it, this book is a safe bet.
February 26, 2018
I'm really happy that this was first book about k8s that i've read. It's really good introduction into the topic with some background why things are done this way and not the other way round.
I would say its solid 4. I'm giving 5 as this book helped me a lot with understanding what is what and how this all parts work together to create something bigger. If i would not have a need to that knowledge i would go with 4 stars.
That one missing star: The only thing I was missing was 3-4 words dictionary of all keywords used in book. Instead i was forced to jump between chapters just to understand what he is writing about :)
I would say its solid 4. I'm giving 5 as this book helped me a lot with understanding what is what and how this all parts work together to create something bigger. If i would not have a need to that knowledge i would go with 4 stars.
That one missing star: The only thing I was missing was 3-4 words dictionary of all keywords used in book. Instead i was forced to jump between chapters just to understand what he is writing about :)
December 31, 2022
Why I read this book: I’ll be transitioning to the Platform backend team in a few months. I want to spend the time while I wait to learn something that could potentially ease my onboarding.
How I read this book: I read the physical book. The chapters in the book are rather small and easy to comprehend. I read through a full chapter, highlighted the parts that seemed most interesting or useful and later wrote them all down. Once I’ve gone through the entire book, I re-read the notes to refresh my memory.
What I liked about it:
There were 3 attempts to teach me about Kubernetes in the past: a fellow backend engineer doing a learning session with a demo for our team; one of our SREs doing an extensive 4-hour workshop on Kubernetes basics; another SRE doing a short walk-through on our GitOps setup. None of these worked well for me. They jumped into the tooling without giving much context about the concepts used. I couldn't get over the fact that I don't understand why a Pod is called a Pod and therefore couldn't focus. This book, on the other hand, was the perfect level of abstraction to provide a context that I later could use when googling for how to do something specific. Oh, and also a Pod is a group of whales (so the naming goes with the whale theme of Docker containers).
As the book is written by the co-founders of the Kubernetes open source project, it has some sneak peeks into the philosophy of Kubernetes design, such as:
- Coming in the front door (an example of this would be replica sets using the same api we would to create a Pod manually)
- Decoupling (e.g. because Pods are not coupled to ReplicaSets and DaemonSets, every tool used for introspecting Pods in the context of ReplicaSets is equally applicable to Pods created by DaemonSets
I found this rather exciting, as Kubernetes is a revolutionary technology that has had a major impact on the way software is built in the past decade.
I really liked how the information in the book is structured. The concepts are introduced in a logical progression, with each concept building on the understanding gained from the previous one e.g. first introducing Pods, then ReplicaSets then Deployments. Or first introducing ServiceObjects and then Ingress. I feel like I really have a good mental model of the main concepts in Kubernetes and how they relate with each other after reading this book.
I’m also happy they are still keeping the book up to date. The third edition that I read was released only in August this year, so I wasn’t worried that I’m reading about outdated things.
What I disliked:
This wasn’t a problem for me, but I could imagine someone getting disappointed about this. The book is introductory level, reading it won’t make you an expert in Kubernetes, only familiar with it.
There were some chapters (mainly “Service discovery”) where I had to check the documentation to understand what the authors are trying to say better
There were very few illustrations. As a visual person I would appreciate the summary of some concepts as diagrams. For example the relationship between Kubernetes clusters and nodes vs Pods, ReplicaSets and Deployments.
P.S. You can find this book review and the reviews of other technical or otherwise work related books that I’ve read on my website: https://www.ieva.dev/book_reviews.html
How I read this book: I read the physical book. The chapters in the book are rather small and easy to comprehend. I read through a full chapter, highlighted the parts that seemed most interesting or useful and later wrote them all down. Once I’ve gone through the entire book, I re-read the notes to refresh my memory.
What I liked about it:
There were 3 attempts to teach me about Kubernetes in the past: a fellow backend engineer doing a learning session with a demo for our team; one of our SREs doing an extensive 4-hour workshop on Kubernetes basics; another SRE doing a short walk-through on our GitOps setup. None of these worked well for me. They jumped into the tooling without giving much context about the concepts used. I couldn't get over the fact that I don't understand why a Pod is called a Pod and therefore couldn't focus. This book, on the other hand, was the perfect level of abstraction to provide a context that I later could use when googling for how to do something specific. Oh, and also a Pod is a group of whales (so the naming goes with the whale theme of Docker containers).
As the book is written by the co-founders of the Kubernetes open source project, it has some sneak peeks into the philosophy of Kubernetes design, such as:
- Coming in the front door (an example of this would be replica sets using the same api we would to create a Pod manually)
- Decoupling (e.g. because Pods are not coupled to ReplicaSets and DaemonSets, every tool used for introspecting Pods in the context of ReplicaSets is equally applicable to Pods created by DaemonSets
I found this rather exciting, as Kubernetes is a revolutionary technology that has had a major impact on the way software is built in the past decade.
I really liked how the information in the book is structured. The concepts are introduced in a logical progression, with each concept building on the understanding gained from the previous one e.g. first introducing Pods, then ReplicaSets then Deployments. Or first introducing ServiceObjects and then Ingress. I feel like I really have a good mental model of the main concepts in Kubernetes and how they relate with each other after reading this book.
I’m also happy they are still keeping the book up to date. The third edition that I read was released only in August this year, so I wasn’t worried that I’m reading about outdated things.
What I disliked:
This wasn’t a problem for me, but I could imagine someone getting disappointed about this. The book is introductory level, reading it won’t make you an expert in Kubernetes, only familiar with it.
There were some chapters (mainly “Service discovery”) where I had to check the documentation to understand what the authors are trying to say better
There were very few illustrations. As a visual person I would appreciate the summary of some concepts as diagrams. For example the relationship between Kubernetes clusters and nodes vs Pods, ReplicaSets and Deployments.
P.S. You can find this book review and the reviews of other technical or otherwise work related books that I’ve read on my website: https://www.ieva.dev/book_reviews.html
September 29, 2018
As promised, this is a nice, quick, bare-bones intro to Kubernetes. You'll deploy some Docker containers in Pods, create Services, work with ReplicaSets, DaemonSets, and StatefulSets, run a few Jobs, and learn how to manage configs, secrets, and deployments. The Kubernetes project is moving so quickly that, just 2 years later, a little bit of the content feels dated, but overall, the book holds up well.
June 25, 2018
A great introduction to main kubernetes core concepts.
It's a beginners book but is very easy to read.
It's a beginners book but is very easy to read.
January 6, 2020
It is an okay book, but there’s nothing inside that you can’t find in documentation around the web. Instead the authors could start from real-world example and try to solve it with kubernetes infrastructure. This way they could delve deeper into the philosophy of orchestration of containers and why you need scaling in your environment. I would recommend people to buy an online course instead of this book. And also minus star for requirement for a commercial service for a kubernetes cluster.
July 21, 2022
A bit outdated in 2022, though it is still fine to describe the basics.
August 24, 2022
Good book to get started with.
December 31, 2016
This is a review of the "Early Release" edition.
To be concise: the "Early Release" edition contains typos, a few technical errors, and a host of incomplete sections even within the "available" chapters. The total length is about 90 pages and the list price at the time of writing this review was about $40. This may be a good book eventually, but it is far too early, unpolished, and incomplete a draft to be ready for sale even as an "Early Release."
Perhaps when the full edition is available this book will be worth the time/money. The topic and technology are certainly worth reading about. At the moment though, I would say this book was released before it was ready for sale.
To be concise: the "Early Release" edition contains typos, a few technical errors, and a host of incomplete sections even within the "available" chapters. The total length is about 90 pages and the list price at the time of writing this review was about $40. This may be a good book eventually, but it is far too early, unpolished, and incomplete a draft to be ready for sale even as an "Early Release."
Perhaps when the full edition is available this book will be worth the time/money. The topic and technology are certainly worth reading about. At the moment though, I would say this book was released before it was ready for sale.
December 30, 2025
My last book of 2025.
I actually tried reading it a couple of months ago, but a lot of the content didn’t fully click at the time. After getting more hands-on experience with Kubernetes, coming back to it felt very different. The book reads less like a high-level overview and more like a manual for the operational loops that actually drive a cluster.
The authors anchor the entire book around a demo application called kuard (Kubernetes Up and Running Demo). Instead of abstract “Hello World” examples, they use kuard to demonstrate real behavior. For example, early on they walk through optimizing image size with multistage Docker builds, compiling the Go binary and React frontend separately from the runtime image. Later, kuard’s built-in memory stress test is used to show exactly what happens when a Pod exceeds its memory limits versus its requests.
The progression of concepts is very deliberate. It starts by contrasting imperative commands with Kubernetes’ immutable, declarative model. From there, it moves from Pods to ReplicaSets and explains the reconciliation loop that enables self-healing. The networking section clearly separates Layer 4 Services (ClusterIP, NodePort, LoadBalancer) from Layer 7 Ingress, using the Contour controller as a concrete example of path-based routing.
The chapter on Deployments was especially practical. Instead of stopping at “what a rollout is,” it breaks down how maxUnavailable and maxSurge actually affect availability and throughput, and how to tune them. It also explicitly calls out the requirement for backward and forward compatibility during rolling updates, when multiple application versions are running at the same time.
The book goes beyond standard web services as well. It covers DaemonSets using log collectors like Fluentd, Jobs and CronJobs for batch tasks such as database migrations, and StatefulSets through a replicated MongoDB example. That section makes the need for stable network identities (like mongo-0, mongo-1) very concrete compared to random Pod names.
It also addresses “day 2” concerns that many introductory resources skip, including governance with Gatekeeper and OPA, and writing custom controllers using the Kubernetes API. Instead of hand-waving, it includes actual code examples in Python, Java, and .NET that use the Informer pattern rather than shell scripts.
Overall, the book feels like a practitioner’s reference. Reading it after working with Kubernetes made the design decisions much clearer, from readiness probe thresholds to RBAC verb granularity. It really bridges the gap between basic definitions and the realities of running systems in production.
I actually tried reading it a couple of months ago, but a lot of the content didn’t fully click at the time. After getting more hands-on experience with Kubernetes, coming back to it felt very different. The book reads less like a high-level overview and more like a manual for the operational loops that actually drive a cluster.
The authors anchor the entire book around a demo application called kuard (Kubernetes Up and Running Demo). Instead of abstract “Hello World” examples, they use kuard to demonstrate real behavior. For example, early on they walk through optimizing image size with multistage Docker builds, compiling the Go binary and React frontend separately from the runtime image. Later, kuard’s built-in memory stress test is used to show exactly what happens when a Pod exceeds its memory limits versus its requests.
The progression of concepts is very deliberate. It starts by contrasting imperative commands with Kubernetes’ immutable, declarative model. From there, it moves from Pods to ReplicaSets and explains the reconciliation loop that enables self-healing. The networking section clearly separates Layer 4 Services (ClusterIP, NodePort, LoadBalancer) from Layer 7 Ingress, using the Contour controller as a concrete example of path-based routing.
The chapter on Deployments was especially practical. Instead of stopping at “what a rollout is,” it breaks down how maxUnavailable and maxSurge actually affect availability and throughput, and how to tune them. It also explicitly calls out the requirement for backward and forward compatibility during rolling updates, when multiple application versions are running at the same time.
The book goes beyond standard web services as well. It covers DaemonSets using log collectors like Fluentd, Jobs and CronJobs for batch tasks such as database migrations, and StatefulSets through a replicated MongoDB example. That section makes the need for stable network identities (like mongo-0, mongo-1) very concrete compared to random Pod names.
It also addresses “day 2” concerns that many introductory resources skip, including governance with Gatekeeper and OPA, and writing custom controllers using the Kubernetes API. Instead of hand-waving, it includes actual code examples in Python, Java, and .NET that use the Informer pattern rather than shell scripts.
Overall, the book feels like a practitioner’s reference. Reading it after working with Kubernetes made the design decisions much clearer, from readiness probe thresholds to RBAC verb granularity. It really bridges the gap between basic definitions and the realities of running systems in production.
December 1, 2021
This is a review for the second edition of K8S U&R, even though early access for the third edition is already available on some of the platforms.
Reading this book feels like walking in a park. Almost no code snippets to follow, no excruciating technical details. Read yamls and a very few imperative CLI commands. If all books for system administrators are like that, I'm curious, why the OPS guys are paid on the same level with developers.
Speaking of the book itself, I can't say that I've learned much from it. It definitely covers all the basics and gives a few tips.
Definitely better than the manual, better skip it if you already know the basics.
Reading this book feels like walking in a park. Almost no code snippets to follow, no excruciating technical details. Read yamls and a very few imperative CLI commands. If all books for system administrators are like that, I'm curious, why the OPS guys are paid on the same level with developers.
Speaking of the book itself, I can't say that I've learned much from it. It definitely covers all the basics and gives a few tips.
Definitely better than the manual, better skip it if you already know the basics.
February 27, 2022
I kind of wish I've read it earlier, as this book simply explains all basic building blocks of applications running in Kubernetes clusters.
It's not that long, if you just read it without experimenting with code snippets on your own, you can manage to read it in one day.
Highly recommend if you come to the point, that you need to understand what resources in Kubernetes are responsible for what (there comes such moment when learning Kubernetes, at least in my case it did).
It's not that long, if you just read it without experimenting with code snippets on your own, you can manage to read it in one day.
Highly recommend if you come to the point, that you need to understand what resources in Kubernetes are responsible for what (there comes such moment when learning Kubernetes, at least in my case it did).
April 23, 2018
Very good technical book about deployment, scaling and management of containerized applications, written by some of the engineers who originally developed Kubernetes at Google. This is a new software architecture paradigm that will change how we build, deploy and maintain services in the cloud and will make virtual machine hosted servers obsolete.
February 18, 2021
I found it really useful. It starts with the very basics and goes deeper with some real world examples and interesting situations.
One thing that caught my eyes: At the begining I thought I knew enough about kubernetes, but from chapter 15 on I realised I still had so much to learn =)
One thing that caught my eyes: At the begining I thought I knew enough about kubernetes, but from chapter 15 on I realised I still had so much to learn =)
July 21, 2020
Good introduction to Kubernetes, but I would not rush it to production after reading only this book.
January 10, 2021
Easy to read for the writing style as well as the number of pages. I've read a printed version that's easy to carry along, and the number of pages per chapter let me read one at one sitting without much effort (and quite often invited for another one). That's exactly the book about Kubernetes I'd recommend to beginners like myself and am tempted to call it the book for Kubernetes novices.
December 15, 2023
496-Kubernetes: Up & Running-Kelsey Hightower- Container-2016
Barack
2023/12/14
"Kubernetes: Up & Running", first published in 2016. This book explores how Kubernetes and container technology can help you achieve new levels of speed, agility, reliability, and efficiency. It explains how the system fits into the life cycle of distributed applications. You'll learn how to use tools and APIs to automate scalable distributed systems, whether they're online services, machine learning applications, or clusters of Raspberry Pi computers.
Kelsey Hightower was born in Long Beach, California in 1981. is an American software engineer, developer advocate, and speaker known for his work on Kubernetes, open-source software, and cloud computing. He joined CoreOS as an early team member in early 2014 and began making significant contributions to the Kubernetes project. Hightower has been working as an engineer and developer advocate in Google's cloud computing division since November 2015. As of October 2022, Hightower is a Distinguished Engineer at Google Cloud with an Individual Contributor Level 9 (L9). On June 26, 2023, Hightower announced his retirement from Google on Twitter, saying that "if everything goes as planned, this will be his last job."
Containerization, in software engineering, is operating system-level virtualization or application-level virtualization across multiple network resources so that software applications can be run in isolated user spaces called containers in any cloud or non-cloud environment regardless of type or supplier. A container is basically a fully functional and portable cloud or non-cloud computing environment that surrounds an application and makes it independent of other environments running in parallel. Each container individually emulates a different software application and runs independent processes by bundling related configuration files, libraries, and dependencies. However, in general, multiple containers share a common operating system kernel (OS). In recent years, containerization technology has been widely adopted by cloud computing platforms such as Amazon Web Services, Microsoft Azure, Google Cloud Platform, and IBM Cloud.
Kubernetes was first released in September 2014. It is an open-source container orchestration system for automated software deployment, scaling, and management. The project was originally designed by Google and is now maintained by the Cloud Native Computing Foundation. The name Kubernetes comes from ancient Greek, meaning "helmsman" or "pilot." Kubernetes is often abbreviated as K8s, counting the eight letters between K and s (the number). Kubernetes works with various container runtimes, such as containers and CRI-O. It is suitable for running and managing large-scale cloud-native workloads, so it has been widely adopted in data centers. The platform is available in multiple distributions - from independent software vendors (ISVs) as well as cloud-hosted offerings from all major public cloud providers.
Table of Contents
Chapter 1. Introduction
Chapter 2. Creating and Running Containers
Chapter 3. Deploying a Kubernetes Cluster
Chapter 4. Common kubectl Commands
Chapter 5. Pods
Chapter 6. Labels and Annotations
Chapter 7. Service Discovery
Chapter 8. ReplicaSets
Chapter 9. DaemonSets
Kubernetes is a container orchestration tool whose core is a series of APIs that enable users to manage containers more effectively. Containers are lightweight virtualization technologies at the operating system level or application level that have several significant advantages. First, speed. Speed here not only means enabling developers to quickly iterate their applications and services but also means that services can continue to run without interruption during the iteration process. We are now accustomed to real-time updates of software. For example, when using taxi-hailing software, this software must run online, and users have almost no awareness of the update process. Another feature of Kubernetes is its ease of operation. It enables better scaling of services. Because cloud products need to support an uncertain number of users, they must have strong scalability. For example, reduce the number of servers when the number of users is small, and dynamically increase the number of servers when the number of users increases. Third, Kubernetes improves the understandability and reusability of infrastructure by abstracting your infrastructure. Finally, efficiency. Compared with traditional virtualization technologies (such as hypervisor-based virtualization), container-based virtualization (containerization) is implemented at the operating system level or application level, which means that it requires less resource overhead. Therefore, under the same resource conditions, it can support more virtual machine instances, thereby improving efficiency.
Before understanding Kubernetes, let us first sort out container technology and its relationship with Kubernetes. First, imagine we have a physical machine. An operating system is running on this physical machine, and the operating system schedules resources on the physical machine through APIs such as assembly instructions. This operating system is what we usually call Kernel. On top of the operating system, we can run multiple containers. Each container is like an independent virtual machine, and it communicates with the operating system through APIs. What Kubernetes provides is a set of APIs for managing these containers. It is an orchestration tool used to manage containers on top of the operating system, or it can also be called a scheduling tool. Several advantages of Kubernetes include: First, the declarative nature of configuration. Kubernetes allows users to declaratively configure the required resources. For example, if you declare that you need three copies of a container, Kubernetes will ensure that there are always three copies running. If a container changes, its replicas are updated accordingly. Second, high efficiency. Kubernetes improves efficiency by decoupling services. Different services, such as the three ABC services, can share the same physical machine or run on different containers in the same cluster. This means that developers do not need to care about which machine the service is running on. Kubernetes will automatically schedule computing resources based on the demand for these services. Third, scalability. Because Kubernetes decouples the relationship between services and physical machines, when the service requires more computing resources, the service can be easily scaled by increasing the number of containers. This flexibility is similar to placing containers from different companies in a large factory. Compared with purchasing land and building buildings, this method is more flexible and efficient in resource allocation.
Kubernetes is designed for cloud-native environments. The so-called "cloud-native applications" refer to those applications that specifically run in the public cloud, private cloud, or hybrid cloud environments. A core characteristic of these applications is their high degree of scalability, that is, their ability to flexibly adapt to changes in service requirements. To achieve this goal, developers often split the application into numerous microservices. The coupling between these microservices is low, but they work together to complete complex business requirements. These microservices usually run in containers, such as common open-source container technologies such as Docker. In this, Kubernetes plays a crucial role. It is essentially an API library for managing containers, used for container deployment, management, scheduling, etc. From the perspective of the entire development life cycle, developers can also use methods and tools such as DevOps or CICD (continuous integration and continuous deployment) to achieve continuous updates and maintenance of cloud products and services without interrupting services. A key advantage of container technology is isolation - its ability to isolate services running within the container from the external environment. It's like a container. No matter where it is moved, the environment inside the container is not affected by the outside world.
Kubernetes uses "declarative configuration", which focuses on the state that the system should achieve rather than the specific steps of the execution process. This is in contrast to "imperative configuration", which focuses on specific operation steps rather than the state of the system after the operation is completed. For example, if my configuration goal is to maintain three backups, then in a declarative configuration, all I care about is ensuring that three backups exist at all times. This approach defines the state the system should reach. In the imperative configuration, if specific copy steps are configured, such as copying A first, then copying B from A, and then copying C from B, this method defines the specific operations to be performed. In this case, the number of backups after the operation is completed is undefined. In terms of the specific method to achieve this goal, there is a key component in Kubernetes called "Operator", which is essentially an extension of the Kubernetes API. The Operator continuously monitors the current state. If it finds that the current state is inconsistent with the declared target state, it will automatically take various measures to ensure that the current state is consistent with the declared state.
In Kubernetes, there are several core concepts that need to be understood: First, Pod (a group). Pod is the basic running unit of Kubernetes and can contain one or more tightly coupled containers. Containers in the same Pod share computing resources, which makes the Pod the smallest unit in the Kubernetes architecture. Secondly, Cluster. Cluster is a high-level concept that consists of multiple physical machines, usually including a master node (for management and scheduling) and multiple worker nodes (for performing specific tasks). In parallel computing, when the computing power of one physical machine is insufficient, a cluster composed of multiple physical machines is used. In a Cluster, multiple Pods can be running, and each Pod can be responsible for different microservices. Third, Namespace. Namespace is a method of dividing a larger cluster into smaller sub-clusters, which determines the scope of the command. You can think of it as a defined circle. Inside the circle is a sub-cluster. Your command only takes effect on the resources in this sub-cluster and does not affect other parts outside the circle. Fourth, Ingress: The Ingress object is an API object in Kubernetes and is mainly responsible for managing ingress traffic. It defines the way for external access to the internal services of the Kubernetes cluster, including how to route external requests to various services within the cluster.
August 9, 2020
Essential for a comprehensive introduction to Kubernetes!
October 31, 2017
I had high expectations for this books due to the high profiles of the authors. The book is very ordinary. It just introduces what various concepts are (like replicasets, deployments, daemonsets, etc.) at a very beginner level (one per chapter). Nothing is mentioned about how to deploy kubernetes apps in a public cloud, probably, as each of the authors work in different competing companies. Zero information about internals of kubernetes either. The book is neither for beginners nor for advanced users. It just lingers somewhere in between with no justice to either side.
Instead of wasting money (and more importantly time) on this book, you will get far better knowledge, if you spend some time on youtube videos, where all these stuff are explained much more clearly, with live examples. If it were possible to get a refund, I would have asked for it. The book costed a lot more for me, because it was an imported copy and no low-price-edition available in India, which annoyed me more when the book quality was so shallow.
Instead of wasting money (and more importantly time) on this book, you will get far better knowledge, if you spend some time on youtube videos, where all these stuff are explained much more clearly, with live examples. If it were possible to get a refund, I would have asked for it. The book costed a lot more for me, because it was an imported copy and no low-price-edition available in India, which annoyed me more when the book quality was so shallow.
October 17, 2023
This book is excellent to get your feet wet with Kubernetes. It is not very deep — even though it sometimes highlights some nuances of the system — but it is wide in a healthy way. Highly recommend it if you’re beginning the long journey of learning Kubernetes properly.
July 13, 2020
I only have an udemy course to compare this to, but I found "Kubernetes: Up & Running" to be a really excellent introduction to the high level resources, concepts, and best practices of Kubernetes.
The Good:
- Well paced / laid out - the book starts with "Why Kubernetes", then moves through basic kubectl commands, then through the basic Kubernetes resources/concepts (Pods, Service Discovery, Replication Sets, etc), and finishes with some real world applications and advice for how to do things in the real world.
- Minimum Viable Example - I mean this in the best way, the examples in the book present exactly what is being taught and no more for a given concept, instead of trying to create a great big application which demonstrates multiple concepts. I found this reduced the cost to actually trying things out and made me more likely to plug things in to follow along.
- Quite broad - Take this with a grain of salt, since I've not yet used Kubernetes in production, but something I liked about this book over the Udemy course I took "Docker and Kubernetes: The Complete Guide" is that it really covers a very wide breadth of material (DaemonSets, RBAC, How to integrate with services external to Kubernetes). While these might not be enough to complete your project, they've given me the vocabulary to look things up myself.
The Not So Good:
- Some of the examples don't work as written (At least in the O'Reilly Safari Books version). This is kind of to be expected with a rapidly evolving technology, and most are fixable from the excellent Kubernetes error messages.
- The book talks frequently about doing things declaratively instead of imperatively, but always presents things imperatively first - this is a nit, but I wish they led off with the "correct" way.
Overall:
Amazing Kubernetes book would recommend to anyone getting started with k8s
The Good:
- Well paced / laid out - the book starts with "Why Kubernetes", then moves through basic kubectl commands, then through the basic Kubernetes resources/concepts (Pods, Service Discovery, Replication Sets, etc), and finishes with some real world applications and advice for how to do things in the real world.
- Minimum Viable Example - I mean this in the best way, the examples in the book present exactly what is being taught and no more for a given concept, instead of trying to create a great big application which demonstrates multiple concepts. I found this reduced the cost to actually trying things out and made me more likely to plug things in to follow along.
- Quite broad - Take this with a grain of salt, since I've not yet used Kubernetes in production, but something I liked about this book over the Udemy course I took "Docker and Kubernetes: The Complete Guide" is that it really covers a very wide breadth of material (DaemonSets, RBAC, How to integrate with services external to Kubernetes). While these might not be enough to complete your project, they've given me the vocabulary to look things up myself.
The Not So Good:
- Some of the examples don't work as written (At least in the O'Reilly Safari Books version). This is kind of to be expected with a rapidly evolving technology, and most are fixable from the excellent Kubernetes error messages.
- The book talks frequently about doing things declaratively instead of imperatively, but always presents things imperatively first - this is a nit, but I wish they led off with the "correct" way.
Overall:
Amazing Kubernetes book would recommend to anyone getting started with k8s
January 17, 2018
The Kubernetes book we've been waiting for.
If you're using Kubernetes, you probably heard of Kelsey Hightower by now and anticipated a book by him. Well, now partnered with O'Reilly - they deliver!
The book follows the standard narrative of the "Up & Running" series - go through different topics by providing the minimum valuable code snippets and then build it all up to one big application that showcases everything learnt so far.
Given Kubernetes history of changes, the book manages to cover the things you'll use the most which is `ReplicaSet`s and `Deployment`s, but also do a good job going through the basics which are `Service`, ` and `Pod`.
Pay very close attention to the `Deployment` strategies explained which are `Recreate` and `RollingUpdate`. It covers hard-learnt lessons on production environments for free! You don't have to go through that on your production environment. :)
However there's a bit of lack of "advanced" features such as Ingress/Egress. Although the scenarios where you need them are rare, they're essential to understanding how a Service works.
If you're using Kubernetes, you probably heard of Kelsey Hightower by now and anticipated a book by him. Well, now partnered with O'Reilly - they deliver!
The book follows the standard narrative of the "Up & Running" series - go through different topics by providing the minimum valuable code snippets and then build it all up to one big application that showcases everything learnt so far.
Given Kubernetes history of changes, the book manages to cover the things you'll use the most which is `ReplicaSet`s and `Deployment`s, but also do a good job going through the basics which are `Service`, ` and `Pod`.
Pay very close attention to the `Deployment` strategies explained which are `Recreate` and `RollingUpdate`. It covers hard-learnt lessons on production environments for free! You don't have to go through that on your production environment. :)
However there's a bit of lack of "advanced" features such as Ingress/Egress. Although the scenarios where you need them are rare, they're essential to understanding how a Service works.
November 2, 2023
"Kubernetes Up and Running" can be a bit overwhelming at the beginning, but hang in there. Once you get past the initial hurdles, it's a valuable resource for beginners like me.
The book shines when it comes to explaining Pods and simplifying complex concepts. It sets you up with a strong foundation in Kubernetes and even guides you on creating your learning lab. The included manifest files are super helpful, although I did spot a few typos and missing parts in the YAML files, mostly in the Rego sections. A quick online search can help you find the right information, though. Here is my Github repo that I've forked from "kubernetes-up-and-running/kuard" and added fixed files from book: https://github.com/yusufatalay/kuard
I've successfully implemented the book's teachings, and it's boosted my understanding of Kubernetes. If you're a newbie like me, don't be discouraged by the initial complexity. "Kubernetes Up and Running" is a great starting point for your journey into Kubernetes.
The book shines when it comes to explaining Pods and simplifying complex concepts. It sets you up with a strong foundation in Kubernetes and even guides you on creating your learning lab. The included manifest files are super helpful, although I did spot a few typos and missing parts in the YAML files, mostly in the Rego sections. A quick online search can help you find the right information, though. Here is my Github repo that I've forked from "kubernetes-up-and-running/kuard" and added fixed files from book: https://github.com/yusufatalay/kuard
I've successfully implemented the book's teachings, and it's boosted my understanding of Kubernetes. If you're a newbie like me, don't be discouraged by the initial complexity. "Kubernetes Up and Running" is a great starting point for your journey into Kubernetes.
November 13, 2022
An excellent introductory book for entering the Kubernetes world.
Pros:
- A brief and quick introduction to essential Kubernetes concepts, and components and also a fundamental understanding of Docker containers.
- Hands-on exercises. If you have subscribed to O'Reilly online learning platform, you can practice the exercises directly on the interactive lab pages.
- Cover many aspects of administering Kubernetes, as well as some suggestions for organizing your applications so that you could have a happy life for years to come after your Kubernetes cluster is deployed.
Cons:
- No whole system architecture and concepts are introduced in the book. It assumes that you are already knowing what Kubernetes is and what is inside it.
- The code in this 3rd edition is still old, it would be better to update and correct some typos.
- The writing style in some chapters is not ... consistent because there are many authors?
Pros:
- A brief and quick introduction to essential Kubernetes concepts, and components and also a fundamental understanding of Docker containers.
- Hands-on exercises. If you have subscribed to O'Reilly online learning platform, you can practice the exercises directly on the interactive lab pages.
- Cover many aspects of administering Kubernetes, as well as some suggestions for organizing your applications so that you could have a happy life for years to come after your Kubernetes cluster is deployed.
Cons:
- No whole system architecture and concepts are introduced in the book. It assumes that you are already knowing what Kubernetes is and what is inside it.
- The code in this 3rd edition is still old, it would be better to update and correct some typos.
- The writing style in some chapters is not ... consistent because there are many authors?
October 27, 2017
This is a quick read that gives a good overview of Kubernetes and what it is all about. I have never used it myself, but there is talk about this being the future of automation. Basically Kubernetes allows you to automate containers. Mainly Docker. I don't know Docker yet either, so I probably should have started there. Apparently Google has been using this for 10 years already, so you know it is legit. It was made open source and expanded upon by the open source community. The appendix in here explains how to build a Raspberry Pi Kubernetes cluster. I may finally have a reason to get a Raspberry Pi. There was not a whole lot of technical information in here. I think this book is more of a show and tell of what it can do. Probably a good place to start if you are new to Kubernetes or are looking to get into it. It gives you plenty of commands to try, but does not go too in depth.
January 23, 2022
I read the first edition to try host my app in Kubernetes, but we never got around to it. I read the second edition just to refresh the core concepts for a work project and for that, it was useful. The book is ok, generally to the point, didn't find any errors but didn't cross check either.
What I'm still puzzled about is how to imitate something as simple as Heroku. The book talks about continuous delivery, but expects a commit pointing to a new image to be able to deploy the new image. And if you just point to the latest image, it doesn't matter if what latest change, Kubernetes won't update. There's a lot of plumbing that needs to be built on top of Kubernetes to have something usable and I feel this book doesn't acknowledge that until the last few pages, and even then, it doesn't really tell you even enough to start searching for what the plumbing should be.
What I'm still puzzled about is how to imitate something as simple as Heroku. The book talks about continuous delivery, but expects a commit pointing to a new image to be able to deploy the new image. And if you just point to the latest image, it doesn't matter if what latest change, Kubernetes won't update. There's a lot of plumbing that needs to be built on top of Kubernetes to have something usable and I feel this book doesn't acknowledge that until the last few pages, and even then, it doesn't really tell you even enough to start searching for what the plumbing should be.
December 29, 2017
Straightforward introduction to Kubernetes, covers most of the basics (and is mostly cloud-provider agnostic, did it all on GCP and it was all good) and goes all the way to setting up a stateful application. Includes examples of how to use config maps, services, pods, replica sets, daemon sets and stateful sets, lots of stuff to take on.
Some examples have typos or need updating to the latest version (I did this in a 1.7 cluster on GCP) but it's nothing that drives down the value. Also, if on GCP you don't need to setup anything for dynamic (or manual) volume creation, it will do it all for you, pretty good to get started and playing around. Don't forget to delete your servers once you're done, tho.
Some examples have typos or need updating to the latest version (I did this in a 1.7 cluster on GCP) but it's nothing that drives down the value. Also, if on GCP you don't need to setup anything for dynamic (or manual) volume creation, it will do it all for you, pretty good to get started and playing around. Don't forget to delete your servers once you're done, tho.
May 23, 2023
The book would be ok as an internet documentation site but is quite bad as a book.
It style is basically "Do 1,2,3 and you get that; don't ask why, that is the proper google way, no questions".
It would be ok for how-tos and getting started (that's you are basically looking for when you are browsing for them) but not for the book that you read from start through finish.
Probably it could be ok for reference but you usually browse the API docs for that but not the books.
Really can't find good use for the book.
Note: I read about 1/3 of the book to get the impression. Hopefully the other parts of the book are more useful, will find that out soonish.
It style is basically "Do 1,2,3 and you get that; don't ask why, that is the proper google way, no questions".
It would be ok for how-tos and getting started (that's you are basically looking for when you are browsing for them) but not for the book that you read from start through finish.
Probably it could be ok for reference but you usually browse the API docs for that but not the books.
Really can't find good use for the book.
Note: I read about 1/3 of the book to get the impression. Hopefully the other parts of the book are more useful, will find that out soonish.
March 21, 2019
The book is a complete pack for anyone starting or wanting to catch up with kubernetes. However I would love to see more practical examples. Don't get me wrong there's plenty of practical advice but only one sample how to glue everything altogether. I felt also confused about all options I can choose for persistency. I should also point out that there is little about kubernetes architecture. Overall it's a solid book thought but I need to supplement it with some Internet reading or another book.
Displaying 1 - 30 of 123 reviews