book

Kubernetes in Action, Second Edition

Name: Kubernetes in Action, Second Edition
ISBN: 9781617297618

by Kevin Conner, Marko Luksa

March 2026

Beginner to intermediate

688 pages

20h 44m

English

Manning Publications

Read now

Unlock full access

Kubernetes in Action, Second Edition
copyright
contents
Praise for the First Edition
dedication
preface
acknowledgments
about this book
about the authors
about the cover illustration

Part 1 Getting started
1 Introducing Kubernetes
1.1 Introducing Kubernetes1.1.1 Kubernetes in a nutshell1.1.2 About the Kubernetes project1.1.3 Understanding why Kubernetes is so popular1.2 Understanding Kubernetes1.2.1 Understanding how Kubernetes transforms a computer cluster1.2.2 The benefits of using Kubernetes1.2.3 The architecture of a Kubernetes cluster1.2.4 How Kubernetes runs an application1.3 Introducing Kubernetes into your organization1.3.1 Running Kubernetes on-premises and in the cloud1.3.2 To manage or not to manage Kubernetes yourself1.3.3 Using vanilla or extended Kubernetes1.3.4 Should you even use Kubernetes?
2 Understanding containers and containerized applications
2.1 Introducing containers2.1.1 Comparing containers to VMs2.1.2 Introducing the Docker container platform2.1.3 Installing Docker and running a “Hello, World!” container2.1.4 Introducing the Open Container Initiative and Docker alternatives2.2 Deploying the Kubernetes in Action Demo Application2.2.1 Introducing the Kiada Application2.2.2 Building the application2.2.3 Running the container2.2.4 Distributing the container image2.2.5 Stopping, resuming, and deleting the container2.3 Understanding containers2.3.1 Customizing the process environment with Kernel Namespaces2.3.2 Exploring the environment of a running container2.3.3 Limiting the resources available to a process using cgroups2.3.4 Strengthening isolation between containers
3 Deploying your first application on Kubernetes
3.1 Deploying a Kubernetes cluster3.1.1 Using the built-in Kubernetes cluster in Docker Desktop3.1.2 Running a local cluster using Minikube3.1.3 Running a local cluster using kind (Kubernetes in Docker)3.1.4 Creating a managed cluster with Google Kubernetes Engine3.1.5 Creating a cluster using Amazon Elastic Kubernetes Service3.1.6 Deploying a multi-node cluster from scratch3.2 Interacting with Kubernetes3.2.1 Setting up kubectl, the Kubernetes command-line client3.2.2 Configuring kubectl to use a specific Kubernetes cluster3.2.3 Using kubectl3.2.4 Interacting with Kubernetes through web dashboards3.3 Running your first application on Kubernetes3.3.1 Deploying your application3.3.2 Exposing your application to the world3.3.3 Horizontally scaling the application3.3.4 Understanding the deployed application
4 Navigating the Kubernetes API and object model
4.1 Getting familiar with the Kubernetes API4.1.1 Introducing the API4.1.2 Understanding the structure of an object manifest4.2 Examining an object’s individual properties4.2.1 Exploring the full manifest of a Node object4.2.2 Understanding individual object fields4.2.3 Understanding an object’s status conditions4.2.4 Inspecting objects using the kubectl describe command4.3 Observing cluster events via Event objects4.3.1 Introducing the Event object4.3.2 Examining the YAML of the Event object
Part 2 Running applications in Kubernetes
5 Running applications with pods
5.1 Understanding pods5.1.1 Understanding the purpose of pods5.1.2 Organizing containers into pods5.2 Creating pods from YAML or JSON files5.2.1 Creating a YAML manifest for a pod5.2.2 Creating the Pod object from the YAML file5.2.3 Checking the newly created pod5.3 Interacting with the application and the pod5.3.1 Sending requests to the application in the pod5.3.2 Viewing application logs5.3.3 Attaching to a running container5.3.4 Executing commands in running containers5.3.5 Copying files to and from containers5.3.6 Debugging pods using ephemeral containers5.4 Running multiple containers in a pod5.4.1 Extending the Kiada Node.js application using the Envoy proxy5.4.2 Adding Envoy proxy to the pod5.4.3 Interacting with the two-container pod5.5 Running additional containers at pod startup5.5.1 Introducing init containers5.5.2 Adding init containers to a pod5.5.3 Inspecting init containers5.5.4 Kubernetes native sidecar containers5.6 Deleting pods and other objects5.6.1 Deleting a pod by name5.6.2 Deleting objects defined in manifest files5.6.3 Deleting all pods5.6.4 Deleting objects using the “all” keyword
6 Managing the pod life cycle and container health
6.1 Understanding the pod’s status6.1.1 Understanding the pod phase6.1.2 Understanding pod conditions6.1.3 Understanding the container status6.2 Keeping containers healthy6.2.1 Understanding container auto-restart6.2.2 Checking the container’s health using liveness probes6.2.3 Creating an HTTP GET liveness probe6.2.4 Observing the liveness probe in action6.2.5 Using the exec and the tcpSocket liveness probe types6.2.6 Using a startup probe when an application is slow to start6.2.7 Creating effective liveness probe handlers6.3 Executing actions at container start-up and shutdown6.3.1 Using post-start hooks to perform actions when the container starts6.3.2 Using pre-stop hooks to run a process just before the container terminates6.4 Understanding the pod life cycle6.4.1 Understanding the initialization stage6.4.2 Understanding the run stage6.4.3 Understanding the termination stage6.4.4 Visualizing the full life cycle of the pod’s containers
7 Organizing pods and other resources using namespaces and labels
7.1 Organizing objects into namespaces7.1.1 Listing namespaces and the objects they contain7.1.2 Creating namespaces7.1.3 Managing objects in other namespaces7.1.4 Understanding the (lack of) isolation between namespaces7.1.5 Deleting namespaces7.2 Organizing pods with labels7.2.1 Introducing labels7.2.2 Adding labels to pods7.2.3 Label syntax rules7.2.4 Using standard label keys7.3 Filtering objects with label selectors7.3.1 Using label selectors for object management with kubectl7.3.2 Using label selectors in object manifests7.4 Filtering objects with field selectors7.4.1 Using a field selector in kubectl7.4.2 Using field selectors in object manifests7.5 Annotating objects7.5.1 Introducing object annotations7.5.2 Adding annotations to objects7.5.3 Inspecting an object’s annotations7.5.4 Updating and removing annotations
Part 3 Application configuration and storage
8 Configuring applications with ConfigMaps and Secrets
8.1 Setting the command, arguments, and environment variables8.1.1 Setting the command and arguments8.1.2 Setting environment variables in a container8.2 Using a ConfigMap to decouple configuration from the pod manifest8.2.1 Introducing ConfigMaps8.2.2 Creating a ConfigMap object8.2.3 Injecting ConfigMap values into environment variables8.2.4 Updating and deleting ConfigMaps8.3 Using Secrets to pass sensitive data to containers8.3.1 Introducing Secrets8.3.2 Creating a Secret8.3.3 Using Secrets in containers8.3.4 Understanding why Secrets aren’t always secure8.4 Exposing metadata to containers via the Downward API8.4.1 Introducing the Downward API8.4.2 Injecting pod metadata into environment variables
9 Adding volumes for storage, configuration, and metadata
9.1 Introducing volumes9.1.1 Understanding when to use a volume9.1.2 Understanding how volumes fit into pods9.2 Using an emptyDir volume9.2.1 Persisting files across container restarts9.2.2 Initializing an emptyDir volume9.2.3 Sharing files between containers9.3 Mounting a container image as a volume9.3.1 Introducing the image volume type9.4 Accessing files on the worker node’s filesystem9.4.1 Introducing the hostPath volume9.4.2 Using a hostPath volume9.5 ConfigMap, Secret, Downward API, and projected volumes9.5.1 Using a configMap volume to expose ConfigMap entries as files9.5.2 How configMap volumes work9.5.3 Using Secret volumes9.5.4 Setting file permissions and ownership in a secret/configMap volume9.5.5 Using a downwardAPI volume to expose Pod metadata as files9.5.6 Using projected volumes to combine volumes into one9.6 Other volume types at a glance
10 Persisting data with PersistentVolumes
10.1 Introducing persistent storage in Kubernetes10.1.1 Introducing PersistentVolumeClaims and PersistentVolumes10.1.2 Dynamic vs. static provisioning of PersistentVolumes10.2 Dynamically provisioning a PersistentVolume10.2.1 Creating a PersistentVolumeClaim10.2.2 Using PersistentVolumeClaims10.2.3 Deleting a PersistentVolumeClaim and PersistentVolume10.2.4 Understanding access modes10.2.5 Understanding StorageClasses10.2.6 About CSI drivers10.3 Statically provisioning a PersistentVolume10.3.1 Creating a node-local PersistentVolume10.3.2 Claiming a pre-provisioned PersistentVolume10.3.3 Releasing and recycling a manually provisioned PersistentVolume10.4 Managing PersistentVolumes10.4.1 Resizing PersistentVolumeClaims10.4.2 Creating a snapshot of a PersistentVolumeClaim10.4.3 Restoring a PersistentVolume from a snapshot10.5 Creating ephemeral PersistentVolumes for individual pods10.5.1 Introducing the ephemeral volume type10.5.2 Understanding the benefits of using an ephemeral volume
Part 4 Connecting and exposing applications
11 Exposing pods with services
11.1 Exposing pods via services11.1.1 Introducing services11.1.2 Creating and updating services11.1.3 Accessing cluster-internal services11.2 Exposing services externally11.2.1 Exposing pods through a NodePort service11.2.2 Exposing a service through an external load balancer11.2.3 Configuring the external traffic policy for a service11.3 Managing service endpoints11.3.1 Introducing the Endpoints object11.3.2 Introducing the EndpointSlice object11.3.3 Managing service endpoints manually11.4 Understanding DNS records for Service objects11.4.1 Inspecting a service’s A and SRV records in DNS11.4.2 Using headless services to connect to pods directly11.4.3 Creating a CNAME alias for an existing service11.5 Configuring services to route traffic to nearby endpoints11.5.1 Forwarding traffic only within the same node with internalTrafficPolicy11.5.2 Topology-aware hints11.6 Managing the inclusion of a pod in service endpoints11.6.1 Introducing readiness probes11.6.2 Adding a readiness probe to a pod11.6.3 Implementing real-world readiness probes
12 Using Ingress to route traffic to services
12.1 Introducing Ingresses12.1.1 Introducing the Ingress object kind12.1.2 Introducing the Ingress controller and the reverse proxy12.1.3 Installing an ingress controller12.2 Creating and using Ingress objects12.2.1 Exposing a service through an Ingress12.2.2 Path-based ingress traffic routing12.2.3 Using multiple rules in an Ingress object12.2.4 Setting the default backend12.3 Configuring TLS for an Ingress12.3.1 Configuring the Ingress for TLS passthrough12.3.2 Terminating TLS at the Ingress12.4 Additional Ingress configuration options12.4.1 Configuring the Ingress using annotations12.4.2 Configuring the Ingress using additional API objects12.5 Using multiple ingress controllers12.5.1 Introducing the IngressClass object kind12.5.2 Specifying the IngressClass in the Ingress object12.5.3 Adding parameters to an IngressClass12.6 Using custom resources instead of services as backends12.6.1 Using a custom object to configure Ingress routing
13 Routing traffic using the Gateway API
13.1 Introducing the Gateway API13.1.1 Comparing Gateway API to Ingress13.1.2 Understanding the Gateway API implementation13.1.3 Deploying Istio as the Gateway API provider13.2 Deploying a Gateway13.2.1 Understanding Gateway classes13.2.2 Creating a Gateway object13.2.3 Exploring the Gateway’s status13.3 Exposing HTTP services using HTTPRoute13.3.1 Creating a simple HTTPRoute13.3.2 Splitting traffic between multiple backends13.3.3 Routing HTTP requests to different backends13.3.4 Augmenting HTTP traffic with filters13.4 Configuring a gateway for TLS13.4.1 Terminating TLS sessions at the gateway13.4.2 End-to-end encryption using TLSRoutes and pass-through TLS13.5 Exposing other types of services13.5.1 Exposing a TCP service with a TCPRoute13.5.2 UDPRoute13.5.3 GRPCRoute13.6 Using Gateway API resources across namespaces13.6.1 Sharing a gateway across namespaces13.6.2 Routing to a service in a different namespace13.7 From ingress gateways to service mesh
Part 5 Managing applications at scale
14 Scaling and maintaining pods with ReplicaSets
14.1 Introducing ReplicaSets14.1.1 Creating a ReplicaSet14.1.2 Inspecting a ReplicaSet and its pods14.1.3 Understanding pod ownership14.2 Updating a ReplicaSet14.2.1 Scaling a ReplicaSet14.2.2 Updating the Pod template14.3 Understanding the operation of the ReplicaSet controller14.3.1 Introducing the reconciliation control loop14.3.2 Understanding how the ReplicaSet controller reacts to pod changes14.3.3 Removing a pod from the ReplicaSet’s control14.4 Deleting a ReplicaSet14.4.1 Deleting a ReplicaSet and all associated pods14.4.2 Deleting a ReplicaSet while preserving the pods
15 Automating application updates with Deployments
15.1 Introducing Deployments15.1.1 Creating a Deployment15.1.2 Scaling a Deployment15.1.3 Deleting a Deployment15.2 Updating a Deployment15.2.1 The Recreate strategy15.2.2 The RollingUpdate strategy15.2.3 Configuring how many pods are replaced at a time15.2.4 Pausing the rollout process15.2.5 Updating to a faulty version15.2.6 Rolling back a Deployment15.3 Implementing other deployment strategies15.3.1 The Canary deployment strategy15.3.2 The A/B strategy15.3.3 The Blue/Green strategy15.3.4 Traffic shadowing
16 Handling stateful applications with StatefulSets
16.1 Introducing StatefulSets16.1.1 Understanding stateful workload requirements16.1.2 Comparing StatefulSets with Deployments16.1.3 Creating a StatefulSet16.1.4 Inspecting the StatefulSet, Pods, and PersistentVolumeClaims16.1.5 Understanding the role of the headless Service16.2 Understanding StatefulSet behavior16.2.1 Understanding how a StatefulSet replaces missing pods16.2.2 Understanding how a StatefulSet handles node failures16.2.3 Scaling a StatefulSet16.2.4 Changing the PersistentVolumeClaim retention policy16.2.5 Using the OrderedReady Pod management policy16.3 Updating a StatefulSet16.3.1 Using the RollingUpdate strategy16.3.2 RollingUpdate with partition16.3.3 OnDelete strategy16.4 Managing stateful applications with Kubernetes Operators16.4.1 Deploying the MongoDB community operator16.4.2 Deploying MongoDB via the operator16.4.3 Cleaning up
17 Deploying per-node workloads with DaemonSets
17.1 Introducing DaemonSets17.1.1 Understanding the DaemonSet object17.1.2 Deploying pods with a DaemonSet17.1.3 Deploying to a subset of Nodes with a node selector17.1.4 Updating a DaemonSet17.1.5 Deleting the DaemonSet17.2 Special features in pods running node agents and daemons17.2.1 Giving containers access to the OS kernel17.2.2 Accessing the node’s filesystem17.2.3 Using the node’s network and other namespaces17.2.4 Marking daemon Pods as critical17.3 Communicating with the local daemon Pod17.3.1 Binding directly to a host port17.3.2 Using the node’s network stack17.3.3 Using a local Service
18 Batch processing with Jobs and CronJobs
18.1 Running tasks with the Job resource18.1.1 Introducing the Job resource18.1.2 Running a task multiple times18.1.3 Understanding how Job failures are handled18.1.4 Parameterizing pods in a Job18.1.5 Running Jobs with a work queue18.1.6 Communication between Job’s Pods18.1.7 Sidecar containers in Job pods18.2 Scheduling Jobs with CronJobs18.2.1 Creating a CronJob18.2.2 Configuring the schedule18.2.3 Suspending and resuming a CronJob18.2.4 Automatically removing finished Jobs18.2.5 Setting a start deadline18.2.6 Handling Job concurrency18.2.7 Deleting a CronJob and its Jobs

Overview

Tens of thousands of developers have learned how to develop and run a Kubernetes environment from Kubernetes in Action. This new second edition updates the definitive guide with new, in-depth coverage of the Kubernetes architecture, including the Kubernetes API, and then ins-and-outs of application deployment.

In it, you’ll find:

Up and running with Kubernetes
Deploying containers across a cluster
Securing clusters
Updating applications with zero downtime

As more and more applications are created using cloud-native and container-based architectures, Kubernetes has become an essential tool for modern developers to master. Kubernetes in Action, Second Edition lays out a complete introduction to container technologies and containerized applications along with practical tips for efficient deployment and operation. From building your first cluster, you’ll steadily expand your initial application, adding features and deepening your knowledge of Kubernetes architecture.

About the Technology
Kubernetes is the de facto standard for deploying containerized distributed applications. This powerful platform acts as an operating system for containers and clusters, reducing the need to micro-manage network and server infrastructure. Used daily by millions of developers, administrators, and architects, Kubernetes is must-know enterprise software.

About the Book
Kubernetes in Action, Second Edition is the definitive guide to developing and deploying software with Kubernetes. Built on the bestselling first edition, this end-to-end revision provides up-to-date coverage on structuring Kubernetes-based applications and taking advantage of the Kubernetes API. You’ll also discover other key topics like configuration, attaching storage, scaling, and zero-downtime maintenance.

What's Inside

Up and running with Kubernetes
Deploying containers across a cluster
Updating applications safely

About the Reader
Written for intermediate software developers. No prior experience with Kubernetes or containers is required.

About the Authors
Marko Lukša is an independent software engineer specializing in cloud-native technologies. Kevin Conner is a Senior Principal Software Engineer at Red Hat, focussed on cloud technologies and software supply chain security.

Quotes
Valuable from the first page to the last.
- Mark Little, IBM

Hands-on, production-minded, and refreshingly clear.
- Diane Mueller, Bitergia

Explains Kubernetes from the ground up and does that thoroughly.
- Ruben Vandeginste, PeopleWare

Concise, practical, and straight to the point.
- Jorge Contreras, McQuilling Partners

A well-structured book that makes Kubernetes easier to understand.
- Anand Edward, Cognizant Technology Solutions

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781617297618Publisher Support Other Publisher Website Purchase Link

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills