Kubernetes Control Plane and Nodes: Who Owns Each Reconciliation Step
Trace a workload from the Kubernetes API through controllers, scheduling, kubelet, and container runtime—and learn which component to inspect when it stalls.
On this page

A Deployment can be accepted by the API and still have no running containers. That is not a contradiction: API acceptance, scheduling, node setup, image pulling, and application readiness are separate steps with different owners and failure signals.
The API server is the cluster interface
A kubectl apply request reaches the Kubernetes API server. The server authenticates and authorizes the request, applies admission and validation rules, and persists accepted API objects. The Kubernetes architecture documentation describes the API server as the control plane’s front end and notes that it is designed to scale horizontally. [1]
For a Deployment, the stored object expresses desired state, such as a replica count and a Pod template. It does not mean those Pods already exist, that a node has capacity, or that the application is healthy. The control plane records and exposes state so other components can act on it.
etcd is the default Kubernetes backing store in many clusters and holds cluster data. The architecture is configurable, and operational backup and recovery remain important. Avoid saying “etcd is the only stateful component”: it is the backing store, while API servers, controllers, admission webhooks, cloud integrations, and add-ons can themselves maintain caches, local state, or external state. The Kubernetes API remains the supported interface for managing cluster objects. [1] [3]
Controllers reconcile declared state
A controller repeatedly observes relevant API objects and compares them with the desired outcome. A Deployment controller can create or update a ReplicaSet; a ReplicaSet controller works to keep the intended number of Pod objects. These are independent control loops, not a single global reconciliation thread. The controller manager packages several controllers, and the exact controllers depend on the cluster and enabled integrations. [1]
A controller does not usually execute a container on a node itself. It creates or updates API objects that cause other components to act. This is why a missing ReplicaSet and a Pod stuck without placement point to different stages. Use kubectl get and kubectl describe to follow the object chain and inspect events, conditions, and owner references.
The scheduler assigns a node
The scheduler watches for Pods that have not been bound to a node. It evaluates resource requests, constraints, affinity, taints and tolerations, data locality, and other policy before choosing a node. It records the assignment through the API; it does not download images or launch containers. [1]
If a Pod remains Pending, the phrase alone does not identify the cause. Check whether it has a node assignment, then read scheduler events. Insufficient requested CPU or memory, an unmatched node selector, an unbound volume claim, or a policy constraint can prevent placement. A Pod may also remain pending while the chosen node downloads an image or initializes storage. The next troubleshooting step depends on which substage is waiting.
The kubelet owns node-local execution
Every node runs a kubelet, which watches Pod specifications assigned to that node and works to keep the described containers running. The kubelet asks the configured container runtime to create containers through the Container Runtime Interface. Kubernetes documentation lists runtimes such as containerd and CRI-O; Kubernetes does not itself implement the low-level container runtime. [1] [2]
A kubelet may be healthy while a workload is not ready. Image pull failures, missing secrets, volume setup, sandbox creation, startup probes, and application errors appear at different points in the local lifecycle. For how those states progress and how termination works, see our Pod lifecycle guide.
Service networking has more than one implementation
kube-proxy traditionally programs node-level network rules to implement part of Service behavior. It is not mandatory in every cluster: Kubernetes docs say a network plugin that provides equivalent service proxying can replace it. The Container Network Interface plugin also provides Pod networking, including IP allocation and connectivity. Do not assume every cluster uses the same packet-filtering technology or has a kube-proxy process to inspect. [1]
This variation matters when debugging. A Service that has no usable endpoints points toward selector or readiness state; endpoints that exist but are unreachable may involve the network plugin, node rules, policy, or an external load balancer. Inspect the implementation your cluster actually runs instead of assuming kube-proxy is responsible for all traffic routing.
Component placement varies
The control plane is a logical responsibility, not necessarily one fixed machine. Kubernetes allows different deployment models. Small or development clusters may colocate control plane and workloads; larger production clusters often separate them. Managed Kubernetes services may operate the control plane for users. Some network plugins replace kube-proxy. [1]
The control plane-to-node communication model also has security implications. Kubernetes documents several communication paths and the direction in which connections are initiated. The precise network controls depend on installation and provider, so a generic diagram should not be treated as a firewall specification. [4]
Debug by following ownership
When a workload fails to appear, trace this sequence:
- API request: Was the object accepted? Check the API error, admission response, and stored object.
- Controller output: Did the Deployment create a ReplicaSet and Pod objects? Inspect owner references and controller events.
- Scheduling: Does the Pod have a node? If not, read scheduler events and placement constraints.
- Node setup: If assigned, inspect kubelet events, runtime status, image access, volumes, and sandbox setup.
- Application readiness: Once running, inspect startup, liveness, and readiness probes separately.
- Service path: Confirm labels, EndpointSlices, network policy, and the cluster’s actual service-proxy implementation.
The most useful operational model is a chain of responsibilities. Kubernetes makes declared state observable and gives specialized controllers and node agents a way to converge toward it. The chain is powerful precisely because each component has a bounded role; diagnosis gets faster when the observed failure is mapped to the component that owns the next step.
Frequently asked questions
What is the difference between the Kubernetes control plane and a node?
The control plane exposes and manages the cluster API, schedules workloads, and runs controllers that respond to changes. Nodes host Pods and run local components such as kubelet and a container runtime. Actual component placement varies by cluster setup.
Does the scheduler start containers?
No. The scheduler selects a suitable node for a Pod that has not been assigned one. The kubelet on that node works with the container runtime to set up and run the Pod.
Is kube-proxy required on every Kubernetes node?
No. kube-proxy implements part of Kubernetes Service behavior, but a network plugin can provide equivalent service proxying and remove the need to run kube-proxy.



/* Comments */
Comments are offline right now — we reconnect automatically, nothing is lost.