Kubernetes Architecture Crash Course

TechOps Examples

Hey — It's Govardhana MK 👋

Along with a use case deep dive, we identify the remote job opportunities, top news, tools, and articles in the TechOps industry.

Before we begin... a big thank you to today's sponsor.

  • VMs. Kubernetes. PaaS. You can DO anything.

  • Try DIGITAL OCEAN — Free $200 credit.

  • Simple, scalable, affordable cloud computing - Always know what you'll pay with monthly caps and flat pricing.

IN TODAY'S EDITION

🧠 Use Case
  • Kubernetes Architecture Crash Course

🚀 Top News

👀 Remote Jobs

📚️ Resources

📢 Reddit Threads

🛠️ TOOL OF THE DAY

PerfectScale -  The only automated K8s optimization and management platform that aligns with real-world needs of DevOps, SREs, and Platform Engineers.

  • Meet demand with 99.99% K8s availability – No code changes needed.

  • Cut Kubernetes costs by up to 50% – By right-sizing workloads, streamlining autoscaling, and maximizing node capacity.

🧠 USE CASE

Kubernetes Architecture Crash Course

Kubernetes, often called K8s (short for "Kubernetes," with "8" representing the eight letters between "K" and "s"), started its journey at Google.

It was born from Google's internal system called Borg, which handled massive-scale workloads way before "cloud-native" was even a term.

In 2014, Google decided to open-source this powerful idea, and it became Kubernetes.

10 years ago, on June 6th, 2014, the first commit of Kubernetes was pushed to GitHub.

The Cloud Native Computing Foundation (CNCF) adopted it early on, turning Kubernetes into the poster child of cloud-native computing. Explore the 10-year timeline.

Let’s now get hands-on and break down the architecture, making sense of the key components with the attached diagram.

Kubernetes Architecture Illustration

The Control Plane Node: The Brain 🧠

This is where the decision-making happens. Every Kubernetes cluster has one or more control plane nodes that oversee everything in the cluster.

Here's how it all fits together:

API Server (api):
Think of it as the front desk of Kubernetes. Every kubectl command or internal component interaction goes through the API server. It validates your requests and routes them to the right place.

Controller Manager (c-m):
The automation genius. If your app's desired state (like 3 replicas) doesn’t match reality, the controller manager steps in to create, delete, or update resources.

Scheduler (sched):
New pod? Cool. The scheduler finds the best worker node for it, considering factors like resources, affinity, and taints. It's all about optimal placement.

etcd:
The brain's memory. This is a highly consistent key-value store that keeps track of everything in the cluster. If etcd is down, Kubernetes forgets the cluster's state.

kubelet on Control Plane:
Just like on worker nodes, the kubelet on the control plane ensures containers running here are healthy and up-to-date.

Worker Node: The Muscles 💪

While the control plane is busy planning and deciding, the worker nodes do the actual work.

Here's what happens under the hood:

kubelet:
The node's manager. It takes orders from the API server and ensures that containers (running inside pods) are healthy and doing what they're supposed to. It’s like the node's personal assistant.

Kube-proxy (k-proxy):
Handles networking. It ensures every pod can talk to other pods and services inside (and sometimes outside) the cluster. It uses iptables or similar tools to manage network rules.

Container Runtime:
This is what runs the actual containers. Whether it’s Docker, containerd, or CRI-O, it’s all about keeping your apps alive and isolated.

Pods and Containers:
Pods are the smallest deployable units in Kubernetes. Each pod wraps one or more containers and shares networking and storage. The containers inside do the heavy lifting—running your application code.

Putting It All Together

🧠 The control plane makes the rules, stores the cluster's state, and sends commands.

💪 The worker nodes execute these commands, run your applications, and handle network requests.

It’s a perfect balance of brains and brawn, ensuring that your apps are highly available, scalable, and self-healing.

Want to explore more? Run these commands on your Kubernetes cluster and see the magic live:

# Check control plane components
kubectl get pods -n kube-system

# Check worker node details
kubectl describe node <worker-node-name>

You may even like:

Looking to promote your company, product, service, or event to 30,000+ TechOps Professionals? Let's work together.