Kubernetes Architecture

This article provides a concise, practical overview of core Kubernetes concepts and architecture. It’s ideal if you want a fast refresher or an SEO-friendly primer before diving into hands-on labs or certification courses. Kubernetes (k8s) is a container orchestration platform that manages containerized applications at scale. Unlike running a single container with Docker, Kubernetes lets you run, scale, update, and self-heal many instances across a cluster of machines.

From Docker to Kubernetes: a quick comparison

With Docker you can run a single container:

docker run my-web-server

Kubernetes lets you run many instances (replicas) and manage them centrally using Deployments, Services, and other primitives. Example: creating and scaling a Deployment

# Create a deployment for the web server
kubectl create deployment my-web-server --image=my-web-server

# Scale the deployment to 2000 replicas
kubectl scale deployment my-web-server --replicas=2000

# Create a deployment with a specified number of replicas
kubectl create deployment my-web-server --image=my-web-server --replicas=1000

Autoscaling based on resource usage:

kubectl autoscale deployment my-web-server --min=1 --max=2000 --cpu-percent=80

Horizontal Pod Autoscaling (HPA) requires metrics to be available. Install a metrics provider like metrics-server or another monitoring backend for CPU/memory-based autoscaling to work.

Kubernetes supports rolling updates and rollbacks, so you can update images safely and revert if needed:

# Update the image of the deployment (triggers a rolling update)
kubectl set image deployment/my-web-server my-web-server=web-server:2

# Check rollout status
kubectl rollout status deployment/my-web-server

# Roll back to the previous revision if something goes wrong
kubectl rollout undo deployment/my-web-server

Advanced release strategies (canary, blue/green, A/B testing) are supported via deployment patterns and tools built on top of Kubernetes. K8s also integrates with many networking and storage plugins, and supports multiple authentication and authorization mechanisms. Major cloud providers offer managed Kubernetes services.

Container runtimes and dockershim deprecation

Kubernetes orchestrates containers on nodes using a container runtime. Historically, Docker Engine was frequently used via the dockershim integration, but Kubernetes has removed dockershim in recent releases. Common runtimes now include containerd and CRI-O. Docker-formatted images remain fully supported.

Cluster basics: nodes and clusters

A node is a physical or virtual machine that runs the Kubernetes node components and your containers. Running multiple nodes increases availability — if one node fails, workloads can be rescheduled to other nodes.

A presentation slide titled "Nodes (Minions)" showing a red node box with two container icons and a Kubernetes wheel icon, while a presenter stands to the right. The dark background includes a faint whale/container graphic and a server icon.

A cluster is a group of nodes managed together so workloads remain available even if individual nodes fail. Who manages the cluster? The control plane.

Control plane (formerly “master”): what it runs

The control plane is responsible for maintaining cluster state and orchestrating workloads across worker nodes. When you install Kubernetes, you install a set of components including the API server, etcd, controller manager, scheduler, kubelets, and a container runtime.

A presenter stands on the right while a slide titled "Components" shows purple hexagons labeled API Server, etcd, kubelet, Scheduler, Controller, and Container Runtime arranged in a ring. A blue set of device icons on the left is connected by a dotted arrow to the API Server.

Key control plane and node components

Component	Role	Notes / Examples
`API Server`	Front-end for the cluster — exposes the Kubernetes API	All kubectl and controller requests go here
`etcd`	Distributed key-value store for cluster state	Provides strong consistency; replicates data across control plane nodes
`Scheduler`	Places pods on suitable nodes based on resources and policies	Evaluates resource requests, affinities, taints/tolerations
`Controller(s)`	Reconciliation loops that ensure desired state (replicas, endpoints, etc.)	Includes deployment controller, node controller, etc.
`kubelet`	Agent on each node that ensures containers described by the API Server are running	Talks to container runtime via CRI
`Container runtime`	Runs containers (containerd, CRI-O, etc.)	Docker Engine via dockershim is deprecated

kubectl: the command-line interface

kubectl is the main CLI to interact with the Kubernetes API. Use it to create, update, inspect, and delete resources. Common kubectl commands:

# Deploy an app (create a deployment)
kubectl create deployment hello-minikube --image=hello-minikube

# View cluster endpoints & services
kubectl cluster-info

# List all nodes in the cluster
kubectl get nodes

# Run a deployment with three replicas
kubectl create deployment my-web-app --image=my-web-app
kubectl scale deployment my-web-app --replicas=3

Tip: The behavior of kubectl run changed in recent versions. For creating and managing long-lived workloads, prefer kubectl create deployment or declarative workflows using kubectl apply -f <manifest.yaml>. Use kubectl run for quick, ad-hoc pods.

Quick reference: when to use these Kubernetes features

Deployments: manage stateless application releases and rolling updates.
StatefulSets: manage stateful workloads that require stable network IDs or storage.
DaemonSets: ensure a pod runs on all (or some) nodes.
Services: expose sets of pods as a network service (ClusterIP, NodePort, LoadBalancer).
ConfigMaps / Secrets: separate configuration and sensitive data from container images.
Horizontal Pod Autoscaler (HPA): scale replicas based on observed CPU/memory or custom metrics.

Further learning and references

Kubernetes official docs: https://kubernetes.io/docs/
Kubernetes Basics: https://kubernetes.io/docs/concepts/overview/what-is-kubernetes/

Courses mentioned:

That completes a compact overview of Kubernetes architecture and core concepts. If you want a deeper walkthrough (pods, services, networking, storage, manifests, RBAC, and cluster administration), consider following a structured course or the official docs for hands-on exercises.

Introduction

Docker Engine

Docker Image Management

Docker Engine - Security

Docker Engine - Networking

Docker Engine - Storage

Docker Compose

Docker Swarm

Kubernetes

Docker Engine Enterprise

Docker Trusted Registry

Disaster Recovery

Kubernetes Architecture

From Docker to Kubernetes: a quick comparison

Container runtimes and dockershim deprecation

Cluster basics: nodes and clusters

Control plane (formerly “master”): what it runs

kubectl: the command-line interface

Quick reference: when to use these Kubernetes features

Further learning and references

Watch Video

​From Docker to Kubernetes: a quick comparison

​Container runtimes and dockershim deprecation

​Cluster basics: nodes and clusters

​Control plane (formerly “master”): what it runs

​kubectl: the command-line interface

​Quick reference: when to use these Kubernetes features

​Further learning and references

Watch Video

From Docker to Kubernetes: a quick comparison

Container runtimes and dockershim deprecation

Cluster basics: nodes and clusters

Control plane (formerly “master”): what it runs

kubectl: the command-line interface

Quick reference: when to use these Kubernetes features

Further learning and references