DevOps Shack

Master and Worker Node Components in Kubernetes:

Functionalities, Implementation, and Architecture
In a Kubernetes cluster, nodes are the fundamental units responsible for
running containerized applications. A cluster typically consists of master nodes,
responsible for managing the cluster, and worker nodes, responsible for
running the actual applications. Understanding the components of both master
and worker nodes is essential to effectively manage, troubleshoot, and
optimize a Kubernetes environment.
 1. Why We Use This Architecture
Kubernetes uses a master-worker architecture to efficiently manage and
orchestrate containerized applications at scale. The master node controls and
monitors the state of the cluster, while worker nodes run the workloads. This
separation allows for:
• Scalability: The worker nodes handle the scaling of applications without
burdening the control processes.
• Reliability: Even if some worker nodes fail, the master can quickly
reschedule workloads on healthy nodes, ensuring minimal downtime.
• Flexibility: The architecture supports a wide range of workloads,
whether they are stateless applications or stateful services.
• Resource Efficiency: By separating management and workload tasks,
resources are more efficiently allocated, leading to better overall
performance.
This architecture ensures that Kubernetes can operate in dynamic
environments, providing a high level of automation, scalability, and resilience,
essential for modern microservices and container-based applications.

2. Master Node Components and Their Functionalities

The master node orchestrates the overall management of the cluster. It
handles scheduling, monitoring, and configuration. The key components of a
master node are:
• API Server (kube-apiserver):
The API server is the front-end interface for the Kubernetes control
plane. It exposes the Kubernetes API, and all administrative commands
are sent via RESTful requests. It manages the state of the cluster and
validates and configures data for the API objects.
Implementation:
The API server receives requests (via kubectl or other clients), processes them,
and then updates the cluster's state. Example command:
kubectl get nodes
 • Controller Manager (kube-controller-manager):
This component is responsible for running several controllers that
regulate the cluster's state, such as:
o Node Controller: Monitors the health of nodes.
o Replication Controller: Ensures that the desired number of pod
replicas are running.
Implementation:
Controllers track resources continuously and ensure they align with the
declared state in the manifest files.
• Scheduler (kube-scheduler):
The scheduler determines on which node a pod should be scheduled. It
takes into account resource availability and constraints such as CPU,
memory, and affinity/anti-affinity rules.
Implementation:
Example of defining constraints for a pod:
apiVersion: v1
kind: Pod
metadata:
name: example-pod
spec:
containers:
- name: example-container
image: nginx
nodeSelector:
disktype: ssd
• Etcd:
Etcd is a consistent, distributed key-value store that stores all the data
for the Kubernetes cluster, including information about the current state
of the cluster, secrets, and configuration data.
Implementation:
Every change made in the cluster is stored in etcd, ensuring consistency across
the entire cluster. Example:
etcdctl get / --prefix --keys-only

3. Worker Node Components and Their Functionalities

Worker nodes are where the actual workloads are run in containers. The
worker node components ensure that the necessary pods are created and
running properly. Key components of the worker nodes include:
• Kubelet:
Kubelet is the agent that runs on each worker node. It ensures that the
containers described in PodSpecs are running and healthy. It interacts
with the API server to retrieve and execute workloads.
Implementation:
Kubelet uses the pod definition to launch and monitor containers.
kubectl apply -f pod-definition.yaml
• Kube-Proxy:
Kube-proxy handles network routing and ensures that the services in the
cluster are accessible both internally and externally. It configures the
necessary IP tables and manages the networking rules.
Implementation:
Kube-proxy routes traffic from outside the cluster to the correct pods.
kubectl expose pod nginx --type=NodePort --port=80
• Container Runtime (Docker, containerd, CRI-O):
The container runtime is responsible for pulling container images,
starting containers, and managing their lifecycle.
Implementation:
You can use Docker to run a container directly:
docker run -d nginx
5. Advantages of Kubernetes Master-Worker Architecture
• High Availability:
The separation of the master and worker nodes allows Kubernetes to
handle failures gracefully. If a node fails, the master reschedules the
workload on a healthy node.
• Scalability:
Kubernetes can scale easily by adding more worker nodes to the cluster,
distributing the workload across multiple nodes and ensuring efficient
resource usage.
• Automation:
Built-in controllers in the master node automate various tasks like
monitoring the health of nodes, ensuring the desired number of replicas,
and scheduling pods according to resource requirements.
• Efficient Resource Utilization:
Kubernetes ensures that workloads are distributed efficiently based on
available resources, leading to optimal performance.
• Flexibility in Workload Management:
The architecture supports diverse workload types—whether it’s running
microservices, batch jobs, or databases, ensuring that workloads are
managed independently across nodes.
• Resilience:
The architecture provides fault tolerance by ensuring that the failure of a
single node does not impact the entire cluster.

6. Conclusion
Kubernetes separates concerns by placing management on master nodes and
application workloads on worker nodes. This architecture ensures that
Kubernetes clusters can scale easily, recover quickly from failures, and handle
dynamic workloads with high availability. Master node components manage
the cluster's state and ensure that workloads are scheduled correctly, while
worker nodes run the actual containerized applications, ensuring optimal
resource usage and scalability.