Kubernetes
Kubernetes is an open-source platform for orchestrating and automating the deployment, scaling, and management of containerized workloads across computing clusters.
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 and manages containerized microservices in a production cluster.
- How deep it goes
- Works through local and Azure deployments, cluster configuration, and registry access, while stopping short of Kubernetes’ full feature set.
- Examples
- Uses a video-streaming microservice, Docker Desktop’s local cluster, an Azure managed cluster, and a Terraform cluster definition.
- What you can do after
- Operate/configure it to deploy a microservice locally and on Azure, then automate infrastructure and application deployment.
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 →
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 containerized Spring Boot applications to a cluster instead of a traditional Java application server.
- How deep it goes
- Walks through a deployment manifest, kubectl checks, and health probes, but defers detailed Kubernetes deployment specifications.
- Examples
- Uses a three-replica Spring Boot deployment, kubectl output, port forwarding, and HTTP health-probe configuration.
- What you can do after
- Operate/configure it by deploying a Spring Boot image, checking its pods, and wiring 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 →
Related concepts
- agent orchestrationkind of · Orchestration is the coordination and sequencing of agents, services, tasks, or components to carry out a larger workflow or objective.
- 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 of requests or computational work across multiple resources to manage demand, reduce workload imbalance, and improve utilization or availability.
- 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.
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.