Master Kubernetes Architecture: Core Components and How They Work Together

What Is Kubernetes?

Kubernetes (often abbreviated as K8s) is an open‑source container orchestration platform originally developed by Google and released in 2014. It automates the deployment, scaling, and management of containerized applications, providing a powerful platform for handling large‑scale container clusters.

Kubernetes Architecture

Kubernetes follows a master‑worker distributed architecture. The control plane (master) consists of several components that manage the desired state of the cluster, while worker nodes run the actual workloads.

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

Control Plane Components

The control plane includes the API Server, Scheduler, Controller Manager, and etcd.

API Server is the central entry point for all cluster operations, exposing a RESTful API used by kubectl, UI tools, and controllers. It handles authentication, authorization, admission control, and data validation.

Scheduler assigns Pods to suitable Nodes. Its scheduling process consists of three steps:

Filtering – discard nodes that lack sufficient resources or do not meet constraints.

Scoring – rank remaining nodes using priority functions.

Binding – bind the Pod to the selected Node.

Controller Manager runs a set of controllers that continuously monitor the cluster state and act to achieve the desired state. It includes controllers such as:

ReplicaSetController – manages replica sets.

NodeController – detects node failures.

JobController, DaemonSetController, etc. kube-controller-manager is the binary that implements this component.

etcd is a distributed key‑value store that holds the entire cluster state. It supports high availability through multiple replicas and uses the Raft consensus algorithm to ensure consistency.

Worker Node Components

Each worker node runs the following agents:

kubelet – an agent that ensures Pods run as defined, managing container lifecycles on the node.

kube-proxy – implements Service load balancing and network proxying by maintaining network rules that forward traffic to the appropriate Pods.

Container Runtime – the software that actually runs containers, such as Docker or containerd.

Kubernetes Workflow

The overall workflow proceeds as follows:

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

The API Server stores the desired cluster state in etcd.

The Controller Manager watches the state and takes actions to reconcile the actual state with the desired state.

The Scheduler selects an appropriate Node for each Pod.

Kubelet on the chosen Node creates and manages the Pod and its containers.

kube-proxy sets up network rules to provide Service load balancing.

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