Control plane components (API server, scheduler, controller manager, etcd) in Kubernetes - Mini Project: Build & Apply

Understanding Kubernetes Control Plane Components

📖 Scenario: You are learning how Kubernetes manages your containerized applications. The control plane is like the brain of Kubernetes. It has parts that talk to each other to keep your apps running smoothly.In this project, you will create simple representations of the main control plane components: the API server, scheduler, controller manager, and etcd. This will help you understand their roles and how they connect.

🎯 Goal: Build a simple Python script that models the Kubernetes control plane components as a dictionary. Then add a configuration for their status, write logic to check which components are running, and finally print the running components.

📋 What You'll Learn

Create a dictionary named control_plane with keys for api_server, scheduler, controller_manager, and etcd with initial status values.

Add a variable named running_status that holds the string "Running".

Write a loop that creates a list running_components containing the names of components whose status matches running_status.

Print the list running_components.

💡 Why This Matters

🌍 Real World

Kubernetes control plane components manage the cluster state and ensure your applications run correctly. Understanding their status helps troubleshoot and maintain healthy clusters.

💼 Career

DevOps engineers and site reliability engineers often monitor and manage these components to keep Kubernetes clusters stable and performant.

1

Create the control plane components dictionary

Create a dictionary called control_plane with these exact entries: 'api_server': 'Running', 'scheduler': 'Stopped', 'controller_manager': 'Running', and 'etcd': 'Running'.

Kubernetes

# Create the control_plane dictionary with component statuses
# Your code here

Hint

Use curly braces {} to create a dictionary. Each key is a component name as a string, and each value is its status as a string.

2

Add the running status variable

Add a variable called running_status and set it to the string 'Running'.

Kubernetes

control_plane = {
    'api_server': 'Running',
    'scheduler': 'Stopped',
    'controller_manager': 'Running',
    'etcd': 'Running'
}
# Define running_status variable
# Your code here

Hint

Just assign the string 'Running' to the variable running_status.

3

Find running components

Write a for loop using variables component and status to iterate over control_plane.items(). Inside the loop, if status equals running_status, add component to a list called running_components. Initialize running_components as an empty list before the loop.

Kubernetes

control_plane = {
    'api_server': 'Running',
    'scheduler': 'Stopped',
    'controller_manager': 'Running',
    'etcd': 'Running'
}
running_status = 'Running'

# Create running_components list and fill it with components that are running
# Your code here

Hint

Use control_plane.items() to get key-value pairs. Check if the status matches running_status. If yes, add the component name to the list.

4

Print the running components

Write a print statement to display the list running_components.

Kubernetes

control_plane = {
    'api_server': 'Running',
    'scheduler': 'Stopped',
    'controller_manager': 'Running',
    'etcd': 'Running'
}
running_status = 'Running'
running_components = []
for component, status in control_plane.items():
    if status == running_status:
        running_components.append(component)

# Print the running_components list
# Your code here

Hint

Use print(running_components) to show the list of running components.

Practice

1. Which component of the Kubernetes control plane acts as the main entry point for all REST commands and handles communication with the cluster?

easy

A. etcd

B. Scheduler

C. API server

D. Controller manager

Solution

1. Step 1: Understand the role of the API server

   The API server is the front door of the Kubernetes control plane. It receives REST requests and processes them.

2. Step 2: Compare with other components

   The scheduler assigns pods to nodes, the controller manager runs controllers, and etcd stores cluster data. None handle REST communication directly.

3. Final Answer:

   API server -> Option C

4. Quick Check:

   API server = main REST entry point [OK]

Hint: API server handles all REST requests to the cluster [OK]

Common Mistakes:

• Confusing scheduler with API server
• Thinking controller manager handles REST calls
• Assuming etcd processes API requests

2. Which of the following is the correct command to check the status of the Kubernetes scheduler component?

easy

A. kubectl get pods -n kube-system | grep scheduler

B. kubectl get nodes --show-scheduler

C. kubectl describe scheduler

D. kubectl get scheduler-status

Solution

1. Step 1: Identify how to check scheduler status

   The scheduler runs as a pod in the kube-system namespace, so checking pods there helps find it.

2. Step 2: Analyze each command

   kubectl get pods -n kube-system | grep scheduler lists pods in kube-system and filters for scheduler, which is correct. The other commands are invalid kubectl commands or do not exist.

3. Final Answer:

   kubectl get pods -n kube-system | grep scheduler -> Option A

4. Quick Check:

   Scheduler runs as pod, check pods in kube-system [OK]

Hint: Scheduler runs as pod; check pods in kube-system namespace [OK]

Common Mistakes:

• Using invalid kubectl commands
• Trying to describe scheduler directly
• Assuming scheduler is a node property

3. Given the following scenario: The Kubernetes scheduler fails to assign pods to nodes. Which control plane component is most likely responsible for detecting and fixing this issue automatically?

medium

A. API server

B. kubelet

C. etcd

D. Controller manager

Solution

1. Step 1: Understand the roles of components

   The controller manager runs controllers that watch cluster state and fix issues like unscheduled pods.

2. Step 2: Identify responsible component for fixing scheduling issues

   When scheduler fails, controller manager detects pods not assigned and may trigger rescheduling or alerts. API server only handles requests, etcd stores data, kubelet runs on nodes.

3. Final Answer:

   Controller manager -> Option D

4. Quick Check:

   Controller manager fixes cluster state issues [OK]

Hint: Controller manager fixes cluster state problems automatically [OK]

Common Mistakes:

• Confusing API server with controller manager
• Thinking etcd fixes issues
• Assuming kubelet manages scheduling

4. You notice that the etcd cluster is not storing new data correctly. Which of the following is the most likely cause and fix?

medium

A. etcd disk is full; free up disk space or increase storage

B. Scheduler is overloaded; scale scheduler pods

C. API server is down; restart the API server pods

D. Controller manager crashed; restart controller manager

Solution

1. Step 1: Identify symptoms related to etcd

   etcd stores cluster data. If it fails to store new data, disk space or storage issues are common causes.

2. Step 2: Match cause and fix

   API server, scheduler, and controller manager issues do not directly cause etcd storage failure. Disk full on etcd node is the likely cause; freeing space or increasing storage fixes it.

3. Final Answer:

   etcd disk is full; free up disk space or increase storage -> Option A

4. Quick Check:

   etcd storage issues = disk full fix [OK]

Hint: etcd storage issues often mean disk full; check storage first [OK]

Common Mistakes:

• Restarting unrelated components
• Ignoring disk space on etcd nodes
• Assuming scheduler affects etcd storage

5. You want to ensure high availability of the Kubernetes control plane. Which combination of components should you deploy in multiple replicas to avoid a single point of failure?

hard

A. Multiple schedulers and controller managers only

B. Multiple API servers and etcd nodes

C. Multiple etcd nodes only

D. Multiple API servers only

Solution

1. Step 1: Understand high availability needs

   High availability means no single point of failure. Both API servers and etcd store critical data and handle requests.

2. Step 2: Identify components to replicate

   API servers can run multiple replicas behind a load balancer. etcd must run as a cluster with multiple nodes for data safety. Scheduler and controller manager can be run as leader election but are less critical to replicate for HA.

3. Final Answer:

   Multiple API servers and etcd nodes -> Option B

4. Quick Check:

   HA = replicate API servers + etcd nodes [OK]

Hint: Replicate API servers and etcd for control plane high availability [OK]

Common Mistakes:

• Replicating only schedulers or controller managers
• Ignoring etcd clustering
• Assuming API server alone is enough