This is not a slideshow about Kubernetes. You'll follow one realistic production cluster — two applications, two deployment styles, a CI/CD pipeline, monitoring and autoscaling — through animated diagrams, real command output you learn to read, interactive simulators, and a war-story incident you get to solve. By the end you can walk into a K8s interview, or a K8s on-call rotation, and know what you're looking at.
All examples follow QuickBites, a (fictional but very realistic) food-delivery startup that outgrew "Docker on a few servers" — exactly the story in chapter 1. Their production setup is the classic small-company shape you'll meet everywhere:
| Piece | What it is | Notes |
|---|---|---|
| control-plane | The cluster's brain — API server, etcd, scheduler, controller-manager. | No app pods run here |
| node-1 / node-2 | Worker nodes running the actual workloads via kubelet + containerd. | Pods can land on either — the scheduler decides |
| ci-server | A separate box running Jenkins in a container — builds images, pushes them to the registry,
then deploys to the cluster with kubectl/helm. |
Chapter 3 walks the whole pipeline |
| Cluster software | Kubernetes v1.29 · containerd · Calico CNI · ingress-nginx · Prometheus + Grafana + Loki | the same stack countless real teams run |
riders-prod,
deployed as Helm release riders. Includes a MySQL StatefulSet
(mysql-0), PV/PVC, Ingress, ConfigMap and Secret.
orders-prod,
deployed with kubectl apply from numbered YAML files. Includes a MongoDB
StatefulSet (mongodb-0), PV/PVC, Ingress, ConfigMap and Secret.
The 2 a.m. problem, the desired-state idea, an interactive self-healing demo,
and the full architecture — brain, workers, and a deploy's journey from apply to Running.
Namespaces, Pods, Deployments, Services, Ingress, ConfigMaps, Secrets, PV/PVC — each mapped to a real object in the QuickBites cluster.
A production Jenkinsfile, stage by stage: versioning, the approval gate, docker build/push, and the kubectl/helm deploy step.
The same problem solved two ways. What actually differs, what --atomic buys you, and when to pick each in a real job.
Why mysql-0 and mongodb-0 are StatefulSets and not Deployments — identity, storage, and what survives a pod restart.
The skill that separates juniors from seniors: what every column of get pods, describe, rollout status and logs -f is telling you.
Want to run all of this on real multi-server infrastructure — real image pulls, real rollbacks, real 502s? That's the separate Real Server Lab module: live guided sessions, booked individually. Finish this course first; the lab assumes everything taught here.
A production failure worth memorising: the missing v that silently shipped nothing to production while the pipeline said SUCCESS.
Grafana, Prometheus, Loki and Promtail run in the cluster's monitoring namespace. Learn to check your app's health and logs there.
Every command from the pack on one page, plus the "can I fly solo?" final checklist.
The server nobody explains — you've deployed it without knowing. Event-loop workers, the real config inside frontend pods, and the robot that turns Ingress YAML into live nginx routing. With an interactive Host-header routing simulator.
Drive the cluster from the k9s cockpit, light up kubectl top with metrics-server, then the best demo in Kubernetes: load-test an API and watch the HPA scale it 2 → 6 → 2.
The firewall nobody turns on by default: a flat cluster network today, and the default-deny + explicit-allow manifests that lock it down.
Who are you, and what may you touch? ServiceAccounts, Roles and RoleBindings — and why handing out admin.conf is the root password of your cluster.
What the slash in 0/1 Running actually means. Readiness controls ENDPOINTS, liveness controls RESTARTS — confusing them builds your own crash loop.
Two numbers that decide where you run and when you die. CPU throttles, memory kills — plus the QoS eviction order and why no CPU request means no autoscaling.
Work that is meant to stop. Why a backup script as a Deployment loops forever, concurrencyPolicy, and the CronJob timezone bug.
One pod per node — the CNI, kube-proxy and log shippers you never deployed, and the toleration without which your control plane goes dark.
The object that says "not all of them at once". Why two replicas didn't save you from kubectl drain, and the deadlock that makes a node undrainable.
How a pod chooses a node — and how a node refuses a pod. Why a toleration is permission and not attraction, and decoding every FailedScheduling.
From http:// to https:// without touching your app. Where TLS actually terminates, the kubernetes.io/tls Secret, and cert-manager's renew loop.
Patch, don't template. Base + overlays in plain valid YAML, and an honest Helm-vs-Kustomize verdict for interviews.
The capstone lives in the Real Server Lab module: a real cluster is wiped and you deploy both apps back from nothing — one with raw manifests, one with Helm. Book a lab session when you're ready.
Progress is saved in your browser (localStorage) — it survives closing the tab.
minikube or kind on your laptop, or the Real Server Lab sessions.