Kubernetes Architecture

Slide 1 / 10

From VM Problems to Kubernetes

Start with the problem, then see how Kubernetes solves it.

Format Problem -> Solution -> Lab

A simple flow from challenge to architecture to hands-on practice.

Problem VM Limits

Why managing containers on many VMs becomes hard.

Resolution Kubernetes

How orchestration solves scale, recovery, and networking.

Outcome Clarity

Understand how the cluster works end to end.

Agenda

Slide 2 / 10

1-Hour Session Flow

OpeningStart with the limitations of running containers across virtual-machine-based environments.

ResolutionExplain why Kubernetes is introduced and what orchestration fixes.

ArchitectureBreak the solution into control plane, worker nodes, and pods.

Control PlaneExplain the API server, etcd, scheduler, and controller manager.

Worker NodesCover kubelet, kube-proxy, container runtime, and node responsibilities.

Control FlowWalk through how desired state becomes running pods.

LabInstall tools, inspect a local cluster, and deploy nginx with minikube.

RecapEnd with a concise summary of the Kubernetes architecture model.

Problem First

Slide 3 / 10

Problems When Running Containers Across Many Virtual Machines

Common problems

Each virtual machine needs its own operating system, so it uses extra CPU, memory, and storage.
As the number of VMs grows, managing them becomes slow and difficult.
If a container crashes, someone often has to restart or replace it manually.
Connecting containers across many machines becomes harder to manage.
Scaling an application up or down usually takes manual work.

What teams start needing

A way to place containers automatically on available machines.
A way to restart failed containers without manual effort.
A simple way for applications to find and talk to each other.
A reliable way to scale applications when traffic changes.
One system to manage everything instead of handling each machine separately.

Resolution

Slide 4 / 10

How Kubernetes Resolves the Problem

Centralized control

Kubernetes gives you one API and one control model for scheduling, scaling, recovery, rollout, and service exposure across the cluster.

Automated operations

Instead of managing containers host by host, Kubernetes continuously places workloads, replaces failures, and routes traffic automatically.

Declarative model

You declare what should run, and Kubernetes works to make the actual cluster state match that desired state.

What Kubernetes adds

Self-healing, horizontal scaling, rolling updates, service discovery, and load balancing become built-in platform capabilities.

Why architecture matters

These features are possible because the cluster has a control plane, worker nodes, persistent state, and continuous reconciliation loops.

Control Plane

Slide 5 / 10

Control Plane Components

kube-apiserver This is the main entry point of Kubernetes. When you run kubectl, the request comes here first.

etcd This stores all important cluster data. You can think of it as Kubernetes memory.

kube-scheduler This decides which node should run a new pod.

kube-controller-manager This checks if the cluster matches what you asked for, and fixes things when it does not.

Simple view: API server receives requests, etcd stores data, scheduler picks a node, and controllers keep everything in the correct state.

Node Plane

Slide 6 / 10

Node Plane Components

kubelet This is the agent running on each node. It makes sure the pod is started and kept running.

kube-proxy This helps manage networking so traffic can reach the correct pods.

Container runtime This is the software that actually runs the containers, such as containerd.

Node itself This is the worker machine that provides CPU, memory, storage, and network for the pods.

Easy way to remember it

The control plane makes decisions. The node plane does the actual work of running the application.

Reconciliation Flow

Slide 7 / 10

How Kubernetes Turns YAML Into Running Pods

1

User declares desired state.
A manifest or kubectl command defines what should exist.

2

API server accepts the request.
The request is validated and the object is persisted.

3

etcd stores the state.
Now the desired cluster state is recorded in the system of record.

4

Scheduler and controllers react.
One selects a node, the others keep checking and correcting drift.

5

kubelet and runtime act on the node.
Containers start, health is monitored, and Kubernetes keeps reconciling.

Hands-On Lab

Slide 8 / 10

Install Minikube and kubectl

macOS

Install Homebrew if it is not already available.
Run brew install minikube kubectl.
Verify the tools with minikube version and kubectl version --client.
Make sure Docker Desktop or another supported driver is running before starting the cluster.

Windows

Install Chocolatey if your environment uses it, or download the Windows binaries from the official Minikube and kubectl documentation pages.
With Chocolatey, run choco install minikube kubernetes-cli -y in an elevated terminal.
Verify the tools with minikube version and kubectl version --client in PowerShell or Command Prompt.
Ensure Docker Desktop or another supported virtualization driver is installed and running before starting Minikube.

Lab Commands

Slide 9 / 10

Minikube Walkthrough

Cluster Setup and Inspection

# Verify tools
minikube version
kubectl version --client

# Start cluster
minikube start --driver=docker
minikube status

# Explore cluster
kubectl get nodes
kubectl get nodes -o wide
kubectl get pods -A
kubectl get pods -n kube-system
kubectl get all -n kube-system

# Inspect components
kubectl describe node minikube
kubectl get componentstatuses

Deploy and Test a Pod

# Deploy nginx
kubectl run my-nginx --image=nginx --port=80
kubectl get pods
kubectl describe pod my-nginx
kubectl logs my-nginx

# Access the pod
kubectl port-forward pod/my-nginx 8080:80
curl http://localhost:8080

# Clean up
kubectl delete pod my-nginx

Recap

Slide 10 / 10

Kubernetes Architecture in One View

Core Summary

The control plane receives requests, stores state, and decides what should happen.
Worker nodes run the actual workloads through kubelet, kube-proxy, and the container runtime.
Pods are the smallest deployable units and are scheduled onto nodes.
Kubernetes constantly reconciles actual state back to desired state.

Final Message

Desired state is declared, stored, scheduled, executed, and continuously reconciled. That sequence explains how Kubernetes works internally and why it is reliable at scale.