Glossary

What the system currently looks like, as observed rather than assumed.

Reported by the components doing the work rather than assumed by whoever asked for it. The gap between this and desired state is the only thing a control loop acts on.

See also Desired state, Reconciliation

A set of machines that Kubernetes manages as one pool of compute.

A cluster is a control plane plus the nodes it schedules work onto. You talk to the cluster, not to individual machines.

See also Control plane, Node

The default service type: reachable only from inside the cluster.

See also Service, Ingress

Non-secret configuration data, kept outside the container image.

Mount it as files or inject it as environment variables. The same image can then run in staging and production unchanged.

See also Secret, Volume

An isolated process running from an image.

See also Pod

A packaged filesystem and start command that a container is created from.

The image is immutable and is identified by a tag or a digest. Anything that has to differ between environments should stay out of it.

See also Container, ConfigMap

Something that repeatedly observes state, compares it to what is wanted, and acts.

Kubernetes is a collection of these rather than one program working through a plan. They run independently, and none of them assumes it was the last thing to change anything.

See also Reconciliation, Controller, Desired state

The components that decide what should run and where.

The API server, scheduler, and controller manager. It holds desired state and continuously drives the cluster toward it.

See also Cluster, Reconciliation, Scheduler

A process running one reconciliation loop for one kind of object.

See also Reconciliation

You describe the end state you want, not the steps to reach it.

You submit an object saying "three replicas of this image". Kubernetes works out the difference from reality and closes the gap.

See also Reconciliation, Manifest

An object that keeps a stated number of identical pods running, and updates them safely.

A deployment owns replicasets. Changing the pod template creates a new replicaset and shifts pods over gradually, which is what makes a rollout a rollout.

See also ReplicaSet, Pod, Rollout

What the system is supposed to look like.

You write it down and it stays written down. Nothing about it changes when reality drifts away from it.

See also Actual state, Reconciliation, Declarative

The system is not always correct, but something is always working on it.

A reconciler moves a system toward its desired state rather than putting it there. Between the moment reality diverges and the moment it matches again there is a window where the system is wrong and converging at the same time. Asking whether the gap is closing is usually more useful than asking whether it is closed.

See also Reconciliation, Control loop, Desired state, Actual state

Rules for routing external HTTP traffic to services inside the cluster.

An ingress object is inert on its own. An ingress controller watches those objects and configures a real proxy to match.

See also Service, Controller

The agent on each node that starts and supervises the node's pods.

See also Node, Pod

A key/value tag attached to an object, used for grouping and selection.

See also Selector

A YAML or JSON file describing a Kubernetes object.

See also Declarative

A scope for object names within a cluster.

Two namespaces can each hold a Deployment named web. Namespaces scope most objects, but not cluster-wide ones such as nodes.

See also Object, Cluster

A single machine, virtual or physical, that runs workloads.

Each node runs a kubelet and a container runtime. The control plane places pods onto nodes; the node is responsible for actually running them.

See also Cluster, Kubelet, Pod

A record in the Kubernetes API describing a piece of desired state.

It has a kind, a name, a spec saying what you want, and later a status saying what is. Creating one changes nothing by itself, and a controller acting on it is what changes something.

See also Manifest, Declarative, Namespace, Desired state

A piece of storage in the cluster, with a lifetime independent of any pod.

See also PersistentVolumeClaim, StorageClass

A pod's request for storage of a given size and access mode.

The claim is what a workload references. Kubernetes binds it to a matching volume, provisioning one on demand if a StorageClass says how.

See also PersistentVolume, StorageClass

The smallest deployable unit: one or more containers that share a network namespace and storage.

Containers in a pod share an IP address and can talk over localhost. Pods are disposable by design, and you rarely create them by hand.

See also Container, Node, Deployment

Look at what is wanted, look at what exists, act on the difference, then look again.

The loop the whole system is built from. It reads the current state rather than a stream of instructions, so an event that arrives twice or never arrives at all changes nothing.

See also Desired state, Actual state, Control loop, Controller

One interchangeable copy of a workload.

Interchangeable is the important word. If any copy is as good as any other, the system is free to delete one and start another somewhere else.

See also ReplicaSet, Deployment, Pod

Keeps a fixed number of identical pods alive.

See also Deployment, Pod

Replacing pods with a new version incrementally, so the service stays up.

See also Deployment

The control plane component that picks which node a new pod should run on.

It filters nodes that cannot fit the pod, then scores the rest on resource fit, spread, and affinity rules.

See also Control plane, Node, Pod

Like a ConfigMap, but for sensitive values and handled more carefully.

Base64 encoding is not encryption. Secrets are only as private as the cluster's RBAC and encryption-at-rest settings make them.

See also ConfigMap

A label query that decides which pods an object applies to.

See also Service, Label

A stable name and address for a changing set of pods.

Pods come and go with new IPs. A service gives them one virtual IP and DNS name, and load balances across whichever pods currently match its selector.

See also ClusterIP, Selector, Pod

Like a deployment, but each pod keeps a stable identity and its own storage.

Pods are numbered and started in order, and each one gets its own persistent volume claim that survives a restart.

See also Deployment, PersistentVolumeClaim

A named recipe for provisioning storage automatically.

See also PersistentVolumeClaim

A directory made available to a pod's containers.

See also ConfigMap, PersistentVolume