|The Book Of Kubernetes
Author: Alan Hohn
Containers such as Kubernetes let developers deploy apps in a platform-independent way and this book sets out to explain what containers are and how to use them.
The first part of the book looks at how to make and use containers in Kubernetes, starting with a look at why containers matter, and how they achieve process isolation.
Having explained how process isolation works and what its benefits are, Hohn moves on to resource limiting to ensure that a process uses only the CPU, memory and network resources you assign to it.
A chapter on network namespaces is next. Hohn says container networking is the biggest challenge in containerized development, and this chapter looks at the concept of Linux namespaces as used by Kubernetes to isolate the processes in the Kubernetes container.
Part One of the book concludes with a chapter on container images and runtime layers as a way of bundling an application with its dependencies such as storage, configuration files, logs and data.
Part Two of the book looks in more detail at containers in Kubernetes, starting with a chapter looking more closely at the benefits of Kubernetes. This is followed by an in-depth look at deploying containers to Kubernetes. A chapter on overlay networks are used to provide the appearance of a single container network across all nodes in a Kubernetes cluster. Overlay networks aren't the only network aspect of Kubernetes, and a chapter on service and ingress networks is next, considering how these support dynamic discover, load balancing and traffic routing.
A chapter on when things go wrong looks at problems with scheduling, images, and running containers and how to put things right follows. Hohn then moves on to the control plane and access control. The control plane manages the Kubernetes cluster and stores desired state of the applications, monitoring, scheduling and recovery. The use of role-based access controls is also covered in this chapter.
While the control plane manages the cluster, the container runtime creates, starts, stops and deletes containers, and this is the topic of the next chapter.
Working out what makes an application 'healthy', and how to set up and use probes to check a pod and its containers are healthy is covered next. This is followed by a look at specifying and managing limits and quotas to make sure an app doesn't use all the CPU or memory on a node.
CPU and memory aren't the only resources to be managed, and the next chapter looks at how Kubernetes offers persistent storage to pods using a plug-in architecture so that any supported distributed storage can act as the backing store.
A chapter on configuration and secrets comes next, showing how Kubernetes injects configuration information into container runtimes to ensure the app behaves in the desired way. Part two of the book concludes with a chapter on custom resources and operators and how to define and use them.
The final part of the book is titled "Performant Kubernetes", and it begins with a chapter on affinity and devices, considering how to use other components and hardware while still getting the best from the Kubernetes closed box model. A chapter on quality of service and how to fine-tune it comes next, and the book closes with a chapter on application resiliency and how to achieve it.
This is a useful book that explains clearly what Kubernetes offers and how to get the best from it. Recommended.
|Last Updated ( Tuesday, 09 May 2023 )