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:

1. API Server receives request


2. ETCD stores desired state


3. Scheduler chooses node


4. Kubelet creates pod


5. Container runtime starts containers


6. Kube Proxy enables networking


7. 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 👇

kubernetes #cka #cloudnative #devops #sre #aws #eks #containers #docker #platformengineering #terraform #argocd #gitops #helm #prometheus #grafana #observability #linux #cloudcomputing #devsecops #opensource #siteReliabilityEngineering #cloudengineering #automation #infrastructureascode #learninginpublic