Published: October 16, 2026 · 5 min read

Kubernetes Architecture — Control Plane and Worker Nodes

In the first class we said a cluster has a master node and worker nodes. Now we open both and look at the parts inside.

Here is the whole class in short:

• A cluster has two halves: the control plane, and the worker nodes.
• The control plane decides what should happen. It never runs your app.
• The API Server receives and processes every Kubernetes request.
• The Scheduler decides which worker node should run a Pod.
• The Controller Manager keeps the actual state matching the desired state.
• etcd stores the cluster configuration and state.
• The kubelet runs the Pods on its worker node and reports health back.
• Kube-proxy sets up the Service networking rules on the node.
• Your containers run inside Pods, and Pods are created on the worker nodes.
• Every part talks through the API Server — never directly to each other.

The Control Plane

Four parts live here.

• API Server — Receives and processes every Kubernetes request.
• Scheduler — Decides which worker node should run a Pod.
• Controller Manager — Checks whether the actual state matches the desired state.
• etcd — Stores the cluster configuration and state.

A bit more on each:

API Server. The front door. Your commands come here. The dashboard comes here. The other parts come here too. Nothing gets in any other way.

etcd. The cluster database. Every node, every Pod, every setting. Only the API Server reads and writes it.

Scheduler. A new Pod has no node yet. The Scheduler looks at free CPU and memory, and picks one. It only decides — it does not start anything.

Controller Manager. You asked for 3 copies but only 2 are running? It creates the third. It keeps checking, always.

The Worker Node

Three things are installed on every worker node.

• Kubelet — Talks to the API Server and runs the Pods it is given.
• Kube-proxy — Sets up the Service networking rules on the node.
• Container Runtime — Runs the containers (Docker or containerd).

And one more thing, the reason they all exist:

• Pod — The wrapper around your container. Your app runs inside it.

What Is a Pod?

A Pod is the smallest thing Kubernetes runs.

You never ask for a container. You ask for a Pod, and your container runs inside it.

Most Pods hold one container. Pods are created on worker nodes only.

What Happens When You Deploy an App

1. You send the request. kubectl or the dashboard asks for your app.
2. API Server receives it. It checks the request and saves it into etcd.
3. etcd stores it. The cluster now knows what you want.
4. Controller Manager creates the Pods. What you asked for does not exist yet.
5. Scheduler picks a node. It sees Pods with no node and chooses one.
6. Kubelet starts the work. It tells the container runtime to run the Pod.
7. Kube-proxy sets up networking. Now traffic can reach the Pod.

After that the kubelet keeps reporting health back.

Two Things People Get Wrong

1. The Scheduler does not call the kubelet.

It feels like the Scheduler picks a node and then phones that node. It does not. It writes the decision through the API Server. The kubelet is watching the API Server and picks it up from there.

2. The Controller Manager is not after the Scheduler.

It is before. The Controller Manager creates the Pods, and then the Scheduler places them. And it is not a step at all — it is a loop that never stops.

Kubernetes Architecture Quick Reference

What's Next

That is the full map. The control plane decides, the worker nodes run, and everything goes through the API Server. The official components page (opens in a new tab) lists the same parts. Next we stop drawing and use a real cluster.

← Back to Kubernetes Introduction

Continue to Kubernetes Cluster Setup →

Frequently Asked Questions

What are the main components of Kubernetes architecture?

There are two halves. The control plane has four parts: the API Server, the Scheduler, the Controller Manager and etcd. Every worker node has three: the kubelet, kube-proxy and a container runtime like Docker. The control plane decides what should happen. The worker nodes run your app inside Pods.

What is the API Server in Kubernetes?

The API Server receives and processes every Kubernetes request. It is the front door of the cluster. Your kubectl commands come here, the dashboard comes here, and the other Kubernetes parts come here too. It checks the request and then writes the result into etcd. It is also the only part that talks to etcd.

What does the Kubernetes Scheduler do?

The Scheduler decides which worker node should run a Pod. It looks for Pods that have no node yet, then picks one based on free CPU and memory. It only decides. It does not start anything, and it does not call the worker node. It writes the decision back through the API Server.

What is the Controller Manager in Kubernetes?

The Controller Manager checks whether the actual state matches the desired state. You asked for 3 copies but only 2 are running? It creates the third one. A node died? It replaces what was lost. It is not one step that runs once. It is a loop that never stops checking.

What is etcd in Kubernetes?

etcd stores the Kubernetes cluster configuration and state. It is the cluster database. Every node, every Pod and every setting is written there. Only the API Server reads and writes it. Back up etcd and you have backed up the cluster.

What is the difference between kubelet and kube-proxy?

Both run on every worker node, but they do different jobs. The kubelet is the node agent. It talks to the API Server, runs the Pods it is given, and reports health back. Kube-proxy handles networking. It sets up the Service rules so traffic can reach the right Pod. The kubelet looks after the Pods, kube-proxy looks after the traffic.

What is a Pod in Kubernetes?

A Pod is the wrapper Kubernetes puts around your container. It is the smallest thing Kubernetes runs. You do not ask for a container, you ask for a Pod, and your container runs inside it. Most Pods hold one container. Pods are created on worker nodes only.