Why Kubernetes manages microservice deployment in Microservices - Why This Architecture

Problem Statement

Deploying many microservices manually leads to errors, inconsistent environments, and downtime. Without automation, scaling services or recovering from failures becomes slow and unreliable, causing poor user experience and operational headaches.

Solution

Kubernetes automates deployment by managing containers across many machines. It monitors service health, restarts failed parts, balances load, and scales services up or down automatically. This keeps microservices running smoothly without manual intervention.

Architecture

Developer

Push Code

→Kubernetes

↓

Scheduler &

Scheduler &

This diagram shows how developers push code to Kubernetes, which then schedules and manages microservice containers on worker nodes automatically.

Trade-offs

✓ Pros

→

Automates deployment, scaling, and recovery of microservices.

→

Ensures consistent environments across development, testing, and production.

→

Improves resource utilization by efficiently scheduling containers.

→

Provides self-healing by restarting failed containers automatically.

✗ Cons

→

Adds complexity and learning curve for teams new to container orchestration.

→

Requires additional infrastructure and operational overhead.

→

Debugging issues can be harder due to abstraction layers.

Use Kubernetes when running multiple microservices that require automated scaling, high availability, and frequent deployments, especially at scale above dozens of services.

Avoid Kubernetes for very small projects with few services or low traffic where manual deployment is simpler and overhead is not justified.

Real World Examples

Spotify

Spotify uses Kubernetes to manage thousands of microservices, enabling rapid deployment and scaling of music streaming features without downtime.

Airbnb

Airbnb leverages Kubernetes to automate deployment and scaling of its microservices, improving reliability during traffic spikes like holiday seasons.

Google

Google developed Kubernetes to orchestrate containers at massive scale, powering many of its cloud services with automated management and self-healing.

Alternatives

Docker Swarm

Docker Swarm is simpler and tightly integrated with Docker but offers fewer features and less scalability than Kubernetes.

Use when: Choose Docker Swarm for smaller teams needing quick setup and simpler orchestration without complex requirements.

Serverless Platforms

Serverless abstracts infrastructure completely, running code on demand without managing containers or servers.

Use when: Choose serverless when you want to focus only on code and event-driven execution without managing deployment details.

Summary

Manual deployment of many microservices causes errors and downtime that Kubernetes prevents.

Kubernetes automates container scheduling, scaling, and self-healing to keep services running smoothly.

It is best suited for complex systems with many services needing reliable, automated management.

Practice

1. Why does Kubernetes manage microservice deployment instead of manually running each service?

easy

A. Because it replaces the need for any servers

B. Because it automates starting, stopping, and scaling services reliably

C. Because it writes the code for microservices automatically

D. Because it only works with one service at a time

Solution

1. Step 1: Understand manual deployment challenges

   Manually running many microservices is hard to keep track of and scale.

2. Step 2: Role of Kubernetes in deployment

   Kubernetes automates managing service lifecycles, scaling, and recovery to keep apps running smoothly.

3. Final Answer:

   Because it automates starting, stopping, and scaling services reliably -> Option B

4. Quick Check:

   Automation of service management = B [OK]

Hint: Kubernetes automates service control, not replaces servers or code [OK]

Common Mistakes:

• Thinking Kubernetes replaces servers
• Believing Kubernetes writes app code
• Assuming Kubernetes handles only one service

2. Which of the following is the correct Kubernetes command to deploy a microservice from a YAML file named service.yaml?

easy

A. kubectl apply -f service.yaml

B. kubectl run service.yaml

C. kubectl start service.yaml

D. kubectl create service.yaml

Solution

1. Step 1: Identify the command to apply configuration files

   The kubectl apply -f command applies changes from a YAML file to the cluster.

2. Step 2: Check other options for correctness

   kubectl run is for running pods directly, kubectl start and kubectl create do not accept YAML files directly.

3. Final Answer:

   kubectl apply -f service.yaml -> Option A

4. Quick Check:

   Apply YAML file = kubectl apply -f [OK]

Hint: Use 'kubectl apply -f' to deploy YAML files [OK]

Common Mistakes:

• Using 'kubectl run' to deploy YAML files
• Trying 'kubectl start' which is invalid
• Confusing 'kubectl create' with applying configs

3. Given this Kubernetes YAML snippet for a microservice pod:

apiVersion: v1
kind: Pod
metadata:
  name: myservice
spec:
  containers:
  - name: app
    image: myapp:v1
    ports:
    - containerPort: 80

What will happen if the pod crashes unexpectedly?

medium

A. The pod will restart only if the image is updated

B. The pod will stay crashed until manually restarted

C. Kubernetes will automatically restart the pod to keep the service running

D. Kubernetes will delete the pod and not recreate it

Solution

1. Step 1: Understand pod restart policy default

   By default, Kubernetes restarts pods automatically if they crash to maintain service availability.

2. Step 2: Check other options for correctness

   Pods do not stay crashed without restart, nor are they deleted permanently without recreation, and restarts are not tied to image updates.

3. Final Answer:

   Kubernetes will automatically restart the pod to keep the service running -> Option C

4. Quick Check:

   Pod auto-restart on crash = D [OK]

Hint: Pods auto-restart by default to keep services alive [OK]

Common Mistakes:

• Thinking pods stay crashed until manual restart
• Believing pods delete permanently on crash
• Assuming restart depends on image updates

4. You deployed a microservice with Kubernetes, but it keeps crashing. The YAML file has this snippet:

spec:
  containers:
  - name: app
    image: myapp:v1
    ports:
    - containerPort: 80
  restartPolicy: Never

What is the problem and how to fix it?

medium

A. The pod name is missing; add metadata name

B. The containerPort is wrong; change it to 8080

C. The image version is invalid; update to 'v2'

D. The restartPolicy 'Never' stops restarts; change it to 'Always' to fix

Solution

1. Step 1: Identify restartPolicy effect

   Setting restartPolicy: Never means Kubernetes will not restart the pod if it crashes.

2. Step 2: Fix by changing restartPolicy

   Changing restartPolicy to Always lets Kubernetes restart the pod automatically to keep it running.

3. Final Answer:

   The restartPolicy 'Never' stops restarts; change it to 'Always' to fix -> Option D

4. Quick Check:

   restartPolicy 'Always' enables auto-restart [OK]

Hint: Use restartPolicy 'Always' to auto-restart pods [OK]

Common Mistakes:

• Changing port without checking crash cause
• Updating image version without error info
• Ignoring restartPolicy effect

5. You want to deploy a microservice that must always be available, even if some pods fail. Which Kubernetes feature helps achieve this and how?

hard

A. Use a Deployment with replicas to run multiple pod copies for high availability

B. Use a single Pod with restartPolicy set to Never

C. Use a ConfigMap to store pod data for recovery

D. Use a ServiceAccount to control pod permissions

Solution

1. Step 1: Understand high availability needs

   Running multiple copies of a microservice ensures it stays available if some pods fail.

2. Step 2: Use Kubernetes Deployment with replicas

   A Deployment manages multiple pod replicas and automatically replaces failed pods to maintain availability.

3. Final Answer:

   Use a Deployment with replicas to run multiple pod copies for high availability -> Option A

4. Quick Check:

   Deployment + replicas = high availability [OK]

Hint: Deploy replicas with Deployment for service uptime [OK]

Common Mistakes:

• Using single pod with no replicas
• Confusing ConfigMap with availability
• Mixing permissions with availability