Kubernetes
Kubernetes is an open-source platform for orchestrating containerized workloads and automating their deployment, scaling, and management.
Kubernetes in Action, Second Edition
A Kubernetes cluster is a group of computers running Kubernetes components that collectively manage and run containerized applications.
- How it is used
- Automates deployment and everyday management of containerized applications across a cluster.
- How deep it goes
- Traces manifests through the API, controllers, scheduler, and worker nodes; defers in-depth component internals.
- Examples
- Uses a two-deployment, two-service manifest and a Docker Desktop single-node development cluster.
- What you can do after
- Apply it via Docker Desktop or a managed cluster to deploy applications without choosing individual worker nodes.
Read how Kubernetes in Action, Second Edition explains Kubernetes →
Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform
An open-source platform for orchestrating containerized workloads and services across a cluster of computers.
- How it is used
- Hosts microservices in production and provides a local cluster for deployment practice.
- How deep it goes
- Walks through deployment and managed cluster creation, but leaves much of Kubernetes unexplored.
- Examples
- Deploys a video-streaming microservice locally and on Azure, then ships a complete microservices application.
- What you can do after
- Operate and configure Kubernetes clusters using kubectl, Docker Desktop, Azure, and Terraform to deploy microservices.
Kubernetes for Developers
Kubernetes is an open-source container orchestration platform that automates deployment, scaling, and management of containerized workloads.
- How it is used
- Runs and manages containerized applications on shared compute, including stateless services, stateful workloads, and batch jobs.
- How deep it goes
- Works through cluster building blocks, a release-and-update sequence, and operational behavior, without presenting an exhaustive API reference.
- Examples
- Uses an internet-facing application release, a three-zone service deployment, and local-versus-cloud development clusters.
- What you can do after
- Apply it via kubectl to deploy and update a containerized application using a Deployment and Service.
Learn Docker in a Month of Lunches, Second Edition
Kubernetes is an open-source platform for orchestrating and managing containerized workloads across computing resources.
- How it is used
- Runs containerized applications across machines when single-machine Docker or Compose cannot provide the needed scale or availability.
- How deep it goes
- Works through cluster checks and basic YAML resources, while deferring broader API mastery and templating.
- Examples
- Uses Pod YAML, kubectl checks, a label-selected REST API Service, and ConfigMap-backed application settings.
- What you can do after
- Operate/configure it locally with kubectl to deploy and inspect basic Pods, Services, and ConfigMaps.
Read how Learn Docker in a Month of Lunches, Second Edition explains Kubernetes →
Acing the Certified Kubernetes Administrator Exam, Second Edition
Kubernetes is an open-source platform for orchestrating containerized workloads and services across a cluster of machines.
- How it is used
- Runs containerized workloads across a cluster and anchors hands-on Kubernetes administrator tasks.
- How deep it goes
- Explains the REST API, node roles, workload hierarchy, certificates, and desired state; defers detailed cluster anatomy and RBAC.
- Examples
- Uses a kind practice cluster, an architecture diagram, and pod DNS resolver checks to make cluster behavior observable.
- What you can do after
- Practice/perform cluster administration by accessing components, completing terminal tasks, and checking workload behavior.
Read how Acing the Certified Kubernetes Administrator Exam, Second Edition explains Kubernetes →
Platform Engineering on Kubernetes
A Kubernetes cluster is a group of machines or containerized nodes running Kubernetes to provide coordinated container orchestration.
- How it is used
- Provides the runtime and building blocks for deploying distributed applications and constructing more specialized developer platforms.
- How deep it goes
- Explains cluster choices and pod inspection through a runnable application, while treating Kubernetes building blocks as a starting point rather than detailing their internals.
- Examples
- Uses a KinD-hosted Conference application with Redis, PostgreSQL, and Kafka, plus pod readiness, restart, and node output.
- What you can do after
- Operate/configure it with KinD, Helm, and kubectl to deploy a distributed application and inspect pod health.
Read how Platform Engineering on Kubernetes explains Kubernetes →
Developer Experience on Kubernetes
Kubernetes is an open-source platform for automating the deployment, scaling, and management of containerized applications.
- How it is used
- Aligns inner-loop development with distributed production environments through shared container and Kubernetes behaviors.
- How deep it goes
- Explains adoption rationale and local-cluster provisioning, while deferring deeper platform and remote-environment options.
- Examples
- Uses a local kind cluster shared across application environments and verified with kubectl context and node commands.
- What you can do after
- Operate/configure it as a local kind cluster, choosing shared-host or application-specific provisioning for the use case.
Read how Developer Experience on Kubernetes explains Kubernetes →
Road to Kubernetes
Kubernetes is an open-source platform for orchestrating containerized workloads and services across compute resources.
- How it is used
- Manages container deployment across a cluster when updates, scaling, recovery, and communication become difficult to handle with containers alone.
- How deep it goes
- Builds toward provisioning, kubectl, Deployments, and Services through a deployment sequence, while leaving advanced Kubernetes capabilities beyond the initial foundation.
- Examples
- Uses Python and JavaScript web applications, a Python 3.10 deployment request, and a progression from manual to container to Kubernetes deployment.
- What you can do after
- Operate/configure it with a managed cluster, kubectl, Deployments, and Services to run and expose containerized web applications.
Machine Learning Platform Engineering
Kubernetes is an open-source platform for automating the deployment, scaling, scheduling, and management of containerized applications.
- How it is used
- Provides the infrastructure foundation for deploying, scaling, scheduling, and managing containerized ML applications.
- How deep it goes
- Explains container orchestration, cluster roles, scheduling, state storage, and failure recovery, while deferring Kubernetes’s broader advanced topic.
- Examples
- Uses automated ML service deployment and Kubeflow notebook configuration with namespaces, resource limits, and accelerators.
- What you can do after
- Operate/configure containerized applications and ML workloads across Kubernetes nodes with automated deployment and resource management.
Read how Machine Learning Platform Engineering explains Kubernetes →
Distributed Machine Learning Patterns
Kubernetes is an open-source platform for automating the deployment, scaling, and management of containerized applications.
- How it is used
- Provides the distributed infrastructure for running machine-learning workloads, including Kubeflow training jobs and Argo workflows.
- How deep it goes
- Defines orchestration and practices local cluster, namespace, and Pod operations, while deferring Kubernetes component internals.
- Examples
- Uses a k3d-created distml cluster, a basics namespace, and a whalesay Pod that prints “hello world.”
- What you can do after
- Operate/configure a local Kubernetes cluster, isolate resources with namespaces, and create, inspect, and log a Pod with kubectl.
Read how Distributed Machine Learning Patterns explains Kubernetes →
Spring in Action, Sixth Edition
Kubernetes is a container orchestration platform that manages deployment, scaling, networking, and lifecycle operations for containerized applications.
- How it is used
- Deploys a containerized Spring Boot application to a cluster and monitors its availability.
- How deep it goes
- Walks through a deployment manifest, kubectl commands, and probe configuration while deferring detailed Kubernetes deployment specifications.
- Examples
- Uses a three-replica Taco Cloud deployment, pod port forwarding, and HTTP health probes.
- What you can do after
- Apply it via kubectl to deploy and inspect a containerized application and configure its liveness and readiness probes.
Read how Spring in Action, Sixth Edition explains Kubernetes →
Podman in Action: Secure, rootless containers for Kubernetes, microservices, and more
Kubernetes is an open-source platform for orchestrating containerized workloads across clusters of machines.
- How it is used
- Orchestrates containerized microservices across multiple machines when single-node Podman workflows are insufficient.
- How deep it goes
- Defines orchestrators, engines, and runtimes, then demonstrates YAML-based workloads and nested Podman security requirements without detailing Kubernetes internals.
- Examples
- Uses Kubernetes YAML for privileged and rootless Podman pods, including securityContext, capabilities, and runAsUser.
- What you can do after
- Operate/configure container workloads across nodes and run Podman within Kubernetes when required security settings are available.
Effective Platform Engineering
A Kubernetes cluster is a group of computing nodes managed by Kubernetes to run and coordinate application workloads.
- How it is used
- Standardizes distributed-service orchestration and provides an extensible control plane for engineering platforms.
- How deep it goes
- Explains orchestration, desired state, self-healing, scaling, and API extensibility, while stopping short of detailed component implementation.
- Examples
- Uses service recovery, workload relocation, traffic-based scaling, local clusters, and CircleCI private runners as concrete examples.
- What you can do after
- Operate platform workloads and private CI execution through a standardized, self-healing orchestration API.
Read how Effective Platform Engineering explains Kubernetes →
Logs and Telemetry
A Kubernetes cluster is a group of computing nodes managed together by Kubernetes to run containerized workloads.
- How it is used
- Frames Kubernetes as the operating environment whose application, container, and cluster events Fluent Bit must observe.
- How deep it goes
- Explains logging responsibilities, deployment patterns, ecosystem components, and managed-service limits without teaching Kubernetes administration.
- Examples
- Uses Pod evictions, node lifecycle events, managed Kubernetes visibility, and Fluent Bit deployment through Helm charts or Fluent Operator.
- What you can do after
- Operate/configure it by selecting event collection, enrichment, and Fluent Bit deployment approaches for a Kubernetes environment.
Cloud Observability in Action
Kubernetes is an open-source system for orchestrating containerized workloads and managing their deployment, scaling, and operation.
- How it is used
- Supports deployment and operation of containerized microservices while exposing cluster and application signals for observability.
- How deep it goes
- Explains control-plane and data-plane responsibilities, signal sources, and a local deployment workflow, but defers comprehensive telemetry processing.
- Examples
- Uses the Sock Shop microservices application, kubectl deployment commands, service port-forwarding, logs, and metrics.
- What you can do after
- Operate a local Kubernetes deployment and inspect its application logs and metrics using kubectl.
Read how Cloud Observability in Action explains Kubernetes →
Software Security for Developers
A Kubernetes cluster is a set of coordinated machines that provides the control plane and execution resources for Kubernetes workloads.
- How it is used
- Positions Kubernetes as a self-service production platform for deploying and running applications securely.
- How deep it goes
- Defines security responsibilities and required artifacts but defers cluster installation, management, and operation.
- Examples
- Uses secure container images, YAML deployment manifests, API gateways, and service meshes as practical security artifacts and technologies.
- What you can do after
- Configure Kubernetes workloads with secure container images and deployment manifests that follow security best practices.
Read how Software Security for Developers explains Kubernetes →
Designing Deep Learning Systems: A guide for software engineers
Kubernetes is an open-source platform for automating deployment, scaling, and management of containerized applications.
- How it is used
- Manages distributed containerized services and shared training clusters when manual scheduling and resource tracking become impractical.
- How deep it goes
- Explains scheduling, quotas, namespaces, and API placement, but stops short of comprehensive Kubernetes instruction.
- Examples
- Uses multi-server container deployment, GPU allocation, namespace quotas, and API-driven training job submission as concrete scenarios.
- What you can do after
- Operate training-cluster isolation by assigning users to namespaces, configuring quotas, and submitting workloads through the Kubernetes API.
Read how Designing Deep Learning Systems: A guide for software engineers explains Kubernetes →
AI-Powered Developer: Build software with ChatGPT and Copilot
Kubernetes is an open-source platform for deploying, scaling, and managing containerized applications through declarative resources.
- How it is used
- Deploys containerized applications to AWS and manages their scaling, lifecycle, desired state, and external access.
- How deep it goes
- Explains deployment YAML, ECR access, IAM permissions, pods, and services, while deferring some permission application details.
- Examples
- Uses an ITAM deployment manifest, an ECR image reference, an IAM pull policy, and a LoadBalancer service.
- What you can do after
- Operate/configure an AWS Kubernetes deployment by defining manifests, connecting ECR images, granting pull access, and exposing services.
Read how AI-Powered Developer: Build software with ChatGPT and Copilot explains Kubernetes →
Data Pipelines with Apache Airflow, Second Edition
A Kubernetes cluster is a set of machines managed by Kubernetes that provides pooled resources for running containerized workloads.
- How it is used
- Runs Airflow’s containerized tasks across multiple machines instead of restricting execution to a single Docker host.
- How deep it goes
- Explains orchestration architecture and setup workflows, but stops short of a comprehensive Kubernetes treatment.
- Examples
- Uses kubectl commands, YAML resources, an airflow namespace, persistent storage, and a deployed MovieLens API.
- What you can do after
- Operate Kubernetes-backed Airflow workloads and deploy supporting services, storage, and namespaces with kubectl and YAML.
Read how Data Pipelines with Apache Airflow, Second Edition explains Kubernetes →
Server-Side WebAssembly
Kubernetes is an open-source system for deploying, scheduling, scaling, and managing containerized workloads across clusters.
- How it is used
- Deploys, schedules, scales, and manages containerized and WebAssembly workloads across production clusters.
- How deep it goes
- Explains control-plane architecture, CRDs, operators, deployment workflows, and scaling, but defers detailed operator implementation.
- Examples
- Uses SmartCMS, Ollama, wadm.yaml, kubectl commands, wash status output, port forwarding, and Kubernetes architecture figures.
- What you can do after
- Operate/configure a Wasm application on Kubernetes using manifests, wasmCloud tooling, port forwarding, status checks, and logs.
gRPC Microservices in Go
Kubernetes is an open-source platform for orchestrating containerized applications across clusters of machines.
- How it is used
- Hosts independently deployed Go gRPC microservices in a production-style e-commerce system and its CI/CD flow.
- How deep it goes
- Explains infrastructure abstraction, service discovery, per-service configuration, and deployment paths; stops short of showing Kubernetes specification details in the supplied excerpts.
- Examples
- Uses an e-commerce architecture diagram, a higher-capacity Product service, and deployable Go gRPC service images.
- What you can do after
- Operate/configure it to deploy containerized gRPC services, set service-specific capacity, and address services by name.
Google Anthos in Action
Kubernetes is an open-source platform for orchestrating and automating containerized workloads and infrastructure.
- How it is used
- Deploys and orchestrates containerized application workloads within clusters and broader multi-cloud platforms.
- How deep it goes
- Explains components, resources, and scheduling constraints, but stops short of detailed implementation procedures or individual component internals.
- Examples
- Uses Anthos architecture and workload-placement scenarios involving labels, selectors, tolerations, and affinity rules.
- What you can do after
- Diagnose cluster and workload deployment problems and make better architectural decisions about resources and workload placement.
Shipping Go: Develop, deliver, discuss, design, and go again
Kubernetes is an open-source system for automating the deployment, scaling, and management of containerized applications across clusters.
- How it is used
- Deploys and operates containerized applications across shared clusters when on-demand or dedicated-server approaches become limiting.
- How deep it goes
- Explains cluster abstractions, deployments, pods, services, scaling, routing, restarts, secrets, and configuration, but not cluster internals.
- Examples
- Uses a translation API, a database deployed with Helm, shared application clusters, and a figure positioning containers as shippable products.
- What you can do after
- Operate/configure applications through clusters, deployments, services, secrets, and configuration files.
Read how Shipping Go: Develop, deliver, discuss, design, and go again explains Kubernetes →
Also covered in
- Architecture Modernization: Socio-technical alignment of software, strategy, and structure
- 100 Go Mistakes and How to Avoid Them
- Build Python Web Apps with Streamlit
- Quarkus in Action
- Amazon Web Services in Action, Third Edition: An in-depth guide to AWS
- Cyber Threat Hunting
- Build and Orchestrator in Go (From Scratch)
- Automating API Delivery
- Akka in Action, Second Edition
- Lead Developer Career Guide
- Build AI-Enhanced Web Apps
- LLMs in Production
What to know first
- containerA software container is an isolated execution environment that packages an application and its dependencies, typically sharing the host operating-system kernel.
- deployment pipelineA deployment pipeline is a repeatable sequence of stages that builds, tests or validates, packages, and delivers software changes toward release or deployment.
- microservice architectureMicroservice architecture is a software architectural style that structures an application as independently deployable services, typically organized around focused capabilities and communicating through defined interfaces.
- distributed systemA distributed system is a computing system whose components run across multiple networked processes or machines and coordinate through communication.
Related concepts
- agent orchestrationkind of · Agent orchestration is the coordination of agents, their tasks, tools, and interactions to accomplish a larger objective or workflow.
- kubectlused by · kubectl is the Kubernetes command-line client for communicating with the Kubernetes API and managing cluster resources.
- load balancinguses · Load balancing is the distribution or adjustment of work across multiple resources to manage demand and reduce overload or imbalance.
- poduses · A Kubernetes Pod is the smallest deployable unit in Kubernetes, grouping one or more co-located containers that share networking and other resources.
- Knativeused by · Knative is an open-source, Kubernetes-based platform for deploying and operating serverless and event-driven workloads.
Questions about Kubernetes
What is Kubernetes?
Kubernetes is an open-source platform for orchestrating containerized workloads and automating their deployment, scaling, and management.
Which Manning books explain Kubernetes?
Kubernetes in Action, Second Edition, Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform, Kubernetes for Developers, Learn Docker in a Month of Lunches, Second Edition, Acing the Certified Kubernetes Administrator Exam, Second Edition, Platform Engineering on Kubernetes, Developer Experience on Kubernetes, Road to Kubernetes and 15 more.
What should I know before learning Kubernetes?
Manning books that teach Kubernetes usually introduce container, deployment pipeline, microservice architecture and distributed system first.
What is Kubernetes a kind of?
Kubernetes is a kind of agent orchestration. Agent orchestration is the coordination of agents, their tasks, tools, and interactions to accomplish a larger objective or workflow.
What is Kubernetes also called?
Kubernetes is also called K8s.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.






















