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.
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 →
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 and automating the deployment, scaling, and management of containerized workloads across computing clusters.
- 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, including mappings, sequences, and scalar values.
- Helm chartpart of · A Helm chart is a versioned package of templated Kubernetes resource definitions, configuration values, and metadata for deploying an application or service.
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.