Infrastructure & Operations › Kubernetes & Orchestration

Kubernetes

The dominant container orchestration platform.

Backend Engineer · Mid-level · core Frontend Engineer · Senior Data Engineer · Mid-level

Also known as: K8s, k8s, Kubernetes orchestration, kube

Kubernetes (K8s) is the dominant platform for running containers at scale. You tell it what you want (“run 3 copies of this container, keep them healthy, expose them on this address”), and it continuously works to make reality match, placing containers on machines, restarting failures, scaling and rolling out updates.

It’s declarative: you describe the desired state in YAML, and Kubernetes’ controllers reconcile the cluster to it.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web
spec:
  replicas: 3
  selector:
    matchLabels: { app: web }
  template:
    metadata:
      labels: { app: web }
    spec:
      containers:
        - name: web
          image: registry.example.com/shop:3f9c2a1
          ports: [{ containerPort: 8000 }]
          resources:
            requests: { cpu: "250m", memory: "256Mi" }
            limits: { memory: "512Mi" }

kubectl apply -f deployment.yaml
kubectl get pods

The main building blocks

Concept	What it is
Pod	The smallest unit: one or more containers that run together
Deployment	Keeps N copies of a pod running and handles rolling updates
Service	A stable address and load balancing for a set of pods
Ingress	Routes external HTTP traffic to services
ConfigMap and Secret	Configuration and sensitive values for pods
Namespace	A way to separate teams or environments in a cluster
Probes	Health checks that decide when a pod is ready or needs restarting
Requests and limits	CPU and memory the pod needs and may use

The control plane makes decisions, and nodes (machines) run the pods.

What it gives you

Self-healing, automatic scaling (HPA), rolling updates and rollbacks, service discovery, and a common API across clouds and on-premises.

What it costs

A steep learning curve and a large surface of concepts and YAML.
Operational complexity: networking, upgrades, security, observability. Most teams use a managed service rather than running it themselves.
Overkill for small systems. A single service on a simple platform may need far less (do you need Kubernetes?).

For developers, the practical skills are: reading and writing deployment manifests, kubectl basics, understanding probes and resource limits, and debugging a pod that won’t start (for example CrashLoopBackOff).