Control plane components (API server, scheduler, controller manager, etcd) in Kubernetes - Step-by-Step Execution

Process Flow - Control plane components (API server, scheduler, controller manager, etcd)

User/API Client

↓

API Server

↓

etcd (State Storage)

↓

Controller Manager

The user sends requests to the API server, which stores state in etcd. The controller manager and scheduler watch the API server to manage cluster state and assign work.

Execution Sample

Kubernetes

kubectl run mypod --image=nginx
# API server receives request
# Scheduler assigns pods to nodes
# Controller manager ensures desired state
# etcd stores cluster state

This sequence shows how a pod request flows through control plane components to schedule and maintain pods.

Process Table

Step	Component	Action	Input	Output/Effect
1	User/API Client	Sends request	kubectl run mypod --image=nginx	Request sent to API server
2	API Server	Receives request	kubectl run mypod --image=nginx	Validates and processes request
3	API Server	Reads/Writes state	Request data	Writes pending pod to etcd
4	Scheduler	Watches API server	Pod pending scheduling	Assigns pod to a node
5	Controller Manager	Watches API server	Pod assigned to node	Ensures pod is running as desired
6	etcd	Stores cluster state	Pod info updates	Persistent cluster state updated
7	API Server	Responds to user	Pod info from etcd	Returns pod info to kubectl
8	User/API Client	Receives response	Pod info	Displays pod info to user

💡 Request completed and pod state maintained by control plane components

Status Tracker

Variable	Start	After Step 2	After Step 4	After Step 6	Final
Pod Request State	None	Received by API server	Assigned to node by Scheduler	Stored in etcd	Confirmed running by Controller Manager
Cluster State in etcd	Initial cluster state	No change	No change	Updated with pod info	Updated with pod running status

Key Moments - 3 Insights

Why does the scheduler assign pods after the API server receives the request?

Because the API server validates and stores the pod request first (see execution_table step 3), the scheduler can then watch for new pods needing assignment (step 4).

How does etcd help keep the cluster state consistent?

etcd stores the persistent cluster state (step 6). All components read and write to etcd via the API server, ensuring a single source of truth.

What role does the controller manager play after the scheduler assigns a pod?

The controller manager ensures the pod is running as desired by monitoring the API server state and making adjustments if needed (step 5).

Visual Quiz - 3 Questions

Look at the execution table, at which step does the scheduler assign a pod to a node?

A Step 3

B Step 5

C Step 4

D Step 6

💡 Hint

Check the 'Component' and 'Action' columns in execution_table row 4.

According to the variable tracker, what is the state of the pod request after step 6?

A Stored in etcd

B Assigned to node by Scheduler

C Received by API server

D Confirmed running by Controller Manager

💡 Hint

Look at 'Pod Request State' column 'After Step 6' in variable_tracker.

If the API server did not update etcd, what would happen to the cluster state?

A Cluster state would remain consistent

B Cluster state would not update with pod info

C Scheduler would assign pods twice

D Controller manager would ignore pods

💡 Hint

Refer to execution_table step 6 and variable_tracker 'Cluster State in etcd'.

Concept Snapshot

Control plane components manage Kubernetes cluster state.
API server handles requests and communicates with etcd.
Scheduler assigns pods to nodes.
Controller manager ensures desired state.
etcd stores persistent cluster data.

Full Transcript

In Kubernetes, the control plane components work together to manage the cluster. The user sends a request to the API server, which validates and processes it. The API server reads and writes cluster state to etcd, the persistent storage. The scheduler watches for pods needing assignment and assigns them to nodes. The controller manager monitors the cluster state and ensures pods run as expected. This flow keeps the cluster consistent and responsive to user commands.