## glossary

What is Kubernetes?

Kubernetes (abbreviated K8s) is a container orchestration platform created by Google and donated to the CNCF in 2015. While Docker solves how to run a container on one machine, Kubernetes solves how to run thousands of them across dozens of machines, without manual intervention.

Its defining trait is the declarative model: you do not issue step-by-step orders, you describe the desired state. "I want five replicas of this application, always." The cluster continuously compares the actual state with the declared one and acts to reconcile them — if a container dies, another one comes up on its own.

The objects you need to know

Pod — the smallest deployable unit; one or more containers sharing network and storage.
Deployment — manages pod replicas and takes care of rolling updates and rollback.
Service — gives a stable address to a set of pods, distributing traffic among them.
Ingress — exposes services outside the cluster, with routing by domain and path.
ConfigMap and Secret — separate configuration and credentials from the application image.
Namespace — divides the cluster into logically isolated environments.

A Deployment declaring the desired state

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-api
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-api
  template:
    metadata:
      labels:
        app: my-api
    spec:
      containers:
        - name: api
          image: my-api:1.0
          ports:
            - containerPort: 3000
          resources:
            requests: { cpu: "100m", memory: "128Mi" }
            limits: { cpu: "500m", memory: "512Mi" }

What the cluster does for you

Once the state is declared, Kubernetes takes on responsibilities that used to be manual: it restarts containers that fail, replaces the ones that stop answering health probes, spreads pods across machines according to available resources, scales replicas based on CPU usage, and performs rolling updates without taking the service down.

Common operations via kubectl

kubectl apply -f deployment.yaml    # applies the declared state
kubectl get pods -w                 # watches the pods live
kubectl logs -f <pod>               # follows the logs
kubectl describe pod <pod>          # investigates why something failed
kubectl rollout undo deploy/my-api  # rolls back to the previous version

The honest question: do you need it?

Kubernetes solves scale and resilience problems that most projects do not have. The cost is real: a steep learning curve, operational complexity and the need for dedicated people. For an application with a handful of services, managed platforms deliver the same practical result with a fraction of the effort. The discussion about reducing that cognitive load is in the platform engineering article.

## faq

Frequently asked questions

Does Kubernetes replace Docker?

No. It orchestrates containers, which are still built with Docker or compatible tools. What changed is that Kubernetes stopped using Docker as its internal runtime, adopting containerd — but that is transparent to whoever builds the images.

What is the difference between managed and self-managed Kubernetes?

In managed services like EKS, GKE and AKS, the provider takes care of the control plane, upgrades and high availability. In the self-managed model, your team owns all of that. The difference in operational effort is large, and most companies go with managed.

Why is my pod stuck in CrashLoopBackOff?

It means the container starts, fails, and Kubernetes retries at increasing intervals. The most common causes are an application error at startup, a missing environment variable, failure to connect to a dependency, or a memory limit set too low. The way in is reading kubectl logs and kubectl describe pod.