Kubernetes Architecture and Core Principles Explained

Kubernetes (K8s) is an open‑source container orchestration platform originally developed by Google and released in 2014. It automates deployment, scaling, and management of containerized applications across a cluster of machines.

K8s Architecture

K8s uses a master‑node distributed architecture. The control plane (master) consists of API Server, Scheduler, Controller Manager, and etcd, while each worker node runs kubelet, kube-proxy, and a container runtime.

The following ASCII diagram illustrates the component layout:

+--------------------+
+----------------+
|      API Server   |<------->|      etcd      |
+--------------------+
+----------------+
| Scheduler | ControllerManager |
+--------------------+
+--------------------------+
|      Worker Node        |
+--------------------------+
| kubelet | kube-proxy | CRI |
+--------------------------+
|      Pod (multiple containers)      |
+--------------------------+

Control Plane (Master)

Manages the overall cluster state and includes:

API Server – the central entry point for all cluster operations, exposing a REST API used by kubectl, UI, and controllers.

Scheduler – selects suitable nodes for Pods by filtering, scoring, and binding.

Controller Manager – runs various controllers (ReplicaSet, NodeController, JobController, DaemonSet, etc.) to ensure the desired state.

etcd – a distributed key‑value store that holds the entire cluster state with high availability via Raft.

Worker Node (Node)

Runs the actual workloads and includes:

kubelet – ensures Pods run as defined, monitors health, and reports status to the control plane.

kube-proxy – implements Service load‑balancing and network proxying.

Container Runtime – executes containers (Docker, containerd, etc.).

Key Component Details

API Server provides authentication, authorization, admission control, and data validation, serving as the gateway for all requests.

Scheduler performs three steps: filter out unsuitable nodes, score remaining nodes, and bind the Pod to the chosen node.

Controller Manager runs core controllers; for example, kube-controller-manager monitors cluster state and drives the system toward the desired state.

etcd stores all object states, ensuring consistency and reliability across the cluster.

Kubelet runs on each node, managing Pods and containers to match the declared specifications.

Kube‑proxy maintains network rules to forward traffic to the correct Pods, enabling Service load‑balancing.

K8s Workflow

User issues commands with kubectl , which communicate with the API Server.

API Server writes the desired state to etcd.

Controller Manager watches etcd and takes actions to reconcile the actual state.

Scheduler assigns Pods to appropriate nodes.

Kubelet on each node creates and manages the Pods and containers.

Kube‑proxy handles networking and load‑balancing for Services.

Through the coordinated operation of these components, Kubernetes enables automated deployment, scaling, and management of containerized applications.

Finally, the author offers additional resources such as a 300,000‑word architecture collection and a comprehensive Java interview guide, with links for interested readers.