Kubernetes Architecture: 12 Components Explained

Kubernetes architecture explained: control plane (API server, etcd, scheduler, controllers), node components, add-ons and what happens on kubectl apply.

Dec 8, 2025 - 14:39
Nov 10, 2026 - 06:50
 0  148
Kubernetes Architecture: 12 Components Explained

Kubernetes architecture has two layers. The control plane (kube-apiserver, etcd, kube-scheduler, kube-controller-manager and the optional cloud-controller-manager) stores the desired state and makes decisions. Each worker node runs a kubelet, a container runtime and usually kube-proxy, which start and connect the Pods that actually run your applications.

This page is our main Kubernetes guide. It explains the twelve parts of a cluster you need to understand before you can debug one, shows how they talk to each other when you run a single kubectl apply, and links to every detailed Kubernetes guide on this site. Component names, ports and behaviour were checked against the official Kubernetes components documentation in November 2026.

Key takeaways

  • The kube-apiserver is the only component that talks to etcd. Every other component, including kubectl, goes through the API server.
  • etcd is the single source of truth for cluster state. If you lose etcd without a backup, you lose the cluster's configuration.
  • Kubernetes works by reconciliation: controllers keep comparing desired state with actual state and act on the difference.
  • The scheduler only picks a node. The kubelet on that node is what pulls images and starts containers through the container runtime.
  • Since Kubernetes 1.24 the kubelet no longer ships dockershim, so nodes use a CRI runtime such as containerd or CRI-O. Images built with Docker still run unchanged.
  • Networking, DNS and storage are pluggable. CoreDNS, a CNI plugin and CSI drivers are add-ons, not part of the core binaries.

The big picture: control plane and nodes

A Kubernetes cluster is a set of machines. Some run the control plane, the rest are worker nodes. In production the control plane usually runs on three or more machines for high availability, and on managed services such as Amazon EKS, Azure AKS or Google GKE the provider runs it for you, so you only see the nodes.

You describe what you want (for example "three replicas of this container image, reachable on port 80") as a YAML object and send it to the API server. Nothing is started at that moment. The object is stored, and a chain of components notices it and does its part. Understanding that chain is the most useful thing you can learn about Kubernetes, because almost every production problem is a break somewhere along it.

LayerComponentMain jobDefault port
Control planekube-apiserverFront door to the cluster; authenticates, validates and stores objects6443
Control planeetcdKey-value store holding all cluster state2379-2380
Control planekube-schedulerChooses a node for each new Pod10259
Control planekube-controller-managerRuns built-in controllers (Deployments, Nodes, Jobs and more)10257
Control planecloud-controller-managerLinks the cluster to a cloud provider's APIsProvider specific
NodekubeletAgent that runs and reports on Pods on its node10250
Nodekube-proxyPrograms Service routing rules on the node (optional with some CNI plugins)10256 (health)
NodeContainer runtimePulls images and runs containers through the CRILocal socket
Add-onCoreDNSCluster DNS for Services and Pods53 (inside the cluster)
Add-onCNI pluginPod networking and, often, NetworkPolicyPlugin specific
WorkloadPodSmallest deployable unit; one or more containersn/a
ClientkubectlCommand-line client for the API servern/a

Ports are from the official ports and protocols reference. All of them can be changed, and NodePort Services use 30000-32767 by default.

Control plane components

1. kube-apiserver

The API server exposes the Kubernetes REST API. Every request, whether from kubectl, a CI pipeline, a controller or a kubelet, passes through the same steps: authentication (who are you), authorization, usually RBAC (are you allowed to do this), admission control (should this object be changed or rejected) and validation against the schema. Only then is the object written to etcd.

The API server is stateless, so you scale it horizontally by running several copies behind a load balancer. It also serves "watches": long-lived connections through which other components are told about changes instead of polling. That watch mechanism is why Kubernetes reacts within seconds.

When things fail here you see errors such as Unauthorized, Forbidden or an admission webhook denying a request. Policy tools like Kyverno and OPA Gatekeeper plug in at the admission step.

2. etcd

etcd is a distributed key-value store that uses the Raft consensus algorithm. It holds every object in the cluster: Deployments, Secrets, ConfigMaps, node records and more. Raft needs a majority of members to agree, so etcd clusters use an odd number of members, typically three or five. A three-member cluster survives the loss of one member.

Two practical rules follow. First, back up etcd regularly with etcdctl snapshot save (or use your managed provider's backup) and practise restoring. Second, encrypt Secrets at rest, because by default Secrets are only base64 encoded in etcd. Kubernetes supports this through an EncryptionConfiguration file passed to the API server.

# Snapshot etcd on a kubeadm control plane node (paths are kubeadm defaults)
ETCDCTL_API=3 etcdctl snapshot save /var/backups/etcd-snap.db \
  --endpoints=https://127.0.0.1:2379 \
  --cacert=/etc/kubernetes/pki/etcd/ca.crt \
  --cert=/etc/kubernetes/pki/etcd/server.crt \
  --key=/etc/kubernetes/pki/etcd/server.key

For tools that back up whole namespaces and volumes, not only etcd, see our guides to Kubernetes backup tools and disaster recovery tools.

3. kube-scheduler

The scheduler watches for Pods that have no node assigned. For each one it runs two phases. Filtering removes nodes that cannot run the Pod (not enough CPU or memory for the requests, a taint the Pod does not tolerate, a nodeSelector or affinity rule that does not match, a volume that lives in another zone). Scoring then ranks the remaining nodes, for example to spread replicas across zones. The scheduler writes the chosen node name into the Pod's spec.nodeName and is done.

A Pod stuck in Pending is usually a scheduling problem. kubectl describe pod shows the scheduler's reason in the Events section, such as "0/3 nodes are available: 3 Insufficient cpu".

4. kube-controller-manager

A controller is a loop: read desired state, read actual state, act to close the gap, repeat. The kube-controller-manager runs many built-in controllers in one process. The Deployment controller creates ReplicaSets, the ReplicaSet controller creates Pods, the Node controller marks nodes that stop reporting, the Job controller runs batch work to completion, and the EndpointSlice controller keeps track of which Pods back each Service.

Operators such as those for databases and certificates use the same pattern for custom resources, which is why the controller model is worth understanding early. Our guide to Kubernetes deployment strategies shows the Deployment controller in action during rolling updates.

5. cloud-controller-manager

The cloud-controller-manager holds the code that talks to a specific cloud. It creates a cloud load balancer when you create a Service of type LoadBalancer, sets up routes between nodes, and removes node objects when the underlying virtual machine is deleted. Splitting this out of the main controller manager lets cloud providers release on their own schedule. On bare metal or in a local lab you do not run it; projects such as MetalLB fill the load balancer gap there, which our Kubernetes load balancers review covers.

Worker node components

6. kubelet

The kubelet runs on every node. It watches the API server for Pods assigned to its node, asks the container runtime to pull images and start containers, mounts volumes, runs liveness, readiness and startup probes, and reports Pod and node status back. It only manages containers that Kubernetes created, so a container you start by hand on the node is invisible to it.

If a node shows NotReady, start with the kubelet: systemctl status kubelet and journalctl -u kubelet on the node usually show the cause, such as an expired certificate, a full disk or a runtime that is not responding.

7. kube-proxy

A Service gives a stable virtual IP to a changing set of Pods. kube-proxy watches Services and EndpointSlices and programs the node so that traffic sent to the Service IP reaches a healthy Pod, using iptables or IPVS rules (an nftables mode is also available in recent releases). The Kubernetes documentation now lists kube-proxy as optional, because some network plugins, Cilium for example, can replace it with their own data path.

The different Service types (ClusterIP, NodePort, LoadBalancer, ExternalName and headless Services) are explained in Kubernetes Service patterns with use cases.

8. Container runtime

The kubelet talks to the runtime through the Container Runtime Interface (CRI). containerd and CRI-O are the two common choices. Docker Engine itself was removed as a direct option when dockershim was taken out in Kubernetes 1.24; images built with Docker are OCI images and run fine on containerd or CRI-O. For a deeper comparison read which container runtime to choose and containerd vs Docker in Kubernetes. On a node, crictl ps lists running containers through the CRI.

Cluster add-ons

9. CoreDNS

CoreDNS is the default cluster DNS. It lets a Pod reach a Service by name, for example payments.prod.svc.cluster.local or simply payments from inside the same namespace. When applications report "could not resolve host" inside the cluster, check the CoreDNS Pods in kube-system and the Pod's /etc/resolv.conf.

10. CNI plugin (Pod networking)

Kubernetes sets a simple rule: every Pod gets its own IP address and can reach every other Pod without NAT. It does not implement that rule itself. A Container Network Interface (CNI) plugin such as Calico, Cilium or Flannel does, and most of them also enforce NetworkPolicy objects. Without a CNI plugin installed, nodes stay NotReady after a kubeadm install. Traffic coming in from outside the cluster is handled by Ingress controllers or the Gateway API, covered in our Kubernetes Ingress best practices and Kubernetes gateways guides.

Workloads and the client

11. Pod

A Pod is one or more containers that share a network namespace (one IP, one port space) and can share volumes. Kubernetes schedules Pods, not containers. You rarely create bare Pods; a Deployment, StatefulSet, DaemonSet or Job creates and replaces them for you. Pods are disposable: when one dies, its replacement gets a new name and a new IP, which is why you put a Service in front. Persistent data lives in PersistentVolumes, explained in Kubernetes storage options.

12. kubectl

kubectl is not part of the running cluster, but it is how most people see it. It reads a kubeconfig file (by default ~/.kube/config) that holds cluster addresses, credentials and contexts, and sends REST calls to the API server. Anything kubectl does, a script or a GitOps tool can do through the same API.

What happens when you run kubectl apply

Tracing one request through the cluster ties the twelve parts together. Suppose you apply this Deployment:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      containers:
      - name: web
        image: nginx:1.27
        ports:
        - containerPort: 80
        resources:
          requests:
            cpu: 100m
            memory: 128Mi
  1. kubectl sends the object to the kube-apiserver, which authenticates you, checks RBAC, runs admission and validates the YAML.
  2. The API server stores the Deployment in etcd and returns success. No container is running yet.
  3. The Deployment controller in kube-controller-manager sees the new Deployment through a watch and creates a ReplicaSet.
  4. The ReplicaSet controller sees that zero of three Pods exist and creates three Pod objects with no node assigned.
  5. kube-scheduler sees three unscheduled Pods, filters and scores nodes using the CPU and memory requests, and binds each Pod to a node.
  6. The kubelet on each chosen node sees its new Pod, asks containerd or CRI-O to pull nginx:1.27 and start the container, then runs probes.
  7. The kubelet reports the Pod as Running and Ready. If a Service selects app: web, the EndpointSlice controller adds the Pod IPs and kube-proxy (or the CNI data path) starts sending traffic to them.

If a container later crashes, the kubelet restarts it. If a whole node disappears, the Node controller marks it unhealthy, its Pods are evicted, and the ReplicaSet controller creates replacements that the scheduler places elsewhere. Nobody runs a command; the loops do it.

Where each component usually breaks

SymptomLikely componentFirst check
kubectl times out or refuses connectionkube-apiserver or load balancer in front of itkubectl cluster-info, API server Pod logs
Changes are accepted but nothing happenskube-controller-managerController manager logs, kubectl get events
Pod stuck in Pendingkube-scheduler (or no capacity)kubectl describe pod events
ImagePullBackOffkubelet and runtime (registry, credentials, tag)Image name, imagePullSecrets
Node NotReadykubelet, runtime or CNIjournalctl -u kubelet, CNI Pods
Service unreachablekube-proxy, EndpointSlices, selector labelskubectl get endpointslices
Name resolution fails inside PodsCoreDNSCoreDNS Pods and logs in kube-system
API slow, leader election errorsetcd (disk latency, quorum)etcd metrics and member health

Practise these with the scenarios in Kubernetes scenario-based interview questions, and keep logs and metrics flowing with the tools in Kubernetes logging tools and Kubernetes dashboard tools.

Securing the architecture

  • Expose the API server only to networks that need it, and use RBAC with least privilege. Avoid binding users to cluster-admin.
  • Protect etcd with TLS between members and clients, restrict access to the API server only, and encrypt Secrets at rest.
  • Keep kubelet anonymous authentication disabled and use webhook authorization (the kubeadm defaults).
  • Apply Pod Security Admission at the baseline or restricted level per namespace.
  • Use NetworkPolicy through your CNI plugin to limit Pod-to-Pod traffic.
  • Store Secrets with a proper tool; see tools to manage Kubernetes Secrets safely.

The official Kubernetes security documentation covers each control in detail, and the CKS exam is built around them.

All Kubernetes guides on this site

Once the architecture is clear, these guides go deeper into each area.

Workloads, configuration and scaling

Networking and traffic

Storage, backup and recovery

Runtimes, operations and security

Certifications and interview practice

How to learn the architecture hands-on

  1. Build a local cluster with kind or minikube and list the control plane Pods with kubectl get pods -n kube-system.
  2. Create a Deployment, then watch the chain with kubectl get events --watch in a second terminal.
  3. Delete a Pod and watch the ReplicaSet replace it. Cordon a node and watch where new Pods land.
  4. Install a multi-node cluster with kubeadm on virtual machines so you install the CNI plugin and see etcd yourself.
  5. Take an etcd snapshot and restore it in the lab.

Our CKA training covers these labs, cluster installation, troubleshooting and etcd backup in the Kharadi, Pune classroom or live online. If you build applications rather than run clusters, the CKAD training is the better fit.

Frequently asked questions

What are the main components of Kubernetes architecture?

The control plane runs kube-apiserver, etcd, kube-scheduler, kube-controller-manager and, in clouds, cloud-controller-manager. Each worker node runs the kubelet, a container runtime such as containerd, and usually kube-proxy. Add-ons such as CoreDNS and a CNI plugin provide DNS and Pod networking.

Is the control plane the same as the master node?

Yes. Older material calls control plane machines "master nodes". The Kubernetes project now uses the term control plane, and kubeadm labels these nodes with node-role.kubernetes.io/control-plane.

Why does Kubernetes use etcd?

etcd is a consistent, distributed key-value store built on the Raft consensus algorithm. It gives Kubernetes one reliable record of desired and actual state and supports watches, so components learn about changes quickly. It runs with an odd number of members, usually three or five.

What is the difference between the kubelet and kube-proxy?

The kubelet starts, monitors and reports on the containers in Pods assigned to its node. kube-proxy handles Service networking by programming rules that send traffic for a Service IP to healthy Pods. Some CNI plugins replace kube-proxy entirely.

Does Kubernetes still use Docker?

Not as the node runtime. Dockershim was removed in Kubernetes 1.24, so nodes use CRI runtimes such as containerd or CRI-O. Images built with Docker follow the OCI format and run on those runtimes without changes, and Docker is still widely used to build images.

What happens if the control plane goes down?

Running Pods keep running because the kubelet and runtime work locally. You cannot deploy, scale or change anything, and failed Pods are not rescheduled until the control plane is back. That is why production clusters run several control plane nodes.

How many control plane nodes do I need?

Three is the common minimum for high availability, because stacked etcd needs a majority to stay available. A single control plane node is fine for learning and test clusters. Managed services such as EKS, AKS and GKE run the control plane for you.

Which certification tests Kubernetes architecture?

The Certified Kubernetes Administrator (CKA) exam from the Linux Foundation and CNCF tests cluster architecture, installation, etcd backup and troubleshooting. CKAD focuses on application workloads and CKS on cluster security.

References

What's Your Reaction?

Like Like 0
Dislike Dislike 0
Love Love 0
Funny Funny 0
Angry Angry 0
Sad Sad 0
Wow Wow 0
Mridul I am a passionate technology enthusiast with a strong focus on DevOps, Cloud Computing, and Cybersecurity. Through my blogs at DevOps Training Institute, I aim to simplify complex concepts and share practical insights for learners and professionals. My goal is to empower readers with knowledge, hands-on tips, and industry best practices to stay ahead in the ever-evolving world of DevOps.