Skip to main content
Lexicon
Lexicon
Kubernetes

Kubernetes

Difficulty: Intermediate
6 min read
Updated 2026-08-17

In plain English

Plain definition

Kubernetes is a system that runs containerised applications across a group of machines, called a cluster, and keeps them running the way an operator has specified. It decides which machine runs each container, restarts containers that fail, and adjusts how many copies of an application are running to match the declared target.

How the control plane works

Kubernetes exposes a declarative API that describes the desired state of workloads, storage and networking. A control plane continuously compares that declared state against the observed state of the cluster and takes corrective action to reconcile the two. Each machine that runs workloads (a node) runs an agent that starts, stops and reports on containers under instruction from the control plane.

The names and responsibilities of individual control-plane components (for example, an API server, a scheduler, a controller manager and a cluster data store) are established Kubernetes concepts. Their precise current behaviour, defaults and version-specific guarantees still need checking against the official documentation for the installed Kubernetes version before you treat them as settled fact in a particular environment.

Why teams hand containers to it

Kubernetes saves teams from placing, restarting and scaling containers by hand on individual hosts. They describe the workload they want (for example, “run three copies of this application, restart any that crash, and expose them behind a stable network address”) and Kubernetes works continuously towards that description. The manifests become the main source of truth rather than changes made on the hosts, and the control plane is expected to undo any drift caused by a manual change made directly on a node.

Where Kubernetes sits in the stack

Kubernetes sits above the container runtime and below the workload itself. It assumes an underlying set of machines joined into a cluster, a container runtime capable of running the specified container images, and a network fabric that lets containers on different nodes reach one another and reach the cluster’s internal services. Kubernetes coordinates these lower layers rather than replacing them. Applications are usually packaged as container images and described as one or more Kubernetes objects, such as a Deployment or a Service, rather than being installed directly on a specific machine.

Asking for three copies of an application

The simplest way to see the declarative approach is a Deployment manifest that asks for a fixed number of running copies of an application:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: example-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: example-app
  template:
    metadata:
      labels:
        app: example-app
    spec:
      containers:
        - name: example-app
          image: example-app:stable
          ports:
            - containerPort: 8080

Once a manifest like this is applied in an isolated or non-production cluster, check the result with read-only commands instead of assuming the declared state has been reached:

  • kubectl get deployment example-app to confirm the desired and available replica counts match.
  • kubectl get pods -l app=example-app to confirm each pod reports Running and passes its readiness checks.

Running is not the same as working

It is easy to treat Kubernetes as a platform that guarantees an application is correct, secure or highly available simply because it is “running on Kubernetes”. Kubernetes enforces the desired count and placement of containers; it does not verify that the containerised application itself behaves correctly, that its security configuration is sound, or that its dependencies are themselves resilient. A running pod shows only that Kubernetes has reconciled its own object state, not that the application is fit for purpose.

Other Kubernetes terms

  • Pod: the smallest deployable unit Kubernetes schedules, typically one or more tightly coupled containers.
  • Node: a machine, physical or virtual, that Kubernetes uses to run pods.
  • Control plane: the set of components that hold and reconcile the cluster’s declared state.
  • Deployment: a Kubernetes object that manages a replicated set of pods and their rollout.
  • kubectl: the standard command-line client used to inspect and change cluster state.

Further reading

Before relying on any version-specific behaviour, defaults, or component name described above in a production decision, confirm it against the official documentation for the Kubernetes version actually installed, and verify cluster-specific behaviour directly with read-only commands, such as those in the example above, in a non-production environment first. Where a claim about current Kubernetes internals cannot be confirmed this way, treat it as provisional and escalate to a platform engineer with cluster access before acting on it.

About this page

Credited to

Dates

Published

Corrections

No corrections are listed for this page. Some review sweeps corrected pages without naming each one; those are in the corrections log.

Was this useful?

Reports go to the site owner and are used to correct pages. Corrections are listed at /corrections.