Kubernetes Deployment
A Kubernetes Deployment is a declarative API resource that manages the desired state, scaling, and updates of a replicated application workload.
Kubernetes for Developers
A Kubernetes Deployment is an API object that manages the desired state and rollout of replicated application Pods.
- How it is used
- Manages replicated, continuously running Pods for stateless applications and background task queues.
- How deep it goes
- Works through a YAML manifest, kubectl deployment, inspection, and image update; defers detailed rollout strategies and health checks.
- Examples
- Uses a three-replica container manifest, kubectl status output, an image-version update, and a blue/green Service cutover.
- What you can do after
- Apply it via kubectl to create, inspect, and update a replicated application Deployment.
Read how Kubernetes for Developers explains Kubernetes Deployment →
Acing the Certified Kubernetes Administrator Exam, Second Edition
A Deployment is a Kubernetes API resource that declaratively manages the desired state of replicated application workloads.
- How it is used
- Uses Deployments to manage replicated stateless workloads and practice scaling, image updates, and availability checks.
- How deep it goes
- Works through kubectl operations and Deployment YAML structure, then traces ReplicaSets and rolling updates without descending into controller internals.
- Examples
- Uses an Apache replica-and-image change, CoreDNS scaling, and a MySQL pod-log repair.
- What you can do after
- Operate/configure it with kubectl to scale pods, update images, verify ReplicaSets, and investigate unhealthy pods.
Road to Kubernetes
A Kubernetes Deployment is a Kubernetes workload resource that declaratively manages replicated application Pods and their updates.
- How it is used
- Uses Deployments to manage and scale stateless application Pods across a Kubernetes cluster.
- How deep it goes
- Works through manifest fields, apply and inspection commands, replica replacement, and production use without detailing Kubernetes control-plane internals.
- Examples
- Uses a 15-replica NGINX YAML manifest, kubectl checks, and a Pod-deletion test.
- What you can do after
- Build it from scratch with an apps/v1 YAML manifest, then operate and inspect its Pods using kubectl.
Read how Road to Kubernetes explains Kubernetes Deployment →
Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform
A Kubernetes Deployment is a controller that manages replicated application pods and replaces failed instances to maintain the declared state.
- How it is used
- Uses Deployments to keep containerized microservices running in local and production-like Kubernetes clusters.
- How deep it goes
- Explains pod templates, selectors, replica counts, image configuration, deployment checks, and cleanup; defers further scaling and redundancy.
- Examples
- Uses a video-streaming microservice with one replica, a matching Service, and local and Azure Kubernetes configurations.
- What you can do after
- Operate/configure a Deployment with kubectl by applying YAML, checking its objects, and deleting them after testing.
Platform Engineering on Kubernetes
A Kubernetes Deployment is a resource that declares and maintains a desired number of replicated application instances and their container configuration.
- How it is used
- Defines and maintains the containers and replica count for services in the Conference application.
- How deep it goes
- Explains inspection, scaling, update strategies, and managed ReplicaSets, while deferring detailed resource definitions.
- Examples
- Uses frontend `kubectl` listings, descriptions, and scaling, plus PostgreSQL connection settings for the Call for Proposals service.
- What you can do after
- Operate/configure it with kubectl to inspect failures, change replica counts, and update container environment variables.
Read how Platform Engineering on Kubernetes explains Kubernetes Deployment →
Learn Docker in a Month of Lunches, Second Edition
A Deployment is a Kubernetes API resource that manages a set of Pods through a declarative Pod template and desired replica count.
- How it is used
- Manages application Pods by maintaining a requested replica count from a Pod template.
- How deep it goes
- Works through YAML structure, label matching, replacement, scaling, probes, and configuration updates without detailing controller internals.
- Examples
- Uses a numbers API scaling exercise, ConfigMap-backed container settings, and a logging-configuration lab.
- What you can do after
- Operate/configure it with kubectl to deploy, inspect, scale, update, and check replacement Pods.
Read how Learn Docker in a Month of Lunches, Second Edition explains Kubernetes Deployment →
Machine Learning Platform Engineering
A Deployment is a Kubernetes resource that declaratively manages application updates, scaling, and the ReplicaSets underlying its pods.
- How it is used
- Manages FastAPI application replicas and image revisions through declarative Kubernetes configuration.
- How deep it goes
- Defines manifests, selectors, replicas, updates, status checks, controller events, and rollback, without detailing controller internals.
- Examples
- Uses a three-replica hello-joker deployment, image revision v2, status output, scaling events, and rollout undo.
- What you can do after
- Operate/configure a Deployment, update its image, inspect rollout health, and undo the revision with kubectl.
Read how Machine Learning Platform Engineering explains Kubernetes Deployment →
Developer Experience on Kubernetes
A Deployment is a Kubernetes resource that manages replicated stateless application workloads and their rollout lifecycle.
- How it is used
- Manages replicated stateless application workloads as part of a Kubernetes deployment exposed through Services and optionally Ingresses.
- How deep it goes
- Defines the resource and its manifest role, then stops short of detailed controller internals or rollout mechanics.
- Examples
- Uses an appointments application with PostgreSQL configuration, ko-built images, kubectl commands, and a local Kubernetes cluster.
- What you can do after
- Operate/configure a stateless application Deployment by writing manifests, loading images, applying resources, and inspecting deployed objects.
Read how Developer Experience on Kubernetes explains Kubernetes Deployment →
Quarkus in Action
A Kubernetes deployment is a declarative resource that manages the desired replicas and rollout state of a workload.
- How it is used
- Deploys a Quarkus application declaratively to Kubernetes alongside network exposure and optional monitoring configuration.
- How deep it goes
- Explains manifest generation, image configuration, application, and pod inspection, but omits cluster setup and detailed rollout mechanics.
- Examples
- Uses the Quarkus Inventory service, generated kubernetes.yml, quay.io image, kubectl apply, and running-pod inspection.
- What you can do after
- Operate/configure a Quarkus application deployment by generating manifests, applying them with kubectl, and checking its pods.
Akka in Action, Second Edition
A Kubernetes Deployment is a workload resource that declaratively manages replicated pods and their rollout configuration.
- How it is used
- Deploys replicated application pods and configures their image, discovery, health checks, and cluster-facing ports.
- How deep it goes
- Explains manifest fields, label matching, discovery settings, probes, image packaging, and deployment commands.
- Examples
- Uses three-pod manifests, label selectors, Akka discovery environment variables, health probes, and a betting-house deployment.
- What you can do after
- Operate/configure a Kubernetes-hosted Akka application with replicated pods, discoverable nodes, Docker images, and readiness checks.
Read how Akka in Action, Second Edition explains Kubernetes Deployment →
Google Anthos in Action
A Kubernetes Deployment is a resource that declaratively manages the desired state and rollout of replicated applications.
- How it is used
- Controls application placement and version rollout across labeled clusters, while supporting local previews through service exposure.
- How deep it goes
- Demonstrates manifests, selectors, image tags, service exposure, and port forwarding, but stops short of Deployment controller internals.
- Examples
- Uses rollout-tester and non-tester image variants, a country-specific deployment, and a hello-minikube NodePort preview.
- What you can do after
- Apply it via Kubernetes manifests and kubectl to place container versions, expose them locally, and inspect deployment-related services.
Read how Google Anthos in Action explains Kubernetes Deployment →
Also covered in
- gRPC Microservices in Go
- Server-Side WebAssembly
- Azure Security
- Data Pipelines with Apache Airflow, Second Edition
- Designing AI SystemsIn early access (MEAP)
What to know first
- YAMLYAML is a human-readable data serialization standard for representing structured data, commonly using indentation to express mappings and sequences.
- containerA software container is an isolated execution environment that packages an application and its dependencies, typically sharing the host operating-system kernel.
- 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.
- availabilityAvailability is the degree or proportion of time that a system or service is operational and accessible when required.
Related concepts
- ReplicaSetproduces · A ReplicaSet is a Kubernetes workload resource that maintains a specified number of Pods matching a defined Pod template.
- Supervisorimplements · A supervisor is a component that monitors subordinate processes, actors, or resources and responds to failures with configured recovery actions.
- podproduces · A Kubernetes Pod is the smallest deployable unit in Kubernetes, grouping one or more co-located containers that share networking and other resources.
- rolling updateuses · A rolling update is a deployment or upgrade technique that updates or replaces instances or resources incrementally rather than all at once, allowing the rest of the system to continue operating during the change.
- Kubernetes resourcekind of · A Kubernetes resource is a persistent API-managed object representing the desired or observed state of a workload, configuration, or other cluster entity.
Questions about Kubernetes Deployment
What is Kubernetes Deployment?
A Kubernetes Deployment is a declarative API resource that manages the desired state, scaling, and updates of a replicated application workload.
Which Manning books explain Kubernetes Deployment?
Kubernetes for Developers, Acing the Certified Kubernetes Administrator Exam, Second Edition, Road to Kubernetes, Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform, Platform Engineering on Kubernetes, Learn Docker in a Month of Lunches, Second Edition, Machine Learning Platform Engineering, Developer Experience on Kubernetes and 3 more.
What should I know before learning Kubernetes Deployment?
Manning books that teach Kubernetes Deployment usually introduce YAML, container, microservice architecture and availability first.
What is Kubernetes Deployment a kind of?
Kubernetes Deployment is a kind of workload construct. A workload construct is a Kubernetes resource abstraction that encapsulates and manages Pods for a particular application workload.
What is Kubernetes Deployment also called?
Kubernetes Deployment is also called deployment object or deployment resource.
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.










