Kubernetes
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-appto confirm the desired and available replica counts match.kubectl get pods -l app=example-appto confirm each pod reportsRunningand 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.
Related reading
Authoritative Sources
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.