What is Kubernetes and What Problems Does It Solve?

1. What is Kubernetes?

Kubernetes (K8s) is an open-source container orchestration platform that automates the deployment, scaling, and management of containerized applications. It provides a self-healing, scalable, and efficient way to run applications across multiple machines in a cluster.

Developed by Google, Kubernetes is now maintained by the Cloud Native Computing Foundation (CNCF).

---

2. Problems Kubernetes Solves

Before Kubernetes, managing containers in production environments was complex. Here are some challenges that Kubernetes addresses:

Problem 1: Manual Container Management

• Running multiple containers manually (docker run ...) is error-prone.
• If a container crashes, it must be restarted manually.

How Kubernetes Solves It

• Kubernetes uses Pods (groups of containers) and Controllers to automatically restart failed containers.
• Example: If an application crashes, Kubernetes recreates the container automatically.

---

Problem 2: Scalability Issues

• Scaling applications manually (docker scale ...) is difficult.
• If traffic increases, adding more containers manually is slow.

How Kubernetes Solves It

• Kubernetes provides Auto Scaling based on CPU/memory usage.
• Example:

  apiVersion: autoscaling/v1
  kind: HorizontalPodAutoscaler
  metadata:
    name: my-app-hpa
  spec:
    scaleTargetRef:
      apiVersion: apps/v1
      kind: Deployment
      name: my-app
    minReplicas: 2
    maxReplicas: 10
    targetCPUUtilizationPercentage: 50
  

  If CPU usage goes above 50%, Kubernetes adds more pods automatically.

---

Problem 3: Service Discovery & Load Balancing

• In Docker, you must manually expose ports (-p 8080:80).
• Traffic routing between multiple containers is difficult.

How Kubernetes Solves It

• Kubernetes provides built-in Service Discovery and Load Balancing.
• Example:

  apiVersion: v1
  kind: Service
  metadata:
    name: my-app-service
  spec:
    selector:
      app: my-app
    ports:
      - protocol: TCP
        port: 80
        targetPort: 8080
  

  Now, users can access the app via my-app-service instead of an IP address.

---

Problem 4: Deployment and Rollback Complexity

• Updating applications manually (docker stop, docker run new_version) causes downtime.
• If a new deployment fails, rolling back is hard.

How Kubernetes Solves It

• Kubernetes supports Rolling Updates and Rollbacks.
• Example:

  kubectl set image deployment/my-app my-app=nginx:1.21
  kubectl rollout undo deployment my-app  # Rollback if needed
  

  No downtime! Kubernetes updates the app gradually, ensuring zero service interruption.

---

Problem 5: Multi-Host Networking

• Containers on different nodes (machines) cannot easily communicate in Docker.
• Managing networking across hosts is complicated.

How Kubernetes Solves It

• Kubernetes automatically assigns IPs to each container.
• Uses CNI (Container Network Interface) to manage multi-host networking.

---

Problem 6: Persistent Storage for Containers

• Containers are ephemeral (data is lost if a container restarts).
• Manually mounting storage in Docker (-v /data:/data) is not scalable.

How Kubernetes Solves It

• Kubernetes provides Persistent Volumes (PV) and Persistent Volume Claims (PVC).
• Example:

  apiVersion: v1
  kind: PersistentVolumeClaim
  metadata:
    name: my-pvc
  spec:
    accessModes:
      - ReadWriteOnce
    resources:
      requests:
        storage: 1Gi
  

  Now, even if a container restarts, the data remains safe.

---

3. Kubernetes Use Case: Deploying a Scalable Web Application

Scenario:
A company has a web app with a Node.js backend and MongoDB database. They face scaling issues when traffic spikes.

Solution with Kubernetes

1. Use Deployments for automatic scaling and self-healing.
2. Use Services for load balancing.
3. Use Persistent Volumes for database storage.

Kubernetes YAML Configuration

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nodejs-app
spec:
  replicas: 3  # Start with 3 instances
  selector:
    matchLabels:
      app: nodejs
  template:
    metadata:
      labels:
        app: nodejs
    spec:
      containers:
        - name: nodejs-container
          image: my-nodejs-app:latest
          ports:
            - containerPort: 3000
---
apiVersion: v1
kind: Service
metadata:
  name: nodejs-service
spec:
  selector:
    app: nodejs
  ports:
    - protocol: TCP
      port: 80
      targetPort: 3000
  type: LoadBalancer

Benefits

Kubernetes automatically scales the app when traffic increases.
If a pod crashes, Kubernetes restarts it.
Users access the service without worrying about container IPs.

---