Most engineers learn Kubernetes by memorizing commands.
The best engineers understand how the architecture works behind the scenes.
Once you understand the architecture, troubleshooting becomes significantly easier.
Let's dive in.
Why Kubernetes Exists
Imagine manually managing:
- Hundreds of servers
- Thousands of containers
- Constant deployments
- Hardware failures
- Traffic spikes
Without orchestration, managing this environment would be nearly impossible.
Kubernetes automates these tasks.
High-Level Architecture
A Kubernetes cluster consists of:
✅ Control Plane
✅ Worker Nodes
The Control Plane manages the cluster.
The Worker Nodes run applications.
Control Plane Components
API Server
The API Server acts as the gateway to the cluster.
Every action performed through:
kubectl get pods
kubectl apply -f deployment.yaml
kubectl delete pod nginx
ultimately communicates with the API Server.
ETCD
ETCD is the distributed key-value database of Kubernetes.
It stores:
- Pods
- Deployments
- Services
- ConfigMaps
- Secrets
- Cluster configuration
Think of ETCD as the single source of truth.
Without ETCD, Kubernetes loses its memory.
Scheduler
The Scheduler decides:
"Which worker node should run this pod?"
It evaluates:
- Available CPU
- Available Memory
- Affinity rules
- Taints and Tolerations
- Resource constraints
Controller Manager
Controllers continuously monitor cluster health.
Examples:
- ReplicaSet Controller
- Node Controller
- Deployment Controller
If something drifts from the desired state, controllers correct it.
Cloud Controller Manager
Used in cloud environments such as AWS.
Responsible for:
- Load Balancers
- Node lifecycle management
- Cloud networking integration
Worker Node Components
Kubelet
The primary node agent.
Responsibilities:
- Receives instructions
- Creates pods
- Monitors pod health
Container Runtime
Runs containers.
Examples:
- containerd
- CRI-O
Docker support now works through container runtimes rather than directly.
Kube Proxy
Responsible for service networking.
Provides:
- Service discovery
- Traffic routing
- Load balancing
Pods
The smallest deployable unit in Kubernetes.
Applications ultimately run inside Pods.
What Happens During Deployment?
When a Deployment YAML is applied:
- API Server receives request
- ETCD stores desired state
- Scheduler chooses node
- Kubelet creates pod
- Container runtime starts containers
- Kube Proxy enables networking
- Application becomes available
The Core Kubernetes Philosophy
Desired State Management.
You declare:
"I want 3 replicas."
Kubernetes continuously ensures:
"I have 3 replicas."
If one replica disappears, Kubernetes creates another automatically.
This self-healing behavior is one of Kubernetes' most powerful features.
Real-World Relevance
Understanding Kubernetes Architecture is critical for:
- CKA Certification
- DevOps Engineering
- Site Reliability Engineering
- Platform Engineering
- Cloud Engineering
- AWS EKS Administration
Without architectural knowledge, troubleshooting production incidents becomes extremely difficult.
Challenge Question
Suppose:
- API Server is healthy
- Worker Nodes are healthy
- ETCD is unavailable
Can new Pods be scheduled?
Why or why not?
Drop your answer below 👇