07 — Kubernetes Architecture Overview

“To understand how to use Kubernetes effectively, you must first understand how it is built.”

📌 Table of Contents

• High-Level Architecture
• The Control Plane
  • API Server
  • etcd
  • Scheduler
  • Controller Manager
  • Cloud Controller Manager
• Worker Nodes
  • kubelet
  • kube-proxy
  • Container Runtime
• Add-ons
• Communication Flow
• kubectl — Your Interface to K8s
• Architecture Summary

High-Level Architecture

A Kubernetes cluster consists of two types of machines:

1. Control Plane (Master) — the brain that manages the cluster
2. Worker Nodes — the machines that run your application containers

The Control Plane

The Control Plane is the set of components that manage the overall state of the cluster. In production, the control plane is typically run on dedicated machines, separate from worker nodes.

1. API Server (kube-apiserver)

The API Server is the single entry point for all operations in the Kubernetes cluster. Every component communicates through it.

Key responsibilities:

• Exposes the Kubernetes API (REST + gRPC)
• Authenticates and authorises all requests (RBAC)
• Validates and stores objects in etcd
• Horizontally scalable (can run multiple API server instances)

2. etcd

etcd is a distributed, consistent key-value store that serves as Kubernetes’ backing store for all cluster state.

⚠️ If etcd data is lost, the entire cluster state is lost. In production, run etcd as a highly available cluster (3 or 5 nodes) and take regular backups.

3. Scheduler (kube-scheduler)

The Scheduler decides which node a newly created pod should run on.

Scheduling Constraints You Can Set

4. Controller Manager (kube-controller-manager)

The Controller Manager runs a collection of control loops that watch the cluster state and make changes to move it toward the desired state.

The Control Loop Pattern

5. Cloud Controller Manager

Manages cloud-provider-specific integrations — creating load balancers, volumes, and handling node lifecycle with the cloud API.

Worker Nodes

Worker Nodes (also called data-plane nodes) are the machines where your application containers actually run. Each node runs three key components:

1. kubelet

The kubelet is the primary node agent running on every worker node. It is responsible for everything on its node.

Key facts about kubelet:

• Registers the node with the API Server
• Does NOT manage containers not created by Kubernetes
• Runs as a system daemon (not as a pod)

2. kube-proxy

kube-proxy runs on every node and maintains network rules (iptables / IPVS) that enable the Kubernetes Service abstraction.

3. Container Runtime

The Container Runtime is the software that actually runs containers on the node. Kubernetes uses the Container Runtime Interface (CRI) to support multiple runtimes.

Add-ons

Add-ons extend the functionality of Kubernetes. Some are essential (like DNS), others are optional.

Communication Flow

How a kubectl apply Actually Works

kubectl — Your Interface to Kubernetes

kubectl is the command-line tool that allows you to interact with the Kubernetes cluster via the API Server.

# Cluster information
kubectl cluster-info
kubectl get nodes

# Working with pods
kubectl get pods
kubectl get pods -n kube-system          # System pods
kubectl describe pod <pod-name>
kubectl logs <pod-name>
kubectl exec -it <pod-name> -- /bin/sh

# Deploying applications
kubectl apply -f deployment.yaml
kubectl delete -f deployment.yaml

# Scaling
kubectl scale deployment my-app --replicas=5

# Rolling update
kubectl set image deployment/my-app my-app=myimage:v2.0
kubectl rollout status deployment/my-app
kubectl rollout undo deployment/my-app

Architecture Summary

Component Quick Reference

🔗 Further Reading

• Kubernetes Components — Official Docs
• etcd Documentation
• kube-scheduler Design
• Kubernetes Architecture Explained (Video)

← Previous: 06 - Kubernetes Features

🎉 Congratulations! You’ve completed Module 1 — Introduction to Kubernetes. You now understand what Kubernetes is, why it exists, and how it is architecturally structured. In the next module, we’ll set up a local Kubernetes cluster and deploy your first application!