15 Kubernetes: A primer

This chapter introduces Kubernetes as the industry-standard container orchestrator that closes the production gaps left by running Docker alone. It explains how Kubernetes abstracts machines into a cluster and uses a declarative, portable API—expressed in YAML and managed with kubectl—to model compute, networking, storage, and configuration. While the platform’s richness comes with notable complexity and a steep learning curve, the payoff is strong portability across environments and providers, plus consistent tooling and skills that transfer between applications and clouds.

The chapter walks through the core building blocks. Pods wrap one or more containers and ensure they are kept running, while Services provide stable networking and traffic routing using label selectors, supporting local port-forwarding for development and LoadBalancer exposure in the cloud. Deployments manage Pods for resilience, scaling, and rolling updates, continuously reconciling actual state to desired state. Health probes (readiness and liveness) enhance availability by removing unhealthy Pods from traffic and restarting them as needed, and Services distribute requests across healthy endpoints for steady operation during failures and upgrades.

For application configuration, Kubernetes uses ConfigMaps and Secrets to inject settings as environment variables or mounted files, enabling flexible, environment-specific setups without changing container images. Updates to configuration or container setup are applied safely through rolling changes to Pods. The chapter culminates with a multi-component example (web app plus database) modeled with Deployments, Services, ConfigMaps, and Secrets, demonstrating how to iteratively assemble and operate real applications. It closes by highlighting a practical learning path: deepen Docker fundamentals, broaden Kubernetes API fluency, and explore ecosystem tools and cloud integrations to make the most of Kubernetes in production.

A multi-platform Kubernetes cluster which can run containers of any kind

Deploying an application by sending the YAML model to the cluster

Modeling compute, networking, storage and configuration in the Kubernetes API

Enabling Kubernetes in Docker Desktop

Listing the nodes in the cluster is a good way to ensure everything is running correctly.

Kubernetes will keep restarting a Pod if the container exits.

Running an HTTP server in a Pod and routing traffic via the Kubernetes CLI

Deploying a Service to route incoming cluster traffic to a Pod

Deployments manage Pods; if a Pod goes missing, the Deployment creates another.

You can scale a Deployment to add Pods; new Pods share the Service's traffic distribution.

Container probes in the model add high availability to the running app.

Injecting ConfigMap data into a Pod container as environment variables

Mounting a ConfigMap to a folder path presents the data content as files.

A full application model in Kubernetes with multiple components using all the core resources

Deploying and managing distributed apps in Kubernetes; the tools and processes are the same no matter how complex the app.

• We're starting with the to-do app you deployed in section 15.4—if you don't have it, deploy it again from the folder ch15/exercises/todo-list.
• Use the app and check the logs for the web component—you'll see there aren't any because the default configuration settings only print logs when there are errors.
• There's a file called logging.json in the ch15/lab folder which increases the logging level. Your goal is to inject that config file into the web container filesystem.
• The app looks for that logging config file in the same folder as the config.json file.
• When you make the change, do the existing Pods pick it up and start writing logs, or do you need to force the Deployment to create new Pods to pick up the new config file?

FAQ