Kubernetes manifest
A Kubernetes manifest is a declarative configuration document, typically written in YAML or JSON, that specifies Kubernetes resources and their desired state.
Kubernetes in Action, Second Edition
A manifest file is a YAML or JSON file that declares one or more Kubernetes objects.
- How it is used
- Declares Kubernetes objects for deploying and configuring applications through the Kubernetes API.
- How deep it goes
- Works from a small Pod YAML example through applying, inspecting, and deleting manifests, then distinguishes written definitions from API-returned objects.
- Examples
- Uses a one-container Pod YAML file, a two-container Pod, and `kubectl apply -f` and `kubectl delete -f` commands.
- What you can do after
- Build it from scratch as Pod YAML, apply and inspect it with kubectl, and delete its declared objects by file.
Read how Kubernetes in Action, Second Edition explains Kubernetes manifest →
Quarkus in Action
An OpenShift manifest is a declarative configuration file that specifies OpenShift or Kubernetes resources and their desired state.
- How it is used
- Defines cluster resources for deploying Quarkus applications and their supporting services without hand-writing every resource definition.
- How deep it goes
- Works through generation, build-time customization, and application to a cluster; defers the exhaustive property list to Quarkus documentation.
- Examples
- Uses a generated Inventory service manifest and OpenShift manifests that deploy application services and shared infrastructure.
- What you can do after
- Apply it via `kubectl` or `oc` after building, inspecting resource settings, and checking image references.
Developer Experience on Kubernetes
A Kubernetes manifest is a declarative configuration document that specifies the desired state of one or more Kubernetes resources.
- How it is used
- Supports the Kubernetes inner-loop Run activity by defining and updating application resources before they are applied to a cluster.
- How deep it goes
- Explains YAML manifests through Deployment, Service, Ingress, ConfigMap, and Secret roles, while deferring detailed Secret use.
- Examples
- Uses an appointments service Deployment with a container image and database Secret variables, plus a PostgreSQL Cluster.
- What you can do after
- Operate/configure it by defining resource YAML and applying it to create or update an application deployment.
Read how Developer Experience on Kubernetes explains Kubernetes manifest →
Platform Engineering on Kubernetes
A Kubernetes manifest is a declarative configuration document that describes Kubernetes resources and their desired state.
- How it is used
- Defines Kubernetes deployment configuration that service pipelines prepare and environment pipelines apply to clusters.
- How deep it goes
- Explains repository placement, packaging choices, and deployment workflows, but does not work through individual manifest fields.
- Examples
- Compares direct `kubectl apply -f *` with Helm dependencies and `helmfile sync` for environment configuration.
- What you can do after
- Operate/configure it by keeping deployable YAML with a service and choosing direct application or packaging for the target environment.
Read how Platform Engineering on Kubernetes explains Kubernetes manifest →
Acing the Certified Kubernetes Administrator Exam, Second Edition
A Kubernetes manifest is a declarative configuration document, typically written in YAML, that describes a resource's desired state.
- How it is used
- Defines desired Kubernetes resource state for API submission, version-controlled configuration, and hands-on application tasks.
- How deep it goes
- Works through Pod YAML, submission commands, node-selector editing, and verification; does not detail the API’s reconciliation internals.
- Examples
- Uses an nginx Pod manifest, a node-selector scheduling task, and a two-container Pod prepared for log inspection.
- What you can do after
- Apply it via kubectl to create or update Pods, then verify scheduling and inspect status or logs.
Google Anthos in Action
A Kubernetes manifest is a structured configuration document that declares one or more Kubernetes resources and their desired settings.
- How it is used
- Manages an application's desired Kubernetes state through a repeatable, declarative deployment artifact.
- How deep it goes
- Explains multi-resource files, applied configuration tracking, workload fields, and the limits of imperative commands.
- Examples
- Uses an NGINX multi-resource YAML example and a Migrate for Anthos Deployment, Pod, and LoadBalancer Service.
- What you can do after
- Apply it via kubectl, inspect resulting Pods, and expose the workload with a Kubernetes Service.
Read how Google Anthos in Action explains Kubernetes manifest →
Road to Kubernetes
A Kubernetes manifest is a YAML configuration file that declares the desired state of Kubernetes resources.
- How it is used
- Uses YAML manifests to configure and deploy containerized applications to a Kubernetes cluster.
- How deep it goes
- Defines declarative configuration and begins a Pod manifest workflow, without detailing complete manifest syntax.
- Examples
- Uses Python deployment statements, a first Pod manifest, and a directory containing Kubernetes manifest files.
- What you can do after
- Operate/configure Kubernetes resources with YAML manifests and use kubectl for terminal-based, scriptable deployment workflows.
Spring in Action, Sixth Edition
A deployment manifest is a declarative configuration document that specifies how Kubernetes should deploy and operate an application workload.
- How it is used
- Deploys a containerized Spring application and defines how Kubernetes maintains and checks its workload instances.
- How deep it goes
- Defines replicas, selectors, images, and health probes, while deferring the broader mechanics of Kubernetes deployment specifications.
- Examples
- Uses a Taco Cloud Deployment, three replicas, kubectl commands, and Actuator health endpoints as concrete examples.
- What you can do after
- Operate/configure a Kubernetes deployment with kubectl, replicas, container images, and application health probes.
Read how Spring in Action, Sixth Edition explains Kubernetes manifest →
Podman in Action: Secure, rootless containers for Kubernetes, microservices, and more
A Kubernetes YAML file is a YAML-formatted resource description that declares how Kubernetes should create and manage application objects such as pods and containers.
- How it is used
- Deploys and manages containerized applications declaratively across Kubernetes machines.
- How deep it goes
- Defines YAML structure and migration purpose, but stops short of detailed resource fields or complete manifests.
- Examples
- Uses generated YAML from Podman pods or containers and adapted container commands, images, and options.
- What you can do after
- Operate/configure Kubernetes deployments by writing or generating declarative YAML from Podman workloads.
Machine Learning Platform Engineering
A Kubernetes manifest is a declarative document that specifies the desired state of one or more Kubernetes resources.
- How it is used
- Defines deployable Kubernetes state for ML services and supplies the source configuration used by CI/CD and Argo CD.
- How deep it goes
- Explains image references, service types, live-state diffs, and synchronization, but omits manifest syntax and resource schema details.
- Examples
- Uses the fast-api-app service, ClusterIP and LoadBalancer types, Argo CD diffs, and kubectl port-forwarding.
- What you can do after
- Operate/configure ML deployments by applying manifests and synchronizing them through Argo CD.
Read how Machine Learning Platform Engineering explains Kubernetes manifest →
Software Security for Developers
A Kubernetes manifest is a declarative configuration document that specifies Kubernetes resources and their desired state.
- How it is used
- Configures applications for deployment and operation on Kubernetes while expressing security-relevant deployment choices.
- How deep it goes
- Explains YAML manifests and responsibilities, but defers detailed secure-manifest practices to later treatment.
- Examples
- Uses YAML deployment manifests as the concrete configuration artifact for running applications on Kubernetes.
- What you can do after
- Apply it by writing deployment manifests that configure applications according to Kubernetes security best practices.
Read how Software Security for Developers explains Kubernetes manifest →
Also covered in
- Server-Side WebAssembly
- Automating API Delivery
- Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu
What to know first
- YAMLYAML is a human-readable data serialization standard for representing structured data, commonly using indentation to express mappings and sequences.
- load balancingLoad balancing is the distribution or adjustment of work across multiple resources to manage demand and reduce overload or imbalance.
- 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.
Related concepts
- Kubernetes Deploymentconfigures · A Kubernetes Deployment is a declarative API resource that manages the desired state, scaling, and updates of a replicated application workload.
- kubectl applyused by · kubectl apply is a Kubernetes command that creates or updates resources according to declarative configuration.
- Kubernetesconfigures · Kubernetes is an open-source platform for orchestrating containerized workloads and automating their deployment, scaling, and management.
- Kubernetes APIuses · The Kubernetes API is the programmatic interface through which clients and components define, query, modify, and manage Kubernetes resources and cluster state.
- YAMLuses · YAML is a human-readable data serialization standard for representing structured data, commonly using indentation to express mappings and sequences.
- annotationuses · A Kubernetes annotation is key-value metadata attached to an object for storing non-identifying descriptive, configuration, or operational information.
Questions about Kubernetes manifest
What is Kubernetes manifest?
A Kubernetes manifest is a declarative configuration document, typically written in YAML or JSON, that specifies Kubernetes resources and their desired state.
Which Manning books explain Kubernetes manifest?
Kubernetes in Action, Second Edition, Quarkus in Action, Developer Experience on Kubernetes, Platform Engineering on Kubernetes, Acing the Certified Kubernetes Administrator Exam, Second Edition, Google Anthos in Action, Road to Kubernetes, Spring in Action, Sixth Edition and 3 more.
What should I know before learning Kubernetes manifest?
Manning books that teach Kubernetes manifest usually introduce YAML, load balancing, container and deployment pipeline first.
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.










