Kubernetes has a reputation for being complicated. In part, it is. But most of the confusion comes from learning isolated pieces: one tutorial for kubectl, another for kubeadm, another for Helm, another for Prometheus — without ever seeing the whole thing working.

This course is different: we will set up a real cluster, deploy an application on it, operate day to day, and face real problems. Each chapter has concept, lab, validation, common errors, and checklist.

Course seal: commands verified on Kubernetes 1.35 and Ubuntu 24.04. The lab is yours; nothing here should be executed in production without adaptation.

Who this is for

• Anyone who has heard of containers and wants to understand Kubernetes without guesswork.
• Developers who need to understand why the deployment "passed the build and died in the cluster".
• Infra/analysts who want to set up their own lab and operate safely.
• MSP/consulting owners who need to explain the subject to clients.

You don't need to know Kubernetes beforehand. You need to know how to use the terminal and have patience to read logs.

What you will build

A lab with:

• 3 masters and 3 workers (HA control plane).
• CNI, Ingress, TLS, and DNS.
• Persistent storage.
• PostgreSQL with failover (CloudNativePG).
• MinIO, RabbitMQ, Redis, and Elasticsearch.
• Observability (Prometheus/Grafana).
• Tested backup and restore (Velero + etcd).
• Deployment of an application with HPA, probes, and PDB.
• Runbooks for the incidents that actually happen.

How the course works

Each chapter is an independent post, but part of a season:

• Season 1 — Fundamentals and construction: from "what is a pod" to the HA cluster.
• Season 2 — Operations and data: storage, configuration, operators, backup, node upgrades.
• Season 3 — Production and incidents: Helm, GitOps, CI/CD, security, capacity, SLO, and DR.

Between chapters, we publish short postmortems of real lab incidents. They are the most instructive part.

Program

Season 1 — Fundamentals and construction

1. Kubernetes without fear: the container condominium
2. Setting up the lab: 6 VMs and a cluster that fits in your pocket
3. The first pod and the first deploy: YAML, kubectl, and what really happens
4. kubeadm under the hood: certificates, static pods, and the join
5. HA: 3 masters, VIP, and etcd
6. CNI: flannel, Cilium, and why NetworkPolicy matters
7. Namespaces, labels, quotas, and PDB
8. Deployments, StatefulSets, and DaemonSets
9. Services, Ingress, DNS, and TLS
10. The first "it didn't come up": diagnosing pods

Season 1 completed in 10 chapters + 2 postmortems.

Postmortem: The Postgres failover that taught me what PDB is

Postmortem: The deploy that passed the build and died in the cluster

Season 2 — Operations and data

11. Storage: PV, PVC, NFS, and local-path
12. ConfigMap, Secret, and the credential guard
13. Observability: metrics-server, Prometheus, and Grafana
14. Operators: what they are and why use them
15. Postgres with CloudNativePG: HA, failover, and backup
16. MinIO: erasure coding, buckets, and credentials
17. RabbitMQ and Redis: quorum, sentinel, and PDB
18. Elasticsearch/ECK in practice
19. Backup and restore: Velero + etcd + drill
20. Node upgrades safely

Season 2 completed in 10 chapters.

Season 3 — Production and incidents

21. Helm: packaging the application
22. GitOps with ArgoCD
23. Zero-downtime deploy: probes, rolling update, and HPA
24. CI/CD: immutable images and SBOM
25. Security: RBAC, PSA, NetworkPolicy, and secrets
26. Capacity and load: HPA, k6, and rate limit
27. SLO/SLI, on-call, and blameless postmortem
28. DR: RPO/RTO, restore drills, and capstone

Full course in 3 seasons and 28 chapters.

Prerequisites

• A computer with 16 GB of RAM (or a server/Proxmox) for the lab.
• Ubuntu Server 24.04 on the VMs.
• Willingness to break and fix.

What this course is not

• It is not a certification.
• It is not a cloud provider tutorial.
• It is not "copy and paste into production".
• It does not hide the errors: incidents are part of the material.

Start here

Read chapter 01, set up the lab in 02, and bring up the first deploy in 03. If something fails, chapter 10 is your diagnostic map.

See you in the cluster.

Next: Kubernetes Course 01 — Kubernetes without fear