Pod
A Kubernetes Pod is the smallest deployable unit in Kubernetes, grouping one or more co-located containers that share networking and other resources.
Kubernetes in Action, Second Edition
A pod object is a Kubernetes API resource representing the desired and observed state of a pod.
- How it is used
- Represents a running application instance and groups its closely related containers as one manageable unit.
- How deep it goes
- Works through pod grouping, manifests, inspection, scaling relationships, and deletion, with status fields identified but not detailed here.
- Examples
- Uses single-container YAML, an Envoy HTTPS sidecar, a frontend–database split, and a shared-volume pair.
- What you can do after
- Build it from scratch with a v1 Pod manifest; inspect it and its containers with kubectl.
Read how Kubernetes in Action, Second Edition explains pod →
Road to Kubernetes
A Kubernetes Pod is the smallest deployable workload unit and groups one or more containers with shared network and storage resources.
- How it is used
- Runs container images as Kubernetes workloads, first directly for a simple deployment and then through Deployments for scaled applications.
- How deep it goes
- Works through Pod manifest fields and kubectl commands, then explains Deployment templates, replica counts, and replacement of ephemeral Pods.
- Examples
- Uses an NGINX Pod manifest, a 15-replica NGINX Deployment, and a temporary Pod for testing a PostgreSQL connection.
- What you can do after
- Operate/configure it with a YAML manifest and kubectl to create, inspect, and delete a Pod.
Acing the Certified Kubernetes Administrator Exam, Second Edition
The smallest deployable unit in Kubernetes, containing one or more containers that share networking and storage contexts.
- How it is used
- Uses pods as the unit to schedule, connect, store data for, and troubleshoot containerized applications.
- How deep it goes
- Defines the pod and works through placement, DNS, and log checks without descending into container-runtime internals.
- Examples
- Demonstrates an SSD node selector, cross-namespace curl requests, a mounted claim exercise, and multi-container log commands.
- What you can do after
- Operate/configure it with kubectl and YAML, then verify placement, test DNS, and diagnose container startup errors.
Read how Acing the Certified Kubernetes Administrator Exam, Second Edition explains pod →
Learn Docker in a Month of Lunches, Second Edition
A Pod is the smallest deployable unit in Kubernetes and encapsulates one or more containers sharing network and storage resources.
- How it is used
- Models running application components as container-wrapping Kubernetes resources, then serves as the unit managed by Deployments and selected by Services.
- How deep it goes
- Works through Pod YAML, container restarts, inspection, traffic routing, scaling, and configuration; does not detail Kubernetes scheduling internals.
- Examples
- Uses a pi-printing Pod, a random-number HTTP API, and a logging-configuration lab for a to-do application.
- What you can do after
- Operate/configure it with kubectl to deploy and inspect Pods, test an HTTP endpoint, scale a Deployment, and check injected configuration.
Read how Learn Docker in a Month of Lunches, Second Edition explains pod →
Kubernetes for Developers
A Pod is the Kubernetes scheduling unit that groups one or more containers and treats them as a single unit.
- How it is used
- Defines the unit Kubernetes schedules when deploying containerized applications.
- How deep it goes
- Explains container grouping, shared lifecycle, resource-based placement, replicas, and networking without detailing the complete Pod API.
- Examples
- Uses a two-CPU Pod request, a three-replica image update, and replacement after node failure.
- What you can do after
- Operate/configure it by defining Pod containers through a Deployment and checking replica placement or rollout with kubectl.
Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform
A Kubernetes Pod is the smallest deployable unit in Kubernetes, consisting of one or more co-located containers that share network and storage resources.
- How it is used
- Runs a containerized microservice as the computational unit managed by a Kubernetes Deployment.
- How deep it goes
- Explains pod placement, single-container setup, Deployment replacement, and YAML pod templates; defers detailed scaling and redundancy.
- Examples
- Uses a one-replica microservice manifest and kubectl output showing its running pod, Deployment, and Service.
- What you can do after
- Operate/configure a pod through a Deployment manifest, verify it with kubectl, and remove the configuration after testing.
Machine Learning Platform Engineering
A Kubernetes pod is the smallest deployable execution unit, encapsulating one or more containers that share network and storage resources.
- How it is used
- Runs containerized applications as Kubernetes instances and separates serving roles or pipeline components into pods.
- How deep it goes
- Works through a Pod manifest and kubectl lifecycle checks, then shows controller-managed pods; defers pipeline data-passing mechanics.
- Examples
- Uses a FastAPI Pod manifest, kubectl status and troubleshooting commands, and separate API Server and Runner pods for inference.
- What you can do after
- Operate/configure it with YAML and kubectl to launch and inspect pods, then configure replicas through a ReplicaSet or Yatai deployment.
Read how Machine Learning Platform Engineering explains pod →
Designing Deep Learning Systems: A guide for software engineers
A pod is an isolated Kubernetes execution environment that groups application containers and provides a resource guarantee.
- How it is used
- Runs isolated training processes and workflow tasks as Kubernetes-scheduled execution units.
- How deep it goes
- Defines pods through isolation, resource guarantees, lifecycle reconciliation, and distributed-training configuration without detailing Kubernetes internals.
- Examples
- Uses single- and multi-pod PyTorch training plus an Argo data-processing workflow with isolated task pods.
- What you can do after
- Operate/configure distributed training pods with per-process environment variables and stable Service-based master addressing.
Read how Designing Deep Learning Systems: A guide for software engineers explains pod →
Google Anthos in Action
A pod is the smallest deployable unit in Kubernetes, grouping one or more containers with shared networking and storage.
- How it is used
- Defines the deployable unit that hosts containers and receives application traffic through a service.
- How deep it goes
- Defines shared networking, mounted-volume access, and ephemeral addressing, but gives no pod creation procedure.
- Examples
- Uses localhost and 127.0.0.1 for communication between containers in one pod.
- What you can do after
- Evaluate/understand pod networking and avoid targeting an ephemeral pod IP when configuring application access.
Podman in Action: Secure, rootless containers for Kubernetes, microservices, and more
A pod is a group of one or more containers that share storage and network resources and a runtime specification.
- How it is used
- Groups cooperating containers into a larger service managed as one entity on a single host.
- How deep it goes
- Explains shared namespaces, cgroups, SELinux labels, volumes, port bindings, sidecars, and lifecycle commands, stopping short of multi-machine orchestration.
- Examples
- Demonstrates a web application, timestamp-writing sidecar, shared HTML volume, infra container, and localhost port 8080.
- What you can do after
- Apply it via Podman by creating, populating, starting, and testing a multi-container pod.
gRPC Microservices in Go
A Kubernetes Pod is the smallest deployable unit in Kubernetes and encapsulates one or more containers that share network and storage resources.
- How it is used
- Deploys containerized microservice workloads as Kubernetes units rather than running containers directly on cluster nodes.
- How deep it goes
- Works through an Order Pod manifest and its scheduling flow, then delegates replication and updates to Deployments.
- Examples
- Uses an Order service Pod with image and environment variables, plus a two-replica Payment service Deployment.
- What you can do after
- Apply it via kubectl to create a Pod, then use a Deployment for multiple instances and managed updates.
Server-Side WebAssembly
A Kubernetes pod is the smallest deployable Kubernetes unit that groups one or more containers sharing network and storage context.
- How it is used
- Positions pods as the workload units that Kubernetes schedules while Deployments, Services, and operators manage surrounding behavior.
- How deep it goes
- Defines pods and traces their scheduling across nodes, but defers detailed pod specification and lifecycle internals.
- Examples
- Uses a two-agent-node k3d cluster that later runs Spin applications as pods.
- What you can do after
- Operate/configure it by preparing a two-node Spin-enabled cluster where Kubernetes can schedule Wasm workload pods.
Data Pipelines with Apache Airflow, Second Edition
A Kubernetes pod is the smallest deployable unit in Kubernetes and contains one or more containers sharing networking and storage context.
- How it is used
- Runs Airflow task containers as schedulable Kubernetes workloads.
- How deep it goes
- Defines pod composition and scheduling, then demonstrates storage setup and kubectl-based diagnosis without detailing container internals.
- Examples
- Demonstrates Airflow task pods, a MovieLens API deployment, storage YAML, kubectl output, and a missing persistent volume claim.
- What you can do after
- Operate and diagnose pods with kubectl, including deploying resources, checking status, describing failures, and correcting storage configuration.
Read how Data Pipelines with Apache Airflow, Second Edition explains pod →
Shipping Go: Develop, deliver, discuss, design, and go again
A pod is Kubernetes's smallest deployable execution unit, grouping one or more containers with shared networking and storage context.
- How it is used
- Groups containers into scalable workloads managed by Deployments and reached through Services.
- How deep it goes
- Explains pod grouping, scaling, routing, and health checks, but deliberately defers detailed Kubernetes internals.
- Examples
- Uses hello-api YAML with a container image, port 8080, /health probes, and three replicas.
- What you can do after
- Operate/configure pod workloads with kubectl by defining deployments, adding health checks, and adjusting replica counts.
Read how Shipping Go: Develop, deliver, discuss, design, and go again explains pod →
Distributed Machine Learning Patterns
A pod is the smallest deployable unit in Kubernetes, consisting of one or more co-located containers sharing specified resources and execution context.
- How it is used
- Deploys tightly coupled containers as one co-scheduled logical host within Kubernetes.
- How deep it goes
- Defines shared context and demonstrates YAML creation, inspection, status, and logs without explaining Kubernetes internals.
- Examples
- Uses a whalesay container, hello-world manifest, kubectl creation, status output, logs, and raw YAML inspection.
- What you can do after
- Operate/configure a Pod by writing YAML, creating it with kubectl, and inspecting status, logs, JSON, or raw YAML.
Read how Distributed Machine Learning Patterns explains pod →
Related concepts
- ReplicaSetproduced by · A ReplicaSet is a Kubernetes workload resource that maintains a specified number of Pods matching a defined Pod template.
- Kubernetesused by · Kubernetes is an open-source platform for orchestrating and automating the deployment, scaling, and management of containerized workloads across computing clusters.
- containerhas part · A software container is an isolated execution environment that packages an application and its dependencies while sharing the host operating system kernel.
- serviceused by · A Kubernetes Service is an API resource that provides stable network access and service discovery for a changing set of Pods or other specified destinations.
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.