|
|
posted: December 23, 2017
tl;dr: A must-read for anyone seriously experimenting with or starting to use Kubernetes...
My starting point: we’ve been using Kubernetes in production for nearly a year now at Uprising Technology, and I am very impressed with how Kubernetes has performed for us. Our production platform has been rock-solid, performing even better than the previous generation of our product, which was a Google App Engine project (previously we would get the very occasional 500 error on our overall system health check job, even though App Engine was supposed to always have at least one instance up-and-running at all times - we never quite eliminated those rare errors).
I’m impressed with Kubernetes’ robustness and recovery processes: it is hard to kill off our app, because as soon as you delete one pod a new one is spawned to replace it. We’re able to take advantage of standardized Docker containers for the various open-source tools we use in production. Our overall application is split into microservices inside Docker containers, which isolates functionality and lets us avoid the challenges of updating and deploying a monolith. We have a fully automated deployment pipeline: we just push a commit into the production branch of a code repository in GitHub and then the pipeline takes over, and soon a rolling update is done to each of the pods and the new code is deployed in production, without further human intervention. We’ve now deployed to two different cloud providers, Google and AWS, and I am sure we could easily do Azure and on premises hosting if needed. So Kubernetes has been great for us and has delivered on all of its main promises.
All this infrastructure was designed, configured, and deployed by our primary cloud engineer well before this book was published. When it came out he bought a copy and read it to verify the decisions that he had made, and then he gave it to me to read. My involvement with Kubernetes has been monitoring the performance of our various clusters, investigating issues such as seeing how much memory and CPU is being used, doing deployments, and occasionally updating configuration maps and pods.
For me, and for anyone thinking seriously about using Kubernetes or starting to use Kubernetes, this is a great book to both learn and put into practice the basic overall Kubernetes workflow. It stands a very good chance of becoming the primary “go to” book on Kubernetes, sort of the “K&R” for Kubernetes. The authors created an example app called “kuard”, which can be used to peek inside many of the features of Kubernetes. They then walk through the entire process of containerizing the app, deploying it, setting up redundancy, hooking in storage and other configuration data, and monitoring it. Kubernetes uses declarative programming, which is a great fit for what it is trying to accomplish, and the book provides many examples of how to accomplish various tasks in the Kubernetes YAML files. The book also provides a number of “best practice” implementations. I had used a number of Kubernetes commands in isolation, but for me this book did a great job of putting everything into the context of an overall Kubernetes workflow. Maybe someday we’ll get around to building the Raspberry Pi Kubernetes cluster in the appendix, as a product demo for our company.
Kubernetes Up & Running certainly achieves the goal spelled out in the title, and should get you up-and-running with your first Kubernetes cluster. It does not attempt to be a complete reference guide to Kubernetes, nor does it get into some of the newer, more advanced features such as federations. Kubernetes will continue to evolve quickly and grow in usage, but with its strong emphasis on backwards compatibility (as befits a basic infrastructure technology) hopefully this book will age well.
Kubernetes Up & Running is well worth the time and money you may spend on it. Highly recommended.