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:
- The control plane is the brain. It stores the desired state, makes decisions and responds to changes.
- 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:
- 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. - 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.
- Ignore
coredns,kindnetandkube-proxyfor 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?
- One gatekeeper. Each request is authenticated, authorised and validated in one place before anything is stored.
- Consistency. Bad or conflicting data cannot reach etcd by a side route.
- Security. Only one component needs credentials for etcd, which reduces exposure.
6. Putting it together: what happens when you create a Deployment
- You run
kubectl apply, and kubectl sends the request to kube-apiserver. - The API server validates the request and stores the object in etcd.
- A controller in kube-controller-manager sees the new Deployment and creates Pod objects through the API server.
- kube-scheduler sees Pods with no node and assigns each one to a node through the API server.
- 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-systemwith 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.