Kubernetes — Container Orchestration

What is Kubernetes?

Kubernetes (K8s) is a system for automating deployment, scaling, and management of containerized applications.

Docker runs containers. Kubernetes runs and manages thousands of containers across hundreds of servers.

Docker: "Here's how to run one container"
Kubernetes: "Here's how to run 10,000 containers reliably"

Why Kubernetes?

Imagine you have a web app running in Docker. What happens when:

• Traffic spikes — you need more containers?
• A container crashes — who restarts it?
• You deploy a new version — how do you do it without downtime?
• A server dies — where do the containers go?

Kubernetes handles all of this automatically.

Kubernetes Architecture

Control Plane

• API Server — the front door to Kubernetes, all commands go through it
• Scheduler — decides which node to run a pod on
• Controller Manager — ensures desired state matches actual state
• etcd — distributed key-value store, the source of truth for cluster state

Worker Nodes

• Kubelet — agent on each node, talks to the API server
• Container Runtime — Docker or containerd, actually runs containers
• kube-proxy — handles networking between pods

Core Concepts

Pod

The smallest deployable unit in Kubernetes. A pod wraps one or more containers.

# pod.yaml
apiVersion: v1
kind: Pod
metadata:
  name: my-app
spec:
  containers:
  - name: app
    image: my-app:1.0
    ports:
    - containerPort: 3000
    resources:
      requests:
        memory: "64Mi"
        cpu: "250m"
      limits:
        memory: "128Mi"
        cpu: "500m"

Deployment

Manages a set of identical pods. Handles rolling updates and rollbacks.

# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 3          # run 3 pods
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: app
        image: my-app:1.0
        ports:
        - containerPort: 3000

Service

Exposes pods to network traffic. Provides a stable IP/DNS even as pods come and go.

# service.yaml
apiVersion: v1
kind: Service
metadata:
  name: my-app-service
spec:
  selector:
    app: my-app          # routes to pods with this label
  ports:
  - port: 80
    targetPort: 3000
  type: LoadBalancer     # creates a cloud load balancer

How Kubernetes Self-Heals

Rolling Deployments — Zero Downtime

spec:
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1        # add 1 extra pod during update
      maxUnavailable: 0  # never take pods down before new ones are ready

Before update: [v1] [v1] [v1]
During update: [v1] [v1] [v2]  ← new pod added, traffic shifts
               [v1] [v2] [v2]
After update:  [v2] [v2] [v2]

Essential kubectl Commands

# Apply a configuration
kubectl apply -f deployment.yaml
 
# Get resources
kubectl get pods
kubectl get deployments
kubectl get services
 
# Describe a resource (detailed info)
kubectl describe pod my-app-abc123
 
# View logs
kubectl logs my-app-abc123
kubectl logs -f my-app-abc123  # follow
 
# Execute command in pod
kubectl exec -it my-app-abc123 -- sh
 
# Scale a deployment
kubectl scale deployment my-app --replicas=5
 
# Rolling update
kubectl set image deployment/my-app app=my-app:2.0
 
# Rollback
kubectl rollout

Managed Kubernetes Services

Running your own Kubernetes control plane is complex. Cloud providers offer managed versions:

With managed K8s, the provider runs the control plane. You just manage worker nodes and workloads.

When to Use Kubernetes

Use Kubernetes when:

• Running many microservices
• Need auto-scaling
• Multiple teams deploying independently
• High availability is critical

Don't use Kubernetes when:

• Small application, single service
• Small team without DevOps expertise
• Early stage startup (use Vercel, Railway, Render instead)

Kubernetes has significant operational complexity. Don't adopt it until you need it.

Key Takeaway

• Kubernetes automates deployment, scaling, and healing of containers
• Pod = one or more containers, smallest unit
• Deployment = manages replicas, rolling updates, rollbacks
• Service = stable network endpoint for pods
• Control plane manages desired state, worker nodes run workloads
• Use managed K8s (EKS, GKE, AKS) — don't run your own control plane