A Kubernetes cluster has two main parts: a control plane that manages the cluster and one or more worker nodes that run application Pods. The control plane accepts and stores the desired state, assigns Pods to nodes, and coordinates changes. On each node, the kubelet works with a container runtime to run the assigned Pods.
This is a logical map of responsibilities, not a fixed process layout. In a managed service, the provider may operate the control plane; in a small development cluster, components and workloads may share machines.
As an Amazon Associate I earn from qualifying purchases.
What are the components of a Kubernetes cluster?
The main components are grouped by their role: control-plane components make cluster-wide decisions, while node components provide the machinery that runs Pods. The Kubernetes cluster architecture documentation describes these responsibilities and deployment patterns.
Windows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallCrashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minute- Control plane: API server, etcd, scheduler, and controllers; cloud deployments may also use a cloud-controller-manager.
- Worker node: kubelet, a container runtime, and often kube-proxy; a network plugin provides Pod networking and may replace kube-proxy’s Service-forwarding role.
A Pod is Kubernetes’ unit for running one or more containers together. A Deployment, by contrast, is an object that declares desired application state, such as how many replicas should run; it is not itself a container.
#1 Best Overall
What does the control plane do?
The control plane is the cluster’s management layer. Its components coordinate through the Kubernetes API, with the API server serving as the front end for API requests and other control-plane interactions.
API server
The API server exposes the Kubernetes API. Users and automation submit requests to it, and components use it to read or change cluster objects. It is also the communication point for control-plane interactions with nodes.
etcd
etcd is the backing store for cluster data, including the state represented by Kubernetes API objects. It is persistent cluster state, not an ordinary cache; operating a self-managed control plane therefore requires a plan to protect and back up that data.
Scheduler
The scheduler watches for Pods that have not yet been assigned to a node and selects a suitable node. It considers factors such as resource requests, constraints, affinity, data locality, and deadlines. It makes the placement decision; the node’s kubelet is responsible for making the Pod run there.
Controllers and kube-controller-manager
Controllers are reconciliation loops: they watch API resources and move actual state toward declared desired state, often by requesting changes through the API server. The kube-controller-manager runs built-in controllers. For example, when a Job calls for work to be done, the Job controller requests Pod objects; it does not execute the Job’s containers. The scheduler and node components handle placement and execution. See the Kubernetes explanation of controllers.
Cloud-controller-manager
Some cloud deployments include a cloud-controller-manager for cloud-specific logic, such as interacting with provider APIs. It is not a required component of every cluster; on-premises or learning clusters may not use one.
Rank #3
What runs on each node?
A node is a physical or virtual machine managed by the control plane. It provides the services needed to run Pods.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
kubelet
The kubelet receives Pod specifications for its node and makes sure the Pod’s containers are running and healthy. It coordinates execution with the container runtime; it is not the runtime, and it does not manage containers that Kubernetes did not create. The Kubernetes node documentation describes the node’s role.
Container runtime
The container runtime manages container execution and lifecycle on the node. The kubelet communicates with it to carry out the Pod’s container requirements.
kube-proxy and network plugins
kube-proxy maintains node network rules used to implement part of the Kubernetes Service abstraction. It is optional in deployments where a network plugin provides equivalent Service forwarding. Network plugins also provide Pod networking, which is distinct from kube-proxy’s Service role. Service forwarding, Pod connectivity, DNS, and ingress are related parts of a cluster’s networking, but they are not interchangeable concepts.
How does Kubernetes decide where a Pod runs?
Consider a Deployment that requests several replicas of an application. The sequence below follows the normal control path; controllers keep reconciling state after initial placement, rather than acting only once.
Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Scan for outdated or missing drivers - takes under a minuteDriver Scan →- Submit desired state: A user or deployment tool sends the Deployment request to the API server, which exposes and validates the Kubernetes API.
- Record cluster data: Cluster state is held in etcd, the backing store for Kubernetes data.
- Create Pod objects: A controller observes that the requested replicas are not yet represented by the required Pods and requests Pod creation through the API server.
- Choose nodes: The scheduler sees Pods without an assigned node and selects suitable nodes based on resources and scheduling constraints.
- Run the containers: Each selected node’s kubelet works with the container runtime to make the Pod’s containers run.
- Reconcile changes: Controllers continue watching for differences between desired and actual state and request changes through the API when needed. This control-loop behavior is described in the Kubernetes controller documentation.
The Deployment describes the desired outcome; it does not directly start containers. Pod objects, scheduling, and node-level execution connect that declaration to running application processes.
Best Value
How do control-plane components and nodes communicate?
Kubernetes uses an API-centered, hub-and-spoke communication pattern: node and Pod API usage goes to the API server, and other control-plane components also communicate with it. The API server can connect to kubelets for operations such as fetching logs, attaching to a container, and port forwarding. The Kubernetes communication documentation describes these paths and security considerations, including certificate verification and SSH tunneling configurations for untrusted networks.
How does Kubernetes architecture vary by deployment?
The component diagram explains roles, but it does not prescribe one universal machine or process layout. The control plane may run on dedicated machines or virtual machines, as static Pods managed by kubelet, or in self-hosted arrangements. A managed Kubernetes service may operate the control plane on the user’s behalf, so its underlying processes may not be directly exposed to the cluster operator.
Small development clusters may colocate control-plane components and workloads. Production environments commonly separate them and spread control-plane components across machines for high availability. The appropriate arrangement depends on who operates the control plane, fault-tolerance needs, workload isolation, and network implementation. A network plugin may also provide Service forwarding that would otherwise be handled by kube-proxy.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
