Skip to main content
In this lesson we provide a clear, high-level overview of Kubernetes cluster architecture, then drill down into each component: their roles, responsibilities, and how they interact. By the end, you’ll be able to inspect a cluster and identify where each piece lives and what it does.
A dark presentation slide titled "Cluster Architecture" showing eight numbered boxes with Kubernetes topics (e.g., Kubernetes Architecture, etcd, Controller Managers, Kube Scheduler, Kubelet). A presenter stands on the right, gesturing as they speak.
We’ll use a simple ship analogy to make the architecture easier to visualize:
  • The Kubernetes cluster hosts your containerized applications and automates deployment, scaling, and networking.
  • Worker nodes are like cargo ships that carry containers (your application workloads).
  • Control plane nodes act as control ships that plan, monitor, and coordinate the cargo ships.
Nodes can be physical or virtual, and can run on-premises or in the cloud. Worker nodes run application containers; the control plane manages, schedules, and reconciles the desired state for the entire fleet.
Kubernetes cluster = control plane (brains) + worker nodes (muscle). Understanding which components run where helps when debugging, upgrading, or securing clusters.
Control plane responsibilities
  • Persist and manage cluster state
  • Schedule workloads onto appropriate nodes
  • Continuously reconcile desired state with actual cluster state
  • Expose the API used for cluster operations
These responsibilities are implemented by a set of components collectively called the control plane. etcd — the cluster datastore
  • etcd is a distributed, highly available key-value store that persists Kubernetes cluster state and configuration.
  • It stores information about nodes, pods, Services, ConfigMaps, Secrets (encrypted in many production clusters), and more.
  • etcd is critical: if its data is lost or corrupted, cluster state is compromised.
Always back up etcd regularly and secure access to it. etcd contains the authoritative source of truth for your cluster—losing it can cause downtime or data loss.
Scheduling — choosing the right ship
  • The scheduler (kube-scheduler) selects the best node for a Pod based on resource requests, node capacity, and scheduling policies (for example, taints/tolerations and node affinity).
  • Scheduling decisions evaluate pod requirements and node characteristics to optimize placement and maintain cluster stability.
Controllers — specialized offices that reconcile state
  • Controllers are control-plane processes that continuously reconcile desired state (from the API) with the actual state.
    • Node controller: handles node lifecycle events (registration, unavailability, removal).
    • Deployment/ReplicaSet controllers: ensure the desired number of replicas are running.
    • ServiceAccount and other controllers: manage authentication objects and domain-specific resources.
kube-apiserver — the cluster front-end
  • The kube-apiserver is the primary management component. It exposes the Kubernetes API used by administrators, controllers, and kubelets.
  • All control plane components and external tools read from and write to the cluster through the kube-apiserver.
  • kubelets report node and Pod status to the kube-apiserver, and controllers act on changes observed via the API.
Container runtime
  • Nodes need a container runtime to run container images. Kubernetes supports any CRI-compatible runtime.
  • Common runtimes include containerd and CRI-O. Historically Docker was common, but modern clusters use CRI-compatible backends.
  • The runtime is responsible for pulling images, starting containers, and exposing container lifecycle information to the kubelet.
Worker node components
  • kubelet: the node agent responsible for registering the node, receiving Pod specs from the API server, and ensuring containers are started and healthy. It regularly reports status back to the API server.
  • kube-proxy: manages networking rules on the node so Pods and Services can communicate. It implements Service load-balancing using iptables or IPVS.
  • Container runtime: pulls and runs container images (e.g., containerd, CRI-O).
Summary of key components
A slide showing a Kubernetes architecture diagram with Master components (etcd, kube-apiserver, controller-manager, kube-scheduler) on the left and Worker nodes (kubelet, kube-proxy, container runtime) on the right. An instructor/presenter stands in front of the slide at the lower right.
This overview gives you a cohesive mental model: control plane components manage cluster state, scheduling, and reconciliation, while worker node components execute workloads and implement networking. Each component is covered in more detail in dedicated sections and hands-on labs to reinforce these concepts. Links and references That’s it for now.

Watch Video