What is Kubernetes (K8s)? Pod Orchestration, HPA Auto-Scaling & Multi-Zone Infrastructure

It was 8:00 PM on Diwali Eve inside a network operations center in Nanakramguda, Hyderabad. Vikram, a Principal Cloud Architect, was monitoring a digital payment gateway supporting major e-commerce platforms. Traffic surged from a normal baseline of 25,000 requests per second to an unprecedented 280,000 requests per second within four minutes.

At 8:07 PM, the primary virtual machine host hit 100% CPU utilization and ran out of memory. Because the architecture relied on large, monolithic virtual machines that took 12 to 15 minutes to manually provision and warm up, the system locked up. Over 180,000 active checkout sessions timed out, creating a massive customer backlog.

During the emergency post-mortem, Vikram presented a fundamental architectural shift: Monolithic Virtual Machines are a single point of failure under dynamic load spikes.

The solution was to decompose the monolithic backend into lightweight containerized microservices managed by Kubernetes (K8s)—an automated container orchestration engine that monitors workloads, self-heals failing pods, and dynamically scales worker capacity up or down in seconds based on real-time traffic rules.

A production Kubernetes cluster is split into two distinct operational planes: the Control Plane (Master Nodes) and the Worker Nodes.

The 4 Control Plane Components (Brain of the Cluster)

• 1. `kube-apiserver`: The central API gateway exposing HTTP/REST endpoints for all management commands from administrators (`kubectl`), CI/CD pipelines, and internal controllers.
• 2. `etcd`: The immutable, highly available distributed key-value store holding the complete state configuration of the entire cluster.
• 3. `kube-scheduler`: The decision engine that evaluates resource requests (CPU, RAM) and selects the optimal worker node to run newly created Pods.
• 4. `kube-controller-manager`: Runs continuous control loops (ReplicaSet Controller, Node Controller) that compare the actual cluster state against the desired state stored in `etcd`.

Worker Node Components (Execution Muscle)

• Kubelet: The node daemon that receives pod specifications from the API server and ensures target containers are running healthily.
• Kube-proxy: The network daemon managing IP virtual routing rules and load-balancing traffic across internal Pod endpoints.
• Container Runtime (Containerd / CRI-O): The underlying engine responsible for pulling images and launching application containers inside Pods.

Core Abstractions: Pods vs. Deployments vs. Services

Below is a production-grade Kubernetes YAML manifest defining a self-healing Deployment and a Horizontal Pod Autoscaler (HPA) configured for automatic traffic scaling.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: payment-api-deployment
  labels:
    app: payment-api
spec:
  replicas: 5
  selector:
    matchLabels:
      app: payment-api
  template:
    metadata:
      labels:
        app: payment-api
    spec:
      containers:
      - name: payment-api
        image: registry.easycalcs.in/cloud/payment-api:v2.4
        ports:
        - containerPort: 8080
        resources:
          requests:
            cpu: "250m"
            memory: "512Mi"
          limits:
            cpu: "1000m"
            memory: "1024Mi"
        livenessProbe:
          httpGet:
            path: /healthz
            port: 8080
          initialDelaySeconds: 15
          periodSeconds: 10
---
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: payment-api-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: payment-api-deployment
  minReplicas: 5
  maxReplicas: 100
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70