chunk_text stringlengths 730 1.2k | source_file stringclasses 1
value | llm_structured_1 dict |
|---|---|---|
Concepts | Kubernetes
07/04/2026 07:18
## **Concepts**
- 1: Overview
- 1.1: Kubernetes Components
- 1.2: Objects In Kubernetes
- 1.2.1: Kubernetes Object Management
- 1.2.2: Object Names and IDs
- 1.2.3: Labels and Selectors
- 1.2.4: Namespaces
- 1.2.5: Annotation... | Concepts | Kubernetes.pdf | {
"answer": "1.2.3: Labels and Selectors",
"evidence_quote": "1.2.3: Labels and Selectors",
"question": "Which Kubernetes concept covers 'Labels and Selectors'?"
} |
ifecycle Hooks
- 3.5: Container Runtime Interface (CRI)
- 4: Workloads
4.1: Pods
4.1.1: Pod Lifecycle
- 4.1.2: Init Containers
4.1.3: Sidecar Containers
4.1.4: Ephemeral Containers
4.1.5: Disruptions
- 4.1.6: Pod Hostname
4.1.7: Pod Quality of Service Classes
https://kubernetes.io/docs/concepts... | Concepts | Kubernetes.pdf | {
"answer": "Deployments",
"evidence_quote": "4.3.1: Deployments",
"question": "What is the title of section 4.3.1 in the Kubernetes concepts documentation?"
} |
EndpointSlices
5.6: Network Policies
5.7: DNS for Services and Pods
5.8: IPv4/IPv6 dual-stack
5.9: Topology Aware Routing
5.10: Networking on Windows
5.11: Service ClusterIP allocation
5.12: Service Internal Tra!c Policy
- 6: Storage
6.1: Volumes
- 6.2: Persistent Volumes
6.3: Projected Volumes
... | Concepts | Kubernetes.pdf | {
"answer": "6.7: Dynamic Volume Provisioning",
"evidence_quote": "- 6.7: Dynamic Volume Provisioning",
"question": "What section number and title in the 'Storage' category covers dynamic volume provisioning?"
} |
urce Management for Windows nodes
- 8: Security
- 8.1: Cloud Native Security and Kubernetes
- 8.2: Pod Security Standards
- 8.3: Pod Security Admission
- 8.4: Service Accounts
- 8.5: Pod Security Policies
- 8.6: Security For Linux Nodes
- 8.7: Security For Windows Nodes
- 8.8: ... | Concepts | Kubernetes.pdf | {
"answer": "8.3: Pod Security Admission",
"evidence_quote": "- 8.3: Pod Security Admission",
"question": "What is the sub-section number and title listed under 'Pod Security Admission'?"
} |
r
- 10.2: Assigning Pods to Nodes
- 10.3: Pod Overhead
- 10.4: Pod Scheduling Readiness
- 10.5: Pod Topology Spread Constraints
10.6: Taints and Tolerations
- 10.7: Scheduling Framework
- 10.8: Dynamic Resource Allocation
- 10.9: Gang Scheduling
- 10.10: Scheduler Performance Tuning
https://kubernet... | Concepts | Kubernetes.pdf | {
"answer": "10.13: Node-pressure Eviction",
"evidence_quote": "- 10.13: Node-pressure Eviction",
"question": "Which concept in the Kubernetes documentation covers Node-pressure Eviction?"
} |
11.11: Metrics For Kubernetes System Components
11.12: Metrics for Kubernetes Object States
11.13: System Logs
11.14: Traces For Kubernetes System Components
11.15: Proxies in Kubernetes
11.16: API Priority and Fairness
11.17: Installing Addons
11.18: Coordinated Leader Election
12: Windows in Kubernete... | Concepts | Kubernetes.pdf | {
"answer": "It helps you learn about the parts of the Kubernetes system and the abstractions Kubernetes uses to represent your cluster, and helps you obtain a deeper understanding of how Kubernetes works.",
"evidence_quote": "The Concepts section helps you learn about the parts of the Kubernetes system and the abs... |
etes is a portable, extensible, open source platform for managing containerized workloads
https://kubernetes.io/docs/concepts/_print/
Page 4 sur 1 115
Concepts | Kubernetes
07/04/2026 07:18
and services that facilitate both declarative configuration and automation. It has a large, rapidly growing ecosystem. K... | Concepts | Kubernetes.pdf | {
"answer": "Helmsman or pilot",
"evidence_quote": "The name Kubernetes originates from Greek, meaning helmsman or pilot.",
"question": "What does the name Kubernetes mean?"
} |
t run the applications and ensure that there is no downtime. For example, if a container goes down, another container needs to start. Wouldn't it be easier if this behavior was handled by a system?
That's how Kubernetes comes to the rescue! Kubernetes provides you with a framework to run distributed systems resilient... | Concepts | Kubernetes.pdf | {
"answer": "It starts another container to replace the failed one, handling the failover automatically.",
"evidence_quote": "It takes care of scaling and failover for your application, provides deployment patterns, and more.",
"question": "What does Kubernetes do when a container goes down?"
} |
o that the deployment is stable.
- **Storage orchestration** Kubernetes allows you to automatically mount a storage system of your choice, such as local storage, public cloud providers, and more.
- **Automated rollouts and rollbacks** You can describe the desired state for your deployed containers using Kubernetes,... | Concepts | Kubernetes.pdf | {
"answer": "Kubernetes restarts containers that fail, replaces containers, kills containers that don't respond to user-defined health checks, and does not advertise them to clients until they are ready to serve.",
"evidence_quote": "Kubernetes restarts containers that fail, replaces containers, kills containers th... |
containers that fail, replaces containers, kills containers that don't respond to your user-defined health check, and doesn't advertise them to clients until they are ready to serve.
- Kubernetes
- lets you store and manage sensitive information, such as passwords, OAuth tokens, and SSH keys. You can deploy and upd... | Concepts | Kubernetes.pdf | {
"answer": "It kills the failing containers and replaces them.",
"evidence_quote": "containers that fail, replaces containers, kills containers that don't respond to your user-defined health check, and doesn't advertise them to clients until they are ready to serve.",
"question": "What action does Kubernetes tak... |
ion of IPv4 and IPv6
- addresses to Pods and Services
- **Designed for extensibility** Add features to your Kubernetes cluster without changing upstream source code.
## What Kubernetes is not
Kubernetes is not a traditional, all-inclusive PaaS (Platform as a Service) system. Since Kubernetes operates at the con... | Concepts | Kubernetes.pdf | {
"answer": "It provides the building blocks for building developer platforms, while preserving user choice and flexibility.",
"evidence_quote": "Kubernetes provides the building blocks for building developer platforms, but preserves user choice and flexibility where it is important.",
"question": "What does Kube... |
aims to support an extremely diverse variety of workloads, including stateless, stateful, and dataprocessing workloads. If an application can run in a container, it should run great on Kubernetes.
- Does not deploy source code and does not build your application. Continuous Integration, Delivery, and Deployment (CI/C... | Concepts | Kubernetes.pdf | {
"answer": "No, Kubernetes does not provide these as built-in services.",
"evidence_quote": "Does not provide application-level services, such as middleware (for example, message buses), data-processing frameworks (for example, Spark), databases (for example, MySQL), caches, nor cluster storage systems (for exampl... |
xample, Ceph) as built-in services. Such components can run on Kubernetes, and/or can be accessed by applications running on Kubernetes through portable mechanisms, such as the Open Service Broker.
- Does not dictate logging, monitoring, or alerting solutions. It provides some integrations as proof of concept, and me... | Concepts | Kubernetes.pdf | {
"answer": "No, centralized control is not required.",
"evidence_quote": "Centralized control is also not required.",
"question": "Does Kubernetes require centralized control?"
} |
ve the current state towards the provided desired state. It shouldn't matter how you get from A to C. Centralized control is also not required. This results in a system that is easier to use and more powerful, robust, resilient, and extensible.
## Historical context for Kubernetes
Let's take a look at why Kubernete... | Concepts | Kubernetes.pdf | {
"answer": "Run each application on a different physical server.",
"evidence_quote": "for this would be to run each application on a di\"erent physical server.",
"question": "What was a solution to resource allocation issues in the traditional deployment era?"
} |
his would be to run each application on a di"erent physical server. But this did not scale as resources were underutilized, and it was expensive for organizations to maintain many physical servers.
## **Virtualized deployment era:**
As a solution, virtualization was introduced. It allows you to run multiple Virtual... | Concepts | Kubernetes.pdf | {
"answer": "Virtualization allows multiple virtual machines to run on a single physical server's CPU, providing isolation, better resource utilization, scalability, and cost savings.",
"evidence_quote": "Virtualization allows you to run multiple Virtual Machines (VMs) on a single physical server's CPU.",
"questi... |
er of disposable virtual machines.
Each VM is a full machine running all the components, including its own operating system, on top of the virtualized hardware.
## **Container deployment era:**
Containers are similar to VMs, but they have relaxed isolation properties to share the Operating System (OS) among the a... | Concepts | Kubernetes.pdf | {
"answer": "Containers provide agile application creation and deployment, continuous development, integration and deployment, and separation of concerns between Dev and Ops.",
"evidence_quote": "Containers have become popular because they provide extra benefits, such as: - Agile application creation and deployment... |
ge immutability).
- Dev and Ops separation of concerns: create application container images at build/release time rather than deployment time, thereby decoupling applications from infrastructure.
- Observability: not only surfaces OS-level information and metrics, but also application health and other signals.
- ... | Concepts | Kubernetes.pdf | {
"answer": "Kubernetes supports Ubuntu, RHEL, CoreOS, on‑premises environments, major public clouds, and essentially any other environment.",
"evidence_quote": "runs on Ubuntu, RHEL, CoreOS, on-premises, on major public clouds, and anywhere else.",
"question": "Which operating systems and environments does Kuber... |
managed dynamically – not a monolithic stack running on one big single-purpose machine.
- Resource isolation: predictable application performance. Resource utilization: high e!ciency and density.
## What's next
- Take a look at the Kubernetes Components
- Take a look at the The Kubernetes API
- Take a look at... | Concepts | Kubernetes.pdf | {
"answer": "It provides a high-level overview of the essential components that make up a Kubernetes cluster.",
"evidence_quote": "This page provides a high-level overview of the essential components that make up a Kubernetes cluster.",
"question": "What does the '1.1 - Kubernetes Components' section describe?"
} |
s that make up a Kubernetes cluster.
This page provides a high-level overview of the essential components that make up a Kubernetes cluster.
**==> picture [324 x 158] intentionally omitted <==**
**----- Start of picture text -----**<br>
API Server<br>api<br>c-c-m Cloud Controller Manager (optional)<br>Kubernetes c... | Concepts | Kubernetes.pdf | {
"answer": "The core component server that exposes the Kubernetes HTTP API.",
"evidence_quote": "The core component server that exposes the Kubernetes HTTP API.",
"question": "What is the role of the kube-apiserver in a Kubernetes cluster?"
} |
.
## **etcd**
Consistent and highly-available key value store for all API server data.
## **kube-scheduler**
Looks for Pods not yet bound to a node, and assigns each Pod to a suitable node.
## **kube-controller-manager**
Runs controllers to implement Kubernetes API behavior.
## **cloud-controller-manager ... | Concepts | Kubernetes.pdf | {
"answer": "kube-proxy maintains network rules on nodes to implement Services.",
"evidence_quote": "Maintains network rules on nodes to implement Services.",
"question": "What does kube-proxy do in a Kubernetes node?"
} |
f Kubernetes itself. More information
Your cluster may require additional software on each node; for example, you might also run systemd on a Linux node to supervise local components.
## Addons
Addons extend the functionality of Kubernetes. A few important examples include:
## **DNS**
For cluster-wide DNS res... | Concepts | Kubernetes.pdf | {
"answer": "DNS, Web UI (Dashboard), Container Resource Monitoring, Cluster-level Logging.",
"evidence_quote": "Addons extend the functionality of Kubernetes. A few important examples include: ## **DNS** For cluster-wide DNS resolution. ## **Web UI (Dashboard)** For cluster management via a web interface. ## **Con... |
er architecture, see the Cluster Architecture page.
https://kubernetes.io/docs/concepts/_print/
Page 12 sur 1 115
Concepts | Kubernetes
07/04/2026 07:18
## **1.2 - Objects In Kubernetes**
Kubernetes objects are persistent entities in the Kubernetes system. Kubernetes uses these entities to represent the sta... | Concepts | Kubernetes.pdf | {
"answer": "Kubernetes objects are persistent entities that represent the state of the cluster, describing running applications, available resources, and policies such as restart behavior and fault tolerance.",
"evidence_quote": "Kubernetes objects are persistent entities in the Kubernetes system.",
"question": ... |
ons are running (and on which nodes)
- The resources available to those applications
- The policies around how those applications behave, such as restart policies, upgrades, and fault-tolerance
A Kubernetes object is a "record of intent"--once you create the object, the Kubernetes system will constantly work to e... | Concepts | Kubernetes.pdf | {
"answer": "When you create a Kubernetes object, the Kubernetes system continuously works to ensure that the object exists, maintaining the desired state of your cluster.",
"evidence_quote": "A Kubernetes object is a \"record of intent\"—once you create the object, the Kubernetes system will constantly work to ens... |
r example, the CLI makes the necessary Kubernetes API calls for you. You can also use the Kubernetes API directly in your own programs using one of the Client Libraries.
## Object spec and status
Almost every Kubernetes object includes two nested object fields that govern the object's configuration: the object _`sp... | Concepts | Kubernetes.pdf | {
"answer": "The `spec` field defines the desired state of the object, while the `status` field reflects the current state as maintained by the Kubernetes system.",
"evidence_quote": "The `status` describes the _current state_ of the object, supplied and updated by the Kubernetes system and its components.",
"que... |
d state you supplied.
For example: in Kubernetes, a Deployment is an object that can represent an application running on your cluster. When you create the Deployment, you might set the Deployment
`spec` to specify that you want three replicas of the application to be running. The Kubernetes system reads the Deploym... | Concepts | Kubernetes.pdf | {
"answer": "It starts a replacement instance.",
"evidence_quote": "If any of those instances should fail (a status change), the Kubernetes system responds to the di\"erence between spec and status by making a correction--in this case, starting a replacement instance.",
"question": "What action does the Kubernete... |
a correction--in this case, starting a replacement instance.
For more information on the object spec, status, and metadata, see the Kubernetes API Conventions.
## Describing a Kubernetes object
When you create an object in Kubernetes, you must provide the object spec that describes its desired state, as well as s... | Concepts | Kubernetes.pdf | {
"answer": "YAML",
"evidence_quote": "By convention, manifests are YAML (you could also use JSON format).",
"question": "What is the typical format of a Kubernetes manifest?"
} |
at when making the API request over HTTP.
and object spec for a Kubernetes Deployment:
https://kubernetes.io/docs/concepts/_print/
Page 14 sur 1 115
Concepts | Kubernetes
07/04/2026 07:18
```
application/deployment.yaml
apiVersion:apps/v1
kind:Deployment
metadata:
name:nginx-deployment
spec:
selector:
match... | Concepts | Kubernetes.pdf | {
"answer": "nginx:1.14.2",
"evidence_quote": "image:nginx:1.14.2",
"question": "What image is specified for the nginx container in the deployment manifest?"
} |
t you want to create
- `metadata` - Data that helps uniquely identify the object,
- including a `name` string, `UID` , and optional `namespace`
- `spec` - What state you desire for the object
The precise format of the object `spec` is di"erent for every Kubernetes object, and contains nested fields specific to ... | Concepts | Kubernetes.pdf | {
"answer": "The metadata includes a name string, a UID, and an optional namespace.",
"evidence_quote": "- `metadata` - Data that helps uniquely identify the object, including a `name` string, `UID` , and optional `namespace`",
"question": "What fields are included in the metadata of a Kubernetes object?"
} |
ts. That template describes Pods that the StatefulSet controller will create in order to satisfy the StatefulSet specification. Di"erent kinds of objects can also have di"erent `.status` ; again, the API reference pages detail the structure of that `.status` field, and its content for each di"erent type of object.
Se... | Concepts | Kubernetes.pdf | {
"answer": "Field validation is performed, but errors are exposed as warnings rather than failing the request.",
"evidence_quote": "Field validation is performed, but errors are exposed as warnings rather than failing the request",
"question": "What happens when the Warn setting is used for --validate?"
} |
setting for `kubectl` is `--validate=true` .
## **`Strict`**
## **`Warn`**
Field validation is performed, but errors are exposed as warnings rather than failing the request
## **`Ignore`**
When `kubectl` cannot connect to an API server that supports field validation it will fall back to using client-side vali... | Concepts | Kubernetes.pdf | {
"answer": "kubectl falls back to using client-side validation.",
"evidence_quote": "When `kubectl` cannot connect to an API server that supports field validation it will fall back to using client-side validation.",
"question": "What happens when kubectl cannot connect to an API server that supports field valida... |
lready have it available.
To learn about the Kubernetes API in general, visit:
## Kubernetes API overview
To learn about objects in Kubernetes in more depth, read other pages in this section:
https://kubernetes.io/docs/concepts/_print/
Page 17 sur 1 115
Concepts | Kubernetes
07/04/2026 07:18
## **1.2.1 ... | Concepts | Kubernetes.pdf | {
"answer": "A Kubernetes object should be managed using only one technique. Mixing and matching techniques for the same object results in undefined behavior.",
"evidence_quote": "A Kubernetes object should be managed using only one technique. Mixing and matching techniques for the same object results in undefined ... |
ctl.
## Management techniques
## **Warning:**
A Kubernetes object should be managed using only one technique. Mixing and matching techniques for the same object results in undefined behavior.
||**Management**|**Operates**|**Recommended**|**Supported**|**Learning**||
|---|---|---|---|---|---|---|
||**technique**... | Concepts | Kubernetes.pdf | {
"answer": "Declarative",
"evidence_quote": "Declarative|Directories|Production|1+|Highest",
"question": "Which management technique is recommended for production environments?"
} |
ous configurations.
## Examples
Run an instance of the nginx container by creating a Deployment object:
https://kubernetes.io/docs/concepts/_print/
Page 18 sur 1 115
Concepts | Kubernetes
07/04/2026 07:18
```
kubectl create deployment nginx --image nginx
```
## Trade-o"s
- Commands are expressed as a s... | Concepts | Kubernetes.pdf | {
"answer": "kubectl create deployment nginx --image nginx",
"evidence_quote": "kubectl create deployment nginx --image nginx",
"question": "What command is used to create a Deployment object for running an nginx container?"
} |
(create, replace, etc.), optional flags and at least one file name. The file specified must contain a full definition of the object in YAML or JSON format.
See the API reference
## **Warning:**
The imperative `replace` command replaces the existing spec with the newly provided one, dropping all changes to the obj... | Concepts | Kubernetes.pdf | {
"answer": "It replaces the existing spec with the newly provided one, dropping all changes to the object missing from the configuration file.",
"evidence_quote": "The imperative `replace` command replaces the existing spec with the newly provided one, dropping all changes to the object missing from the configurat... |
s Git.
- as reviewing changes before push and audit trails.
- new objects.
Disadvantages compared to imperative commands:
- object schema.
- writing a YAML file.
- easier to understand.
- As of Kubernetes version 1.5, imperative object configuration is more mature.
- directories.
- configuration files... | Concepts | Kubernetes.pdf | {
"answer": "Imperative object configuration.",
"evidence_quote": "As of Kubernetes version 1.5, imperative object configuration is more mature.",
"question": "Which type of Kubernetes configuration is more mature as of version 1.5?"
} |
n file. This is possible by using the `patch` API operation to write only observed di"erences, instead of using the `replace` API operation to replace the entire object configuration.
## Examples
`configs` directory, and create or patch the live objects. You can first `diff` to see what changes are going to be made... | Concepts | Kubernetes.pdf | {
"answer": "kubectl diff -f configs/",
"evidence_quote": "`kubectl diff -f configs/`",
"question": "What command can you use to preview the changes that will be applied to Kubernetes objects in a directory?"
} |
Objects Using Imperative Commands
- Imperative Management of Kubernetes Objects Using
https://kubernetes.io/docs/concepts/_print/
Page 21 sur 1 115
Concepts | Kubernetes
07/04/2026 07:18
- Declarative Management of Kubernetes Objects Using Configuration Files
- Declarative Management of Kubernetes Objects... | Concepts | Kubernetes.pdf | {
"answer": "No, you cannot have two Pods with the same name in the same namespace.",
"evidence_quote": "For example, you can only have one Pod named `myapp-1234` within the same namespace, but you can have one Pod and one Deployment that are each named `myapp-1234`.",
"question": "Can you have two Pods named `my... |
non-unique user-provided attributes, Kubernetes provides labels and annotations.
## Names
A client-provided string that refers to an object in a resource URL, such as `/api/v1/pods/some-name` .
Only one object of a given kind can have a given name at a time. However, if you delete the object, you can make a new o... | Concepts | Kubernetes.pdf | {
"answer": "Yes. Names must be unique across all API versions of the same resource; the API version is irrelevant when determining uniqueness.",
"evidence_quote": "Names must be unique across all API versions of the same resource. API resources are distinguished by their API group, resource type, namespace (for na... |
resenting a physical host, when the host is recreated under the same name without deleting and recreating the Node, Kubernetes treats the new host as the old one, which may lead to inconsistencies.
The server may generate a name when `generateName` is provided instead of `name` in a resource create request. When `gen... | Concepts | Kubernetes.pdf | {
"answer": "The name must contain no more than 253 characters.",
"evidence_quote": "- contain no more than 253 characters",
"question": "What is the maximum number of characters allowed in a Kubernetes resource name that must be a DNS subdomain name?"
} |
ame as defined in RFC 1123. This means the name must:
- contain no more than 253 characters
- contain only lowercase alphanumeric characters, '-' or '.'
- start with an alphanumeric character
- end with an alphanumeric character
## RFC 1123 Label Names
Some resource types require their names to follow the D... | Concepts | Kubernetes.pdf | {
"answer": "lowercase alphanumeric characters, '-' or '.'",
"evidence_quote": "- contain only lowercase alphanumeric characters, '-' or '.'",
"question": "According to RFC 1123, what characters are allowed in a name?"
} |
s the name must:
- contain at most 63 characters
- contain only lowercase alphanumeric characters or '-' start with an alphabetic character
- end with an alphanumeric character
## **Note:**
While RFC 1123 technically allows labels to start with digits, the current Kubernetes implementation requires both RFC 1... | Concepts | Kubernetes.pdf | {
"answer": "By default, no. Kubernetes requires Service names to start with an alphabetic character. Only when the `RelaxedServiceNameValidation` feature gate is enabled for Service objects can a Service name start with a digit.",
"evidence_quote": "While RFC 1123 technically allows labels to start with digits, th... |
metadata:
name:nginx-demo
spec:
containers:
- name:nginx
image:nginx:1.14.2
ports:
- containerPort:80
```
## **Note:**
Some resource types have additional restrictions on their names.
## UIDs
A Kubernetes systems-generated string to uniquely identify objects.
Every object created over the whole lifetime of a K... | Concepts | Kubernetes.pdf | {
"answer": "nginx:1.14.2",
"evidence_quote": "image:nginx:1.14.2",
"question": "What container image is used in the nginx-demo pod?"
} |
dentifers and Names in Kubernetes design document.
https://kubernetes.io/docs/concepts/_print/
Page 25 sur 1 115
Concepts | Kubernetes
07/04/2026 07:18
## **1.2.3 - Labels and Selectors**
_Labels_ are key/value pairs that are attached to objects such as Pods. Labels are intended to be used to specify identi... | Concepts | Kubernetes.pdf | {
"answer": "Non-identifying information should be recorded using annotations.",
"evidence_quote": "Non-identifying information should be recorded using annotations.",
"question": "What type of information should be stored using annotations instead of labels?"
} |
ng annotations.
## Motivation
Labels enable users to map their own organizational structures onto system objects in a loosely coupled fashion, without requiring clients to store these mappings.
Service deployments and batch processing pipelines are often multi-dimensional entities (e.g., multiple partitions or de... | Concepts | Kubernetes.pdf | {
"answer": "\"release\" : \"stable\" and \"release\" : \"canary\"",
"evidence_quote": "\"release\" : \"stable\" , \"release\" : \"canary\"",
"question": "What are two example label key-value pairs that could indicate a release status?"
} |
erA"` , `"partition" :`
- `"customerB"`
- `"track" : "daily"` , `"track" : "weekly"`
https://kubernetes.io/docs/concepts/_print/
Page 26 sur 1 115
Concepts | Kubernetes
07/04/2026 07:18
These are examples of commonly used labels; you are free to develop your own conventions. Keep in mind that label Key mu... | Concepts | Kubernetes.pdf | {
"answer": "The prefix must be a DNS subdomain: a series of DNS labels separated by dots, not longer than 253 characters in total, and it must be followed by a slash.",
"evidence_quote": "If specified, the prefix must be a DNS subdomain: a series of DNS labels separated by dots ( `.` ), not longer than 253 charact... |
d system components (e.g.
`kube-scheduler` , `kube-controller-manager` , `kubeapiserver` , `kubectl` , or other third-party automation) which add labels to end-user objects must specify a prefix.
The `kubernetes.io/` and `k8s.io/` reserved for Kubernetes core components.
Valid label value:
- must be 63 characte... | Concepts | Kubernetes.pdf | {
"answer": "kubernetes.io/ and k8s.io/",
"evidence_quote": "The `kubernetes.io/` and `k8s.io/` reserved for Kubernetes core components.",
"question": "Which prefixes are reserved for Kubernetes core components?"
} |
eplicas should be present.
## **Caution:**
For both equality-based and set-based conditions there is no logical _OR_ ( `||` ) operator. Ensure your filter statements are structured accordingly.
## _Equality-based_ requirement
_Equality-_ or _inequality-based_ label keys and values. Matching objects must satisfy... | Concepts | Kubernetes.pdf | {
"answer": "The operators are `=`, `==`, and `!=`.",
"evidence_quote": "Three kinds of operators are admitted `=` , `==` , `!=` . The first two represent _equality_ (and are synonyms), while the latter represents _inequality_ .",
"question": "Which operators are admitted for equality-based conditions in Kubernet... |
` excluding `frontend` using the comma operator: `environment=production,tier!=frontend`
https://kubernetes.io/docs/concepts/_print/
Page 28 sur 1 115
Concepts | Kubernetes
07/04/2026 07:18
One usage scenario for equality-based label requirement is for Pods to specify node selection criteria. For example, the... | Concepts | Kubernetes.pdf | {
"answer": "accelerator:nvidia-tesla-p100",
"evidence_quote": "nodeSelector:\naccelerator:nvidia-tesla-p100",
"question": "What nodeSelector key-value pair is specified in the sample Pod to select nodes with an NVIDIA Tesla P100 accelerator?"
} |
o `production` or `qa` .
- The second example selects all resources with key equal to `tier` and values other than `frontend` and `backend` , and all resources with no labels with the `tier` key.
- The third example selects all resources including a label with key `partition` ; no values are checked.
- The fourth... | Concepts | Kubernetes.pdf | {
"answer": "It acts as an AND operator.",
"evidence_quote": "Similarly the comma separator acts as an _AND_ operator.",
"question": "What does the comma separator represent in Kubernetes label selectors?"
} |
ents. For example: `partition in (customerA, customerB),environment!=qa` .
https://kubernetes.io/docs/concepts/_print/
Page 29 sur 1 115
Concepts | Kubernetes
07/04/2026 07:18
## API
##
For **list** and **watch** operations, you can specify label selectors to filter the sets of objects returned; you speci... | Concepts | Kubernetes.pdf | {
"answer": "You can use the syntax `labelSelector=environment+in+(production,qa),tier+in+(frontend)`.",
"evidence_quote": "labelSelector=environment+in+%28production%2Cqa%29% 2Ctier+in+%28frontend%29",
"question": "What is the syntax for specifying a set-based label selector in a Kubernetes API query?"
} |
ng _equality-based_ one may write:
```
kubectl get pods -l environment=production,tier=front
```
or using _set-based_ requirements:
```
kubectl get pods -l 'environment in (production),tier
```
As already mentioned _set-based_ requirements are more expressive. For instance, they can implement the _OR_ operator on... | Concepts | Kubernetes.pdf | {
"answer": "Only equality-based requirement selectors are supported.",
"evidence_quote": "\"selector\": {\n\"component\" : \"redis\",\n}",
"question": "Which type of requirement selectors are supported in JSON or YAML files using maps?"
} |
selector.
`json` or `yaml` files using maps, and only _equality-based_ requirement selectors are supported:
```
"selector": {
"component" : "redis",
}
```
or
```
selector:
component:redis
```
This selector (respectively in `json` or `yaml` format) is equivalent to `component=redis` or `component in (redis)` .
... | Concepts | Kubernetes.pdf | {
"answer": "In, NotIn, Exists, DoesNotExist",
"evidence_quote": "Valid operators include In, NotIn, Exists, and DoesNotExist.",
"question": "What operators are available for matchExpressions in selectors?"
} |
In, Exists, and DoesNotExist. The values set must be non-empty in the case of In and NotIn. All of the requirements, from both `matchLabels` and `matchExpressions` are ANDed together -- they must all be
## Selecting sets of nodes
https://kubernetes.io/docs/concepts/_print/
Page 31 sur 1 115
Concepts | Kubernete... | Concepts | Kubernetes.pdf | {
"answer": "The values set must be non-empty.",
"evidence_quote": "The values set must be non-empty in the case of In and NotIn.",
"question": "What requirement applies to the values set for the In and NotIn operators?"
} |
for convenience in manual queries and simple CLI usage. The
`app.kubernetes.io/name` label follows the recommended Kubernetes labeling conventions and is better suited for tooling and automation.
The frontend could carry the following labels:
```
labels:
app:guestbook
app.kubernetes.io/name:guestbook
tier:fronten... | Concepts | Kubernetes.pdf | {
"answer": "The Redis master has the following labels:\n- app: guestbook\n- app.kubernetes.io/name: guestbook\n- tier: backend\n- role: master",
"evidence_quote": "labels:\napp:guestbook\napp.kubernetes.io/name:guestbook\ntier:backend\nrole:master",
"question": "What labels are applied to the Redis master compon... |
ubernetes.io/docs/concepts/_print/
Page 32 sur 1 115
Concepts | Kubernetes
07/04/2026 07:18
```
kubectl apply -f examples/guestbook/all-in-one/guestb
kubectl get pods -Lapp -Ltier -Lrole
```
```
NAME READY STATUS RESTA
guestbook-fe-4nlpb 1/1 Running 0
guestbook-fe... | Concepts | Kubernetes.pdf | {
"answer": "kubectl label pods -l app=nginx tier=fe",
"evidence_quote": "kubectl label pods -l app=nginx tier=fe",
"question": "Which kubectl command can be used to label all NGINX Pods as the frontend tier?"
} |
before creating new resources. This can be done with `kubectl label` . For example, if you want to label all your NGINX Pods as frontend tier, run:
```
kubectl label pods -l app=nginx tier=fe
```
```
pod/my-nginx-2035384211-j5fhi labeled
pod/my-nginx-2035384211-u2c7e labeled
pod/my-nginx-2035384211-u3t6x labeled
```... | Concepts | Kubernetes.pdf | {
"answer": "kubectl label pods -l app=nginx tier=fe",
"evidence_quote": "kubectl label pods -l app=nginx tier=fe",
"question": "What command can you use to label all NGINX pods with a tier of frontend?"
} |
a node
- Find Well-known labels, Annotations and Taints
- See Recommended labels
- Enforce Pod Security Standards with Namespace Labels
- Read a blog on Writing a Controller for Pod Labels
https://kubernetes.io/docs/concepts/_print/
Page 34 sur 1 115
Concepts | Kubernetes
07/04/2026 07:18
## **1.2.4 -... | Concepts | Kubernetes.pdf | {
"answer": "No, namespace-based scoping is applicable only to namespaced objects and not to cluster-wide objects.",
"evidence_quote": "Namespace-based scoping is applicable only for namespaced objects (e.g. Deployments, Services, etc.) and not for cluster-wide objects (e.g. StorageClass, Nodes, PersistentVolumes, ... |
ultiple teams, or projects. For clusters with a few to tens of users, you should not need to create or think about namespaces at all. Start using namespaces when you need the features they provide.
Namespaces provide a scope for names. Names of resources need to be unique within a namespace, but not across namespaces... | Concepts | Kubernetes.pdf | {
"answer": "It allows users to start using the cluster immediately without having to create a namespace first.",
"evidence_quote": "Kubernetes includes this namespace so that you can start using your new cluster without first creating a namespace.",
"question": "What is the purpose of the default namespace in Ku... |
rts with four initial namespaces:
## **`default`**
Kubernetes includes this namespace so that you can start using your new cluster without first creating a namespace.
## **`kube-node-lease`**
This namespace holds Lease objects associated with each node. Node leases allow the kubelet to send heartbeats so
http... | Concepts | Kubernetes.pdf | {
"answer": "kube-system",
"evidence_quote": "The namespace for objects created by the Kubernetes system.",
"question": "Which namespace is reserved for objects created by the Kubernetes system?"
} |
ide documentation for namespaces.
## **Note:**
`kube-` , since it is reserved for Kubernetes system namespaces.
## Viewing namespaces
You can list the current namespaces in a cluster using:
```
kubectl get namespace
```
```
NAME STATUS AGE
default Active 1d
kube-node-lease Active... | Concepts | Kubernetes.pdf | {
"answer": "Use the command `kubectl get namespace`.",
"evidence_quote": "kubectl get namespace",
"question": "How can you list all namespaces in a Kubernetes cluster?"
} |
all subsequent kubectl commands in that context.
```
kubectl config set-context --current --namespace=<ins
# Validate it
kubectl config view --minify | grep namespace:
```
## Namespaces and DNS
When you create a Service, it creates a corresponding DNS entry. This entry is of the form `<service-name>.<namespacename... | Concepts | Kubernetes.pdf | {
"answer": "The DNS entry for a Service is of the form `<service-name>.<namespacename>.svc.cluster.local`.",
"evidence_quote": "This entry is of the form `<service-name>.<namespacename>.svc.cluster.local` , which means that if a container only uses `<service-name>` , it will resolve to the service which is local t... |
DNS names that overlap with public DNS records. Workloads from any namespace performing a DNS lookup without a trailing dot will be redirected to those services, taking precedence over public DNS.
To mitigate this, limit privileges for creating namespaces to trusted users. If required, you could additionally configur... | Concepts | Kubernetes.pdf | {
"answer": "kubectl api-resources --namespaced=false",
"evidence_quote": "kubectl api-resources --namespaced=false",
"question": "Which kubectl command lists Kubernetes resources that are not in a namespace?"
} |
# In a namespace
kubectl api-resources --namespaced=true
# Not in a namespace
kubectl api-resources --namespaced=false
```
## Automatic labelling
## ⓘ **FEATURE STATE:** Kubernetes 1.22 [stable]
The Kubernetes control plane sets an immutable label `kubernetes.io/metadata.name` on all namespaces. The value of the l... | Concepts | Kubernetes.pdf | {
"answer": "kubernetes.io/metadata.name",
"evidence_quote": "The Kubernetes control plane sets an immutable label `kubernetes.io/metadata.name` on all namespaces. The value of the label is the namespace name.",
"question": "What immutable label does the Kubernetes control plane set on all namespaces?"
} |
ons**
You can use Kubernetes annotations to attach arbitrary nonidentifying metadata to objects. Clients such as tools and libraries can retrieve this metadata.
## Attaching metadata to objects
You can use either labels or annotations to attach metadata to Kubernetes objects. Labels can be used to select objects ... | Concepts | Kubernetes.pdf | {
"answer": "They must be strings; numeric, boolean, list or other types are not allowed.",
"evidence_quote": "The keys and the values in the map must be strings. In other words, you cannot use numeric, boolean, list or other types for either the keys or the values.",
"question": "What restrictions exist on the k... |
st be strings. In other words, you cannot use numeric, boolean, list or other types for either the keys or the values.
Here are some examples of information that could be recorded in annotations:
- Attaching these fields as annotations distinguishes them from default values set by clients or servers, and from auto-... | Concepts | Kubernetes.pdf | {
"answer": "Build, release, or image information like timestamps, release IDs, git branch, PR numbers, image hashes, and registry address.",
"evidence_quote": "- Build, release, or image information like timestamps, release IDs, git branch, PR numbers, image hashes, and registry address.",
"question": "What type... |
from other ecosystem components.
- checkpoints.
- Phone or pager numbers of persons responsible, or directory entries that specify where that information can be found, such as a team web site.
- Directives from the end-user to the implementations to modify behavior or engage non-standard features.
Instead of us... | Concepts | Kubernetes.pdf | {
"answer": "The name segment must begin and end with an alphanumeric character and may include dashes, underscores, dots, and alphanumerics in between.",
"evidence_quote": "\"The name segment is required and must be 63 characters or less, beginning and ending with an alphanumeric character ( `[a-z0-9A-Z]` ) with d... |
be a DNS subdomain: a series of DNS labels separated by dots ( `.` ), not longer than 253 characters in total, followed by a slash ( `/` ).
private to the user. Automated system components (e.g.
`kube-scheduler` , `kube-controller-manager` , `kubeapiserver` , `kubectl` , or other third-party automation) which add a... | Concepts | Kubernetes.pdf | {
"answer": "imageregistry",
"evidence_quote": "imageregistry:\"https://hub.docker.com/\"",
"question": "What annotation key is used in the example Pod manifest?"
} |
lectors. Find Well-known labels, Annotations and Taints
https://kubernetes.io/docs/concepts/_print/
Page 41 sur 1 115
Concepts | Kubernetes
07/04/2026 07:18
## **1.2.6 - Field Selectors**
_Field selectors_ let you select Kubernetes objects based on the value of one or more resource fields. Here are some exa... | Concepts | Kubernetes.pdf | {
"answer": "It selects all Pods.",
"evidence_quote": "By default, no selectors/filters are applied, meaning that all resources of the specified type are selected. This makes the kubectl queries kubectl get pods and kubectl get pods --field-selector \"\" equivalent.",
"question": "What is the effect of running 'k... |
tadata.name` and
`metadata.namespace` produces an error. For example:
```
kubectl get ingress --field-selector foo.bar=baz
```
```
Error from server (BadRequest): Unable to find "ingre
```
##
||**Kind**|**Fields**||
|---|---|---|---|
||Pod|`spec.nodeName`<br>`spec.restartPolicy`<br>`spec.schedulerName`<br>`spec... | Concepts | Kubernetes.pdf | {
"answer": "Yes, all custom resource types support these fields.",
"evidence_quote": "All custom resource types support the metadata.name and metadata.namespace fields.",
"question": "Do all custom resource types support the metadata.name and metadata.namespace fields?"
} |
||Job|`status.successful`||
||Node|`spec.unschedulable`||
||CertifcateSigningRequest|`spec.signerName`||
##
All custom resource types support the `metadata.name` and `metadata.namespace` fields.
Additionally, the `spec.versions[*].selectableFields` a CustomResourceDefinition declares which other fields in a custom... | Concepts | Kubernetes.pdf | {
"answer": "The operators `=` , `==` , and `!=` can be used in field selectors.",
"evidence_quote": "You can use the `=` , `==` , and `!=` selectors ( `=` and `==` mean the same thing).",
"question": "Which operators can be used in Kubernetes field selectors?"
} |
label chained together as a comma-separated list. This `kubectl` command selects all Pods for which the `status.phase` does not equal `Running` and the `spec.restartPolicy` field equals `Always` :
```
kubectl get pods --field-selector=status.phase!=Runni
```
## Multiple resource types
This `kubectl` command select... | Concepts | Kubernetes.pdf | {
"answer": "The command retrieves all Statefulsets and Services that are not in the `default` namespace.",
"evidence_quote": "This `kubectl` command selects all Statefulsets and Services that are not in the `default` namespace:",
"question": "Which Kubernetes resources are retrieved by the command `kubectl get s... |
ell Kubernetes to wait until specific conditions are met before it fully deletes resources that are marked for deletion. Finalizers alert controllers to clean up resources the deleted object owned.
When you tell Kubernetes to delete an object that has finalizers specified for it, the Kubernetes API marks the object f... | Concepts | Kubernetes.pdf | {
"answer": "Kubernetes removes the relevant finalizers, leaving the field empty; when `metadata.finalizers` is empty, the deletion is considered complete and the object is deleted.",
"evidence_quote": "After these actions are complete, the controller removes the relevant finalizers from the target object. When the... |
frastructure before the controller deletes the object being finalized.
garbage collection of objects by alerting controllers to perform specific cleanup tasks before deleting the target resource.
Finalizers don't usually specify the code to execute. Instead, they are typically lists of keys on a specific resource s... | Concepts | Kubernetes.pdf | {
"answer": "It sets the metadata.deletionTimestamp to the time the deletion was initiated, returns a 202 Accepted status, and prevents the resource from being removed until all finalizers have been cleared.",
"evidence_quote": "When you attempt to delete the resource, the API server handling the delete request not... |
requested. The controller then attempts to satisfy the requirements of the finalizers specified for that resource. Each time a finalizer condition is satisfied, the controller removes that key from
https://kubernetes.io/docs/concepts/_print/
Page 45 sur 1 115
Concepts | Kubernetes
07/04/2026 07:18
the resourc... | Concepts | Kubernetes.pdf | {
"answer": "The pv-protection finalizer prevents accidental deletion of PersistentVolume objects while they are in use by a Pod.",
"evidence_quote": "kubernetes.io/pvprotection , which prevents accidental deletion of PersistentVolume objects. When a PersistentVolume object is in use by a Pod, Kubernetes adds the p... |
't delete it because the finalizer exists. When the Pod stops using the
`PersistentVolume` , Kubernetes clears the `pv-protection` finalizer, and the controller deletes the volume.
## **Note:**
- When you `DELETE` an object, Kubernetes adds the deletion timestamp for that object and then immediately starts to res... | Concepts | Kubernetes.pdf | {
"answer": "When the object is deleted, Kubernetes records a deletion timestamp and immediately restricts modifications to the object's .metadata.finalizers field. You can remove existing finalizers but cannot add new ones or change the deletion timestamp, and the object cannot be resurrected once deletion is reques... |
ame` . Kubernetes enforces this format; the API server rejects writes to objects where the change does not use qualified finalizer names for any custom finalizer.
## Owner references, labels, and
Like labels, owner references describe the relationships between objects in Kubernetes, but are used for a di"erent purp... | Concepts | Kubernetes.pdf | {
"answer": "The Job controller adds owner references to those Pods, pointing at the Job that created them.",
"evidence_quote": "The Job controller also adds _owner references_ to those Pods, pointing at the Job that created the Pods.",
"question": "What does the Job controller add to the Pods it creates to enabl... |
delete the Job while these Pods are running, Kubernetes uses the owner references (not labels) to determine which Pods in the cluster need cleanup.
references on a resource targeted for deletion.
dependent objects, which can cause the targeted owner object to remain for longer than expected without being fully dele... | Concepts | Kubernetes.pdf | {
"answer": "Kubernetes uses owner references (not labels) to determine which Pods need cleanup.",
"evidence_quote": "Kubernetes uses the owner references (not labels) to determine which Pods in the cluster need cleanup.",
"question": "What mechanism does Kubernetes use to determine which Pods need cleanup when a... |
izers to Control Deletion on the Kubernetes blog.
https://kubernetes.io/docs/concepts/_print/
Page 47 sur 1 115
Concepts | Kubernetes
07/04/2026 07:18
## **1.2.8 - Owners and Dependents**
In Kubernetes, some objects are _owners_ of other objects. For example, a ReplicaSet is the owner of a set of Pods. Thes... | Concepts | Kubernetes.pdf | {
"answer": "A ReplicaSet is the owner of a set of Pods.",
"evidence_quote": "For example, a ReplicaSet is the owner of a set of Pods.",
"question": "What is an example of an owner and its dependent object in Kubernetes?"
} |
d on behalf of a Service has an owner reference. Owner references help di"erent parts of Kubernetes avoid interfering with objects they don’t control.
## Owner references in object specifications
Dependent objects have a `metadata.ownerReferences` that references their owner object. A valid owner reference consists... | Concepts | Kubernetes.pdf | {
"answer": "It consists of the object name and a UID within the same namespace as the dependent object.",
"evidence_quote": "A valid owner reference consists of the object name and a UID within the same namespace as the dependent object.",
"question": "What does a valid owner reference consist of?"
} |
elationships manually by changing the value of this field. However, you usually don't need to and can allow Kubernetes to automatically manage the relationships.
## Dependent objects also have an
`ownerReferences.blockOwnerDeletion` boolean value and controls whether specific dependents can block garbage collection... | Concepts | Kubernetes.pdf | {
"answer": "The boolean value is `ownerReferences.blockOwnerDeletion`.",
"evidence_quote": "ownerReferences.blockOwnerDeletion boolean value and controls whether specific dependents can block garbage collection from deleting their owner object.",
"question": "What boolean value controls whether specific dependen... |
Namespaced dependents can specify clusterscoped or namespaced owners. A namespaced owner
https://kubernetes.io/docs/concepts/_print/
Page 48 sur 1 115
Concepts | Kubernetes
07/04/2026 07:18
**must** exist in the same namespace as the dependent. If it does not, the owner reference is treated as absent, and the... | Concepts | Kubernetes.pdf | {
"answer": "It reports a warning Event with a reason of `OwnerRefInvalidNamespace`.",
"evidence_quote": "In v1.20+, if the garbage collector detects an invalid cross-namespace `ownerReference` , or a cluster-scoped dependent with an `ownerReference` referencing a namespaced kind, a warning Event with a reason of `... |
space` and an `involvedObject` of the invalid dependent is reported. You can check for that kind of Event by running `kubectl get events -A - -field-selector=reason=OwnerRefInvalidNamespace` .
##
When you tell Kubernetes to delete a resource, the API server allows the managing controller to process any fnalizer rul... | Concepts | Kubernetes.pdf | {
"answer": "kubernetes.io/pvprotection",
"evidence_quote": "the `PersistentVolume` has the `kubernetes.io/pvprotection` finalizer on it.",
"question": "What finalizer prevents the deletion of a PersistentVolume that is still in use by a Pod?"
} |
rsistentVolume` has the `kubernetes.io/pvprotection` finalizer on it. Instead, the volume remains in the
`Terminating` which only happens after the `PersistentVolume` is no longer bound to a Pod.
you use either foreground or orphan cascading deletion. In foreground deletion, it adds the `foreground` finalizer so th... | Concepts | Kubernetes.pdf | {
"answer": "Foreground deletion adds a `foreground` finalizer, requiring the controller to delete dependent resources that have `ownerReferences.blockOwnerDeletion=true` before deleting the owner. Orphan deletion adds an `orphan` finalizer, causing the controller to ignore dependent resources after it deletes the ow... |
ge Kubernetes objects with more tools than kubectl and the dashboard. A common set of labels allows tools to work interoperably, describing objects in a common manner that all tools can understand.
In addition to supporting tooling, the recommended labels describe applications in a way that can be queried.
The meta... | Concepts | Kubernetes.pdf | {
"answer": "app.kubernetes.io",
"evidence_quote": "`app.kubernetes.io` users. The shared prefix ensures that shared labels do not interfere with custom user labels.",
"question": "What is the shared prefix used for recommended labels to avoid interfering with custom user labels?"
} |
red prefix ensures that shared labels do not interfere with custom user labels.
## Labels
In order to take full advantage of using these labels, they should be applied on every resource object.
||**Key**|**Description**|**Example**|**Type**|**Type**|
|---|---|---|---|---|---|
||`app.kubernetes.io/name`|The name|`... | Concepts | Kubernetes.pdf | {
"answer": "mysql-abcxyz",
"evidence_quote": "app.kubernetes.io/instance | A unique | `mysql-` | strin | | | name | `abcxyz` | |",
"question": "What is the example value for the `app.kubernetes.io/instance` label?"
} |
.io/version`|The current|`5.7.21`|strin||
|||version of||||
|||the||||
|||application||||
https://kubernetes.io/docs/concepts/_print/
Page 50 sur 1 115
Concepts | Kubernetes
07/04/2026 07:18
|||(e.g., a||||
|---|---|---|---|---|---|
|||SemVer 1.0,||||
|||revision||||
|||hash, etc.)||||
||`app.kubernetes.io/com... | Concepts | Kubernetes.pdf | {
"answer": "5.7.21",
"evidence_quote": "app.kubernetes.io/version:\"5.7.21\"",
"question": "What is the version of the application instance defined in the StatefulSet?"
} |
cxyz
app.kubernetes.io/version:"5.7.21"
app.kubernetes.io/component:database
app.kubernetes.io/part-of:wordpress
app.kubernetes.io/managed-by:Helm
```
## Applications And Instances Of Applications
An application can be installed one or more times into a Kubernetes cluster and, in some cases, the same namespace. For ... | Concepts | Kubernetes.pdf | {
"answer": "5.7.21",
"evidence_quote": "app.kubernetes.io/version:\"5.7.21\"",
"question": "What is the value of the app.kubernetes.io/version label?"
} |
y instance of an application must have a unique name.
## Examples
To illustrate di"erent ways to use these labels the following examples have varying complexity.
## A Simple Stateless Service
Consider the case for a simple stateless service deployed using `Deployment` and `Service` objects. The following two sn... | Concepts | Kubernetes.pdf | {
"answer": "The Deployment sets `app.kubernetes.io/name: myservice` and `app.kubernetes.io/instance: myservice-abcxyz`.",
"evidence_quote": "```\napiVersion:apps/v1\nkind:Deployment\nmetadata:\nlabels:\napp.kubernetes.io/name:myservice\napp.kubernetes.io/instance:myservice-abcxyz\n...\n```",
"question": "What la... |
s illustrate the start of objects used to deploy this application.
The start to the following `Deployment` is used for WordPress:
https://kubernetes.io/docs/concepts/_print/
Page 52 sur 1 115
Concepts | Kubernetes
07/04/2026 07:18
```
apiVersion:apps/v1
kind:Deployment
metadata:
labels:
app.kubernetes.io/na... | Concepts | Kubernetes.pdf | {
"answer": "The Deployment includes the following labels:\n- app.kubernetes.io/name: wordpress\n- app.kubernetes.io/instance: wordpress-abcxyz\n- app.kubernetes.io/version: \"4.9.4\"\n- app.kubernetes.io/managed-by: Helm\n- app.kubernetes.io/component: server\n- app.kubernetes.io/part-of: wordpress",
"evidence_quo... |
naged-by:Helm
app.kubernetes.io/component:server
app.kubernetes.io/part-of:wordpress
...
```
MySQL is exposed as a `StatefulSet` with metadata for both it and the larger application it belongs to:
```
apiVersion:apps/v1
kind:StatefulSet
metadata:
labels:
app.kubernetes.io/name:mysql
app.kubernetes.io/instance:mysql-... | Concepts | Kubernetes.pdf | {
"answer": "app.kubernetes.io/part-of:wordpress",
"evidence_quote": "app.kubernetes.io/part-of:wordpress",
"question": "Which label indicates that the MySQL StatefulSet and Service belong to the WordPress application?"
} |
otice information about both MySQL and WordPress, the broader application, are included.
https://kubernetes.io/docs/concepts/_print/
Page 54 sur 1 115
Concepts | Kubernetes
07/04/2026 07:18
## **1.2.10 - Storage Versions**
The Kubernetes API server stores objects, relying on an etcdcompatible backing store ... | Concepts | Kubernetes.pdf | {
"answer": "storage version",
"evidence_quote": "Kubernetes uses the term _storage version_ to describe how an object is stored in your cluster.",
"question": "What term does Kubernetes use to describe how an object is stored in your cluster?"
} |
er using any mix of the v1 and v2 versions of the HorizontalPodAutoscaler API. Kubernetes is responsible for converting each API call so that clients do not see what version is actually serialized.
For cluster administrators, object storage version is an important concept to understand since it is what links the API ... | Concepts | Kubernetes.pdf | {
"answer": "The API server converts between all stored versions to the API representation of the object dynamically.",
"evidence_quote": "The API Server is aware of the binary encodings of the objects and is able to convert between all the stored versions to the API Representation of the object dynamically.",
"q... |
n entirely. For example, a `v1alpha1` and `v1beta1` API Object for the same Resource will be encoded the same in storage as long as the storage version has not been updated between the two objects.
## Storage version to resource mapping
Every resource will have 1 active storage version at any point in time, meaning... | Concepts | Kubernetes.pdf | {
"answer": "No, they will be encoded the same in storage as long as the storage version has not been updated between the two objects.",
"evidence_quote": "For example, a `v1alpha1` and `v1beta1` API Object for the same Resource will be encoded the same in storage as long as the storage version has not been updated... |
ts | Kubernetes
07/04/2026 07:18
occur to the object. Writes, on the other hand, will convert the stored object to the new representation upon update.
## Storage versions for custom resources
Custom resources from built in Kubernetes types with their storage version. Builtin objects generally have their storage... | Concepts | Kubernetes.pdf | {
"answer": "A specific version of the custom resource must be set as the storage version; the schema defined by that version is used for encoding the resource in the storage layer.",
"evidence_quote": "However, for custom resources, a certain version of the resource must be set as the storage version. The schema d... |
featureset for more detailed information on the API setup and versioning.
_crontabs_ :
https://kubernetes.io/docs/concepts/_print/
Page 56 sur 1 115
Concepts | Kubernetes
07/04/2026 07:18
```
apiVersion:apiextensions.k8s.io/v1
kind:CustomResourceDefinition
metadata:
name:crontabs.example.com
spec:
group:exa... | Concepts | Kubernetes.pdf | {
"answer": "v1beta1",
"evidence_quote": "storage:true",
"question": "Which version of the CustomResourceDefinition is set as the storage version?"
} |
ma:
type:object
properties:
host:
type:string
port:
type:string
time:
type:string
conversion:
strategy:None
scope:Namespaced
names:
plural:crontabs
singular:crontab
kind:CronTab
shortNames:
- ct
```
The `v1beta1` meaning that any updates or creation of `crontabs` will be stored with the object schema of the `v1beta1` ... | Concepts | Kubernetes.pdf | {
"answer": "The newly defined storage version will be used for new or updated custom resources.",
"evidence_quote": "Only updating or creating will have an e\"ect and use the newly defined storage version.",
"question": "What version of the API will be used when a new or updated custom resource is created?"
} |
the object be in use but will just convert the object from the old storage version and not a"ect the object. Only updating or creating will have an e"ect and use the newly defined storage version.
## How storage versions are relevant to encryption at rest
There are tools to encrypt the at rest storage of a cluster,... | Concepts | Kubernetes.pdf | {
"answer": "The API Server must have the key for that storage version in order to decrypt the data as it retrieves them from storage and properly decode the object.",
"evidence_quote": "The APIServer must have the key for that storage version in order to decode the object properly.",
"question": "Why does the AP... |
han just the binary encoding of the object. As long as what is stored can be somehow converted into the API object, it can be used as a storage version.
## Migrating to a di"erent storage version
Multiple storage versions for a single resource can pose problems for cluster administrators. A cluster administrator ma... | Concepts | Kubernetes.pdf | {
"answer": "Removing a storage version prematurely can make it impossible to read the objects that still use that version.",
"evidence_quote": "If a version is removed prematurely, it can mean being unable to read the object entirely.",
"question": "What can happen if a storage version is removed before all obje... |
till are backed by old storage versions, it makes it di!cult to tell when a version can be safely removed. If a version is removed prematurely, it can mean being unable to read the object entirely.
Another important issue is the use of encryption keys as defined in the section above. Since a resource must be actively... | Concepts | Kubernetes.pdf | {
"answer": "Removing a storage version prematurely can make it impossible to read the object entirely.",
"evidence_quote": "If a version is removed prematurely, it can mean being unable to read the object entirely.",
"question": "What can happen if a storage version is removed prematurely?"
} |
Documentation-Kubernetes
Made with ❤️ using 🦥 Unsloth Studiokubernetes documentation was generated with Unsloth Recipe Studio. It contains 99 generated records.
🚀 Quick Start
from datasets import load_dataset
# Load the main dataset
dataset = load_dataset("makayel/documentation-kubernetes", "data", split="train")
df = dataset.to_pandas()
📊 Dataset Summary
📈 Records: 99
📋 Columns: 3
✅ Completion: 99.0% (100 requested)
📋 Schema & Statistics
| Column | Type | Column Type | Unique (%) | Null (%) | Details |
|---|---|---|---|---|---|
llm_structured_1 |
dict |
llm-structured | 99 (100.0%) | 0 (0.0%) | Tokens: 72 out / 390 in |
⚙️ Generation Details
Generated with 3 column configuration(s):
llm-structured: 1 column(s)
seed-dataset: 2 column(s)
📄 Full configuration available in builder_config.json and detailed metadata in metadata.json.
📚 Citation
If you use Data Designer in your work, please cite the project as follows:
@misc{nemo-data-designer,
author = {The NeMo Data Designer Team, NVIDIA},
title = {NeMo Data Designer: A framework for generating synthetic data from scratch or based on your own seed data},
howpublished = {\url{https://github.com/NVIDIA-NeMo/DataDesigner}},
year = 2026,
note = {GitHub Repository},
}
💡 About NeMo Data Designer
NeMo Data Designer is a general framework for generating high-quality synthetic data that goes beyond simple LLM prompting. It provides:
- Diverse data generation using statistical samplers, LLMs, or existing seed datasets
- Relationship control between fields with dependency-aware generation
- Quality validation with built-in Python, SQL, and custom local and remote validators
- LLM-as-a-judge scoring for quality assessment
- Fast iteration with preview mode before full-scale generation
For more information, visit: https://github.com/NVIDIA-NeMo/DataDesigner (pip install data-designer)
- Downloads last month
- 11