LevelUpWith

Explore / Exam Prep for the Kubernetes and Cloud Native Associate (KCNA) / Lesson 2

Lesson 2: Cluster Architecture and the Control Plane

[Kubernetes Fundamentals – Kubernetes Core Concepts] Explains in plain terms what container orchestration is and why it is needed, then goes through the control plane components named on kubernetes.io: kube-apiserver, etcd, kube-scheduler, kube-controller-manager and cloud-controller-manager.

Free to read, no account needed. Part of Exam Prep for the Kubernetes and Cloud Native Associate (KCNA).

By the end of this level you'll be able to

  • Describe a cluster as a control plane plus worker nodes and say what problem orchestration solves
  • State the job of each control plane component and identify it among the Pods shown by `kubectl get pods -n kube-system` on kind
  • Explain why etcd is the cluster's single source of truth and why only kube-apiserver talks to it directly

Why this level matters

In Level 1 you created a kind cluster. This level covers what runs inside it. Kubernetes Fundamentals carries 44% of the KCNA curriculum, and cluster architecture is the base for the rest of that domain. A reminder of the exam format: it is online, proctored and multiple choice, it lasts 90 minutes, your purchase includes one retake, and the certification is valid for 2 years. The curriculum is published by CNCF under CC BY 4.0. This course is independent of the Linux Foundation and CNCF, which do not endorse it, and it cannot promise you a pass.

1. What problem orchestration solves

A container packages an application with everything it needs to run. Running one container on one machine is easy. Running hundreds of containers across many machines raises questions that a person cannot answer by hand all day:

  • Which machine has room for this container?
  • What happens when a container crashes at 3 a.m.?
  • How do I run 5 copies, and later 50?
  • What happens when a whole machine fails?

The CNCF curriculum describes cloud native computing as deploying applications as microservices, "packaging each part into its own container, and dynamically orchestrating those containers to optimize resource utilization." Container orchestration is that automation. You state what you want, for example "3 copies of my web app", and the orchestrator places the containers, watches them and replaces them when they fail.

An analogy: you are a restaurant owner, not the cook. You hand over the order (the desired state) and the kitchen staff make sure it gets delivered.

2. A cluster is a control plane plus worker nodes

A Kubernetes cluster has two parts:

  1. The control plane is the brain. It stores the desired state, makes decisions and responds to changes.
  2. Worker nodes are the machines that actually run your containers. Level 3 covers the components on each node.

In your kind cluster, a single Docker container called kind-control-plane plays both roles.

3. The five control plane components

kubernetes.io lists these components:

Component Job, in plain terms
kube-apiserver Exposes the Kubernetes API. It is the front end of the control plane, and every request goes through it. It scales horizontally: you can run several instances behind a load balancer.
etcd A consistent and highly-available key value store. It is Kubernetes' backing store for all cluster data.
kube-scheduler Looks for Pods that are not yet assigned to a node and picks a suitable node for each one. It weighs resource requirements, constraints, affinity and anti-affinity rules, data locality and deadlines.
kube-controller-manager Runs the controllers. Each controller watches one kind of object and works to make the actual state match the desired state. Examples are the Node, Job, EndpointSlice and ServiceAccount controllers. Logically each controller is separate, but they are compiled into a single binary running as a single process.
cloud-controller-manager (optional) Connects the cluster to a cloud provider's API, for example to create cloud load balancers. It is not present when you run on your own premises or in a learning environment on your own PC.

4. Find the components on your kind cluster

Do this: start your cluster from Level 1 if it is stopped, then run:

kubectl get pods -n kube-system

Typical output (your random suffixes will differ):

NAME                                         READY   STATUS    RESTARTS   AGE
coredns-7db6d8ff4d-4xk2p                     1/1     Running   0          5m
coredns-7db6d8ff4d-9q8lm                     1/1     Running   0          5m
etcd-kind-control-plane                      1/1     Running   0          5m
kindnet-h7fzt                                1/1     Running   0          5m
kube-apiserver-kind-control-plane            1/1     Running   0          5m
kube-controller-manager-kind-control-plane   1/1     Running   0          5m
kube-proxy-p2v6s                             1/1     Running   0          5m
kube-scheduler-kind-control-plane            1/1     Running   0          5m

Read it step by step:

  1. Find the four control plane Pods. Their names end in -kind-control-plane, the name of the node they run on: etcd, kube-apiserver, kube-controller-manager, kube-scheduler.
  2. Notice what is missing: there is no cloud-controller-manager. kind runs on your PC with no cloud provider, which matches the kubernetes.io note.
  3. Ignore coredns, kindnet and kube-proxy for now. They handle DNS, networking and node-level traffic, and later levels cover them.

Optional: inspect one component in more detail:

kubectl describe pod kube-apiserver-kind-control-plane -n kube-system

Look for the --etcd-servers= flag in the command section. It shows the API server is the component configured to reach etcd.

5. etcd: the single source of truth

Everything Kubernetes knows is stored in etcd: every Deployment, Pod, Secret and node record. Neither the scheduler nor the controllers keep their own copy of the official state. This has two consequences:

  • etcd is the single source of truth. If etcd data is lost, the cluster forgets what it is supposed to run. This is why kubernetes.io advises having a backup plan for etcd data.
  • Only kube-apiserver talks to etcd directly. The scheduler, the controller manager, kubectl and everything else read and write state by calling the API server.

Why channel everything through the API server?

  1. One gatekeeper. Each request is authenticated, authorised and validated in one place before anything is stored.
  2. Consistency. Bad or conflicting data cannot reach etcd by a side route.
  3. Security. Only one component needs credentials for etcd, which reduces exposure.

6. Putting it together: what happens when you create a Deployment

  1. You run kubectl apply, and kubectl sends the request to kube-apiserver.
  2. The API server validates the request and stores the object in etcd.
  3. A controller in kube-controller-manager sees the new Deployment and creates Pod objects through the API server.
  4. kube-scheduler sees Pods with no node and assigns each one to a node through the API server.
  5. The node then starts the containers. Level 3 covers how.

What the exam asks about this

  • Matching each component to its job, for example "which component assigns Pods to nodes?"
  • Knowing that etcd is a key value store holding all cluster data.
  • Knowing that kube-apiserver is the front end and the only component that talks to etcd.
  • Knowing that cloud-controller-manager is optional and links the cluster to a cloud provider.
  • Telling control plane components apart from node components. Expect distractors that mix the two groups.

Key takeaways

  • Orchestration automates placing, scaling and healing containers across many machines.
  • A cluster is a control plane (the brain) plus worker nodes (where containers run).
  • The control plane components are kube-apiserver, etcd, kube-scheduler, kube-controller-manager and the optional cloud-controller-manager.
  • On kind, the control plane components run as Pods in kube-system with the suffix -kind-control-plane, and there is no cloud-controller-manager.
  • etcd holds all cluster data. Only kube-apiserver accesses it directly, and everything else goes through the API.

A 6-question knowledge check follows this lesson in the app, free and without an account.

Keep going: levels 3 and 4 are free

Create a free account to open the next two levels, try the AI tutor, save your progress and pick up where you left off. No card needed.

Next: Level 3, Node Components and the Reconciliation Loop.

Create a free account →See the whole course

More like this