Kubernetes Architecture

Why Architecture Matters

Kubernetes can feel magical until you see how its parts cooperate. Once you understand the architecture, troubleshooting becomes much easier because you know which component is responsible for each step.

Full Cluster Architecture

Control Plane Components

The control plane stores cluster state and makes decisions.

API Server

The API Server is the front door of Kubernetes. kubectl, controllers, and other components talk to it. It validates requests and exposes the Kubernetes API.

etcd

etcd is the key-value store that holds cluster state. If the API Server is the front desk, etcd is the source of truth filing cabinet behind it.

Scheduler

The Scheduler watches for pods that do not yet have a node. It chooses the best node based on resources, rules, taints, affinity, and other constraints.

Controller Manager

The Controller Manager runs control loops. These loops compare actual state to desired state and take action. For example, if a Deployment wants 3 pods and only 2 exist, a controller creates another one.

Cloud Controller Manager

The Cloud Controller Manager integrates Kubernetes with cloud providers. It handles things like cloud load balancers, routes, and node metadata.

Worker Node Components

Worker nodes run the workloads.

kubelet

The kubelet is the node agent. It watches for pods assigned to its node and makes sure the containers are running.

kube-proxy

kube-proxy helps implement Service networking. It programs networking rules so traffic can reach the right pods.

Container Runtime

The container runtime runs the containers. Common runtimes include containerd.

Control Plane vs Worker Node

How kubectl apply Flows Through the System

When you run kubectl apply -f deployment.yaml, several components collaborate.

Step-by-Step Explanation

1. kubectl sends a manifest to the API Server.
2. The API Server validates it and stores the desired state in etcd.
3. A controller notices a new workload needs pods.
4. The Scheduler picks a worker node.
5. The kubelet on that node pulls the image and starts containers through the runtime.
6. kube-proxy helps route traffic if a Service points to those pods.

Why Kubernetes Feels Autonomous

Kubernetes is always reconciling. That means it keeps checking whether reality matches what you declared.

Think of it like a thermostat. You set the temperature once, and the system keeps working to maintain it. You do not keep pressing a button every minute.

If a pod dies, the system notices. If replicas drop below the target, the controller creates more. That ongoing reconciliation is the heart of Kubernetes.

Troubleshooting Mindset

Knowing architecture helps you ask better questions:

• Request rejected? Check the API Server or manifest validation.
• Pod stuck Pending? Check the Scheduler decision path.
• Pod assigned but not starting? Check the kubelet and runtime.
• Service not routing? Check kube-proxy, selectors, and endpoints.