Kubernetes Architecture for Beginners | Cluster Master | Node

Understanding Kubernetes’ architecture is critical for harnessing its full potential to deploy and manage containerized applications. Kubernetes organizes its architecture around clusters, with Master and Node components working together to efficiently deploy and manage workloads. This guide breaks down Kubernetes’ key architectural components like kubelet, kube-proxy, and the API server, how scheduling decisions are made, and the deployment lifecycle of applications.

If you’re new to Kubernetes, this beginner-friendly guide will serve as a foundational introduction.

Table of Contents

1. Cluster, Master, and Node Overview
2. Kubernetes Components: kubelet, kube-proxy, API server
3. How Scheduling Works
4. Deployment Cycle
5. External Resources for Further Learning
6. Final Thoughts

---

Cluster, Master, and Node Overview

Kubernetes is a distributed system that organizes resources into clusters, allowing users to run and scale applications seamlessly. Understanding clustering is key to grasping its architecture.

Cluster

The cluster is the top-level abstraction in Kubernetes. It consists of two main types of components:

1. Control Plane (Master components): Manages the overall state, operations, and communication within the cluster.
2. Nodes (Worker machines): Execute workloads (applications) as scheduled by the Control Plane.

Master

The Master Node (Control Plane) governs the cluster and ensures the desired state of the system is met. It handles key operational tasks like scheduling workloads, monitoring their health, and scaling them. The Master Node includes crucial components (e.g., API server, etcd, scheduler).

• Key Responsibilities:
  • Handle incoming API requests.
  • Decide which nodes execute specific workloads.
  • Maintain system state in a consistent manner.

Node

Nodes (sometimes called Worker Nodes) represent the machines where Kubernetes workloads are executed. A node can run on a physical server, virtual machine, or cloud instance.

• Key Responsibilities:
  • Hosting Pods (the smallest deployable unit in Kubernetes).
  • Managing the runtime environment for the containers (e.g., using Docker).
  • Reporting to the Master about health and resource usage.

Each node runs important components like the kubelet and kube-proxy, which interact with the Control Plane to ensure applications run properly.

Analogy: Think of the cluster as a factory, the Master Node as the supervisor, and the Worker Nodes as machines operating under the supervisor’s instructions.

---

Kubernetes Components: kubelet, kube-proxy, API Server

Kubernetes’ core functionality relies on the seamless operation of its key components. Below is an overview of some of the most important ones:

1. API Server

The API server is the front-facing interface of the cluster. It enables communication between users (e.g., via kubectl or dashboards) and the Kubernetes system.

• Responsibilities:
  • Processes RESTful API calls (e.g., to deploy applications).
  • Acts as the central management entity for all cluster interactions.
  • Validates and processes updates requested by users or automation tools.
• Sample API Call: kubectl get pods This command interacts with the API server, which retrieves the current state of Pods in the cluster.

2. kube-proxy

The kube-proxy is a network component that runs on every node. It manages networking for Kubernetes services, ensuring they can communicate internally or externally.

• Responsibilities:
  • Implements network proxy rules to route traffic to correct Pods.
  • Configures IP tables to handle connections between workloads.
  • Facilitates the exposure of services via Service objects.

Example:
When a request reaches the exposed Kubernetes Service, the kube-proxy forwards it to one of the Pod instances.

3. kubelet

The kubelet is a core agent that runs on all nodes. It ensures the Node is operating as instructed by the Control Plane.

• Responsibilities:
  • Monitors containers running on the node.
  • Ensures Pods are functioning as expected based on the PodSpec (Pod Specification).
  • Communicates with the Master Node to report resource usage and health status.
• Example Workflow:
  If a Pod crashes, the kubelet attempts to restart it automatically.

Other Notable Components

• etcd: A distributed key-value store that houses all cluster data such as configuration, resource states, and secrets.
• Controller Manager: Ensures all cluster components are functioning as desired by reconciling the actual state with the desired state.

---

How Scheduling Works

The Role of the Scheduler

The Kubernetes Scheduler, part of the Master Node, is responsible for assigning Pods to nodes. It considers several factors to select the most appropriate node for each workload, ensuring balance and efficiency.

Scheduling Process Overview

1. Pod Spec Submission: A Pod definition is submitted through the API server.
   Example YAML snippet: apiVersion: v1 kind: Pod metadata: name: sample-pod spec: containers: - name: sample-container image: nginx
2. Node Evaluation: The Scheduler evaluates all available nodes against a set of criteria:
   • Resource availability (e.g., CPU, memory).
   • Affinity/Anti-affinity rules.
   • Node taints/tolerations (e.g., restrictions on which Pods can run).
   • Custom scheduling policies.
3. Node Assignment: The Scheduler selects the Node that best matches the criteria and assigns the Pod to it.
4. Execution by kubelet: The kubelet on the assigned Node pulls the required container images, creates the containers, and launches the Pod.

Importance of Scheduling Policies

• Fair Resource Distribution: Prevents overloading certain nodes.
• Application-Specific Needs: Ensures applications run on nodes optimized for their workloads.

---

Deployment Cycle

Deploying applications in Kubernetes follows a structured lifecycle that ensures stability, scalability, and maintainability.

Deployment Phases

1. Writing the Deployment Manifest Define how the workload should operate in a YAML file: apiVersion: apps/v1 kind: Deployment metadata: name: example-deployment spec: replicas: 3 selector: matchLabels: app: nginx template: metadata: labels: app: nginx spec: containers: - name: nginx-container image: nginx ports: - containerPort: 80
2. Submitting the Manifest Use the kubectl command to apply the deployment: kubectl apply -f example-deployment.yaml
3. Pod Creation and Scheduling
   • The Deployment Controller ensures the desired number of Pods (replicas) are created.
   • The Scheduler assigns these Pods to available Nodes.
4. Rolling Updates Kubernetes supports continuous deployment with rolling updates, replacing old instances with new ones while ensuring no downtime: kubectl set image deployment/example-deployment nginx=nginx:v2
5. Monitoring and Scaling Use Horizontal Pod Autoscalers (HPAs) to manage scaling based on metrics like CPU or request load: kubectl autoscale deployment example-deployment --cpu-percent=50 --min=2 --max=10

Observing Deployment Status

Run kubectl commands to monitor the cluster:

kubectl get deployments
kubectl get pods
kubectl describe pod <pod-name>

---

External Resources for Further Learning

• Kubernetes Official Documentation
• Understanding Kubernetes Scheduler
• etcd on GitHub
• Wikipedia on Orchestrators

---

Final Thoughts

Kubernetes architecture revolves around the interaction between Clusters, Nodes, and Master components. By understanding its building blocks like kubelets, kube-proxies, and the API server, alongside concepts such as scheduling and deployment cycles, you can unlock Kubernetes’ full potential for building scalable and fault-tolerant applications.

Use this guide as a stepping stone to mastering Kubernetes and bookmark it for quick reference when deploying applications!