Why container orchestration matters in Kubernetes - See It in Action

Why Container Orchestration Matters

📖 Scenario: You are working in a team that deploys applications using containers. As the number of containers grows, managing them manually becomes hard. You want to learn how container orchestration helps to automate and simplify this process.

🎯 Goal: Build a simple Kubernetes setup that shows how container orchestration manages multiple containers automatically.

📋 What You'll Learn

Create a Kubernetes deployment with multiple replicas

Add a label selector to manage pods

Use a service to expose the deployment

Display the status of pods managed by the deployment

💡 Why This Matters

🌍 Real World

Container orchestration is used in real companies to manage many containers running applications, so they stay healthy and available without manual work.

💼 Career

Understanding container orchestration with Kubernetes is a key skill for DevOps engineers and cloud professionals who deploy and maintain applications at scale.

1

Create a Deployment YAML

Create a Kubernetes deployment YAML file named deployment.yaml with these exact values: apiVersion: apps/v1, kind: Deployment, metadata.name: myapp-deployment, spec.replicas: 3, and a container named myapp-container using the image nginx:latest.

Kubernetes

# Your code here

Hint

Use the Kubernetes deployment structure with replicas: 3 and the nginx:latest image.

2

Add Label Selector

Add a label selector under spec.selector.matchLabels with the label app: myapp to the deployment.yaml file. Also add the same label under spec.template.metadata.labels.

Kubernetes

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: myapp-container
        image: nginx:latest
# Your code here

Hint

Labels help Kubernetes know which pods belong to this deployment.

3

Create a Service YAML

Create a Kubernetes service YAML file named service.yaml that exposes the deployment. Use apiVersion: v1, kind: Service, metadata.name: myapp-service, spec.selector.app: myapp, and expose port 80 on the service and target port 80 on the pods.

Kubernetes

# Your code here

Hint

The service connects to pods with label app: myapp and exposes port 80.

4

Display Pod Status

Run the command kubectl get pods -l app=myapp --no-headers -o custom-columns=NAME:.metadata.name,STATUS:.status.phase to display the names and statuses of pods with label app=myapp.

Kubernetes

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: myapp-container
        image: nginx:latest

---

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

# Run the command below to show pod names and statuses
# Your code here

Hint

This command lists pods with label app=myapp and shows their status.

Practice

1. Why is container orchestration important in managing applications?

easy

A. It helps keep many containers organized and running smoothly.

B. It replaces the need for containers entirely.

C. It slows down application deployment.

D. It only works with virtual machines, not containers.

Solution

1. Step 1: Understand container orchestration role

   Container orchestration manages multiple containers to keep them organized and running well.

2. Step 2: Compare options to orchestration purpose

   Only It helps keep many containers organized and running smoothly. correctly states orchestration helps keep containers organized and running smoothly.

3. Final Answer:

   It helps keep many containers organized and running smoothly. -> Option A

4. Quick Check:

   Container orchestration = Organize and run containers well [OK]

Hint: Orchestration means managing many containers easily [OK]

Common Mistakes:

• Thinking orchestration replaces containers
• Believing orchestration slows deployment
• Confusing orchestration with virtual machines

2. Which of the following is the correct way to describe Kubernetes in YAML files?

easy

A. Kubernetes uses YAML files to define container orchestration settings.

B. Kubernetes uses YAML files to write application code.

C. Kubernetes YAML files are only for styling web pages.

D. Kubernetes does not use YAML files at all.

Solution

1. Step 1: Identify Kubernetes YAML file purpose

   Kubernetes uses YAML files to describe how containers should be run and managed.

2. Step 2: Eliminate incorrect options

   Options A, B, and C are wrong because YAML is not for code writing, styling, or unused by Kubernetes.

3. Final Answer:

   Kubernetes uses YAML files to define container orchestration settings. -> Option A

4. Quick Check:

   Kubernetes YAML = Container orchestration config [OK]

Hint: YAML files describe container setup in Kubernetes [OK]

Common Mistakes:

• Thinking YAML is for coding apps
• Confusing YAML with web styling files
• Believing Kubernetes ignores YAML

3. What happens when Kubernetes detects a container has crashed?

medium

A. It ignores the crash and does nothing.

B. It sends an email but does not restart the container.

C. It deletes all containers in the cluster.

D. It automatically restarts the crashed container.

Solution

1. Step 1: Understand Kubernetes self-healing feature

   Kubernetes monitors containers and restarts any that crash to keep apps running.

2. Step 2: Match behavior to options

   Only It automatically restarts the crashed container. correctly describes automatic restart after a crash.

3. Final Answer:

   It automatically restarts the crashed container. -> Option D

4. Quick Check:

   Kubernetes self-healing = Auto restart crashed containers [OK]

Hint: Kubernetes restarts crashed containers automatically [OK]

Common Mistakes:

• Thinking Kubernetes ignores crashes
• Believing it deletes all containers on one crash
• Assuming manual restart is always needed

4. You wrote a Kubernetes YAML file but your containers are not scaling as expected. What is a likely cause?

medium

A. The YAML file has too many comments.

B. The YAML file is missing the HorizontalPodAutoscaler configuration.

C. Kubernetes does not support scaling containers.

D. You need to restart your computer to scale containers.

Solution

1. Step 1: Identify scaling configuration in Kubernetes

   Scaling containers requires a HorizontalPodAutoscaler resource in the YAML file.

2. Step 2: Evaluate other options

   Comments do not affect scaling, Kubernetes supports scaling, and restarting computer is unrelated.

3. Final Answer:

   The YAML file is missing the HorizontalPodAutoscaler configuration. -> Option B

4. Quick Check:

   Scaling needs autoscaler config in YAML [OK]

Hint: Missing autoscaler config stops scaling [OK]

Common Mistakes:

• Blaming comments for scaling issues
• Thinking Kubernetes can't scale containers
• Restarting computer to fix scaling

5. You want your app to handle more users during busy times without downtime. How does Kubernetes help achieve this?

hard

A. By requiring manual container restarts for scaling.

B. By stopping all containers during busy times to save resources.

C. By automatically scaling containers up and down based on demand.

D. By running only one container regardless of load.

Solution

1. Step 1: Understand Kubernetes scaling capability

   Kubernetes can automatically increase or decrease container count to match user demand.

2. Step 2: Compare options to scaling goal

   Only By automatically scaling containers up and down based on demand. describes automatic scaling to handle more users without downtime.

3. Final Answer:

   By automatically scaling containers up and down based on demand. -> Option C

4. Quick Check:

   Kubernetes auto-scales containers for demand [OK]

Hint: Auto scale containers to match user demand [OK]

Common Mistakes:

• Thinking containers stop during busy times
• Believing manual restarts are needed for scaling
• Assuming only one container runs always