# Containers & Kubernetes Fundamentals
## A hands-on, project-based introduction to Docker and Kubernetes — from your first `docker run` to a production-shaped deployment on a local cluster.
### 20 hours · 10 live sessions of 2h · for engineers with zero container experience
[**Slide decks**](/docker-kubernetes-training/decks/index.html) · [**Setup guide**](/docker-kubernetes-training/labs/lab00-setup.html) · [**Curriculum**](#curriculum) · [**Labs**](#labs) · [**Sample app**](./src/README.md)
Why this course
Most container courses hand you a different toy in every lab. This one is built around a single application you carry from session one to session ten: Pinboard, a tiny three-tier app (Go API, static web front-end on nginx, PostgreSQL). You run its database in a container in the first hour; by the last session you deploy the whole thing into a production-shaped namespace — probes, resources, security context, autoscaling, disruption budgets, Ingress — from a blank folder, and a script grades it.
You learn the way you’ll actually work: build the image, read the logs, write the manifest, watch the rollout, break it, debug it, fix it.
What you’ll build
The storyline. Session 01: run Postgres in a container and lose your data. 02: build Pinboard’s images properly (multi-stage, distroless, non-root). 03: wire the three tiers by hand with networks and volumes. 04: one
compose.yaml. 05: a local Kubernetes cluster with kind and your first Pods. 06: Deployments, rolling updates and probes. 07: Services, DNS and Ingress. 08: ConfigMaps, Secrets and a StatefulSet database. 09: autoscaling, troubleshooting, Pod security. 10: the capstone.
Who it’s for
- Software engineers who want to ship their code as images and understand what the platform team means by “just add a readiness probe”.
- Infra / SysAdmin / DevOps practitioners moving from VMs and scripts to containers and declarative orchestration.
- Anyone technical and comfortable in a Linux terminal — no prior Docker or Kubernetes experience needed.
What you’ll be able to do by the end
- Explain what a container is (namespaces, cgroups, layered filesystems, OCI) and how Docker, containerd and Kubernetes relate.
- Write small, safe, cacheable Dockerfiles; tag, publish and inspect images.
- Run multi-container applications with networks, volumes, limits and health checks — by hand and with Compose.
- Read a Kubernetes cluster: control plane, nodes, the API object model,
kubectlandkubectl explain. - Deploy workloads with Deployments, probes and resource requests; roll out and roll back safely.
- Expose applications with Services and Ingress; configure them with ConfigMaps and Secrets; persist data with PVCs and StatefulSets.
- Troubleshoot with a method (
get→describe→logs→events→debug), autoscale with HPA, and apply baseline Pod security.
Curriculum
Each 2-hour session runs the same rhythm: 50 min theory + demos · 10 min break · 20–30 min theory + demos · 30–40 min lab. Session 10 is 30 min theory + 80 min capstone lab.
| # | Session | You’ll learn | Deck | Lab |
|---|---|---|---|---|
| 01 | Containers & Docker: the mental model | Why containers, namespaces/cgroups/overlayfs, OCI, Docker architecture, images vs containers vs registries, the everyday CLI | deck | Lab 01 |
| 02 | Building images | Dockerfile, BuildKit layers & cache, multi-stage, base-image ladder, non-root, tags & digests, publishing, SBOM/provenance | deck | Lab 02 |
| 03 | Running containers well | ENV/ARG, CMD vs ENTRYPOINT, signals & PID 1, volumes/bind/tmpfs, networks & DNS, limits, restart policies, health checks | deck | Lab 03 |
| 04 | Docker Compose | The Compose Specification, healthchecks & depends_on, env files, up --wait, watch, scaling, overrides — and where Compose stops |
deck | Lab 04 |
| 05 | Kubernetes: architecture, kubectl, Pods | Control plane & nodes, the API object model, desired state, kubeconfig, namespaces, Pods, init & sidecar containers, requests/limits | deck | Lab 05 |
| 06 | Workloads, rollouts and probes | Labels & selectors, ReplicaSets, Deployments, rolling updates & rollbacks, liveness/readiness/startup probes, Jobs & CronJobs | deck | Lab 06 |
| 07 | Networking: Services, DNS, Ingress | Pod network model, Service types, EndpointSlices, cluster DNS, Ingress & ingress-nginx, Gateway API, NetworkPolicy | deck | Lab 07 |
| 08 | Configuration & storage | ConfigMaps, Secrets (and why base64 isn’t encryption), volumes, PV/PVC/StorageClass, StatefulSets, databases on Kubernetes | deck | Lab 08 |
| 09 | Operating Kubernetes | A troubleshooting method, kubectl debug, metrics-server, HPA v2, PDB, quotas, RBAC basics, securityContext & Pod Security Admission |
deck | Lab 09 |
| 10 | Capstone: ship Pinboard like production | The production-ready checklist, Helm & Kustomize at a glance, GitOps, managed Kubernetes, what to learn next | deck | Lab 10 |
Getting started
- Before session 1, complete the setup guide on your Linux lab machine — Docker Engine, kubectl, kind, helm — or run
labs/setup.sh. ~15 minutes. Instructors can instead hand every student a ready-made Azure VM withinfra/azure-lab-vms. - Open the deck index in a browser to follow along (arrow keys navigate,
Ffullscreen,Sspeaker notes). - Work each session’s lab in
~/pinboard-labs/labNN/— every lab picks up exactly where the previous one left off.
Repository structure
.
├── decks/ HTML slide decks (reveal.js) + index — one per session
│ └── assets/ Brand theme, icons, self-hosted fonts, vendored reveal.js (works offline)
├── labs/ Step-by-step labs (lab00 setup → lab10 capstone), kind-config.yaml, setup.sh
│ ├── solutions/ Finished files for every lab; final/ is the canonical end state
│ └── capstone/ Capstone checklist + verify.sh scorecard
├── demos/ Instructor demos shown live in each session (instructions + files)
├── instructor/ Second-screen command sheets + a timed run of show per session
├── infra/ Terraform: one pre-configured Azure lab VM per student (cloud-init does the setup)
├── src/ The Pinboard sample app: pinboard-api (Go), pinboard-web (nginx), db, compose.yaml
├── landing/ Course landing page
├── docs/ COURSE-DESIGN.md (curriculum & decisions), REVIEW.md (review of the 2021 edition)
└── legacy/ The 2021 edition (PDF slides, labs, demos, .NET sample) kept for reference
Labs
Every session ends in a hands-on lab, and they all build on the same Pinboard project. Start with the setup guide before session one.
| Lab | Session | What you’ll do |
|---|---|---|
| Lab 00 — Course setup | pre-work | Install Docker Engine, kubectl, kind, helm; clone the repo. ~15 min. |
| Lab 01 — Run the Pinboard database tier | 01 | Run PostgreSQL in a container, create the notes table, inspect/stop/start/remove it — and watch the data vanish. |
| Lab 02 — Build the Pinboard images | 02 | A naive Dockerfile, then the real multi-stage distroless one; build 1.0, 1.1, 1.2-broken and the web image; optional push to Docker Hub. |
| Lab 03 — Wire Pinboard together by hand | 03 | Network + volume, three containers finding each other by name, persistence across a DB restart, limits and health. |
| Lab 04 — Pinboard in one file | 04 | compose.yaml with healthchecks and depends_on, .env, up --wait, watch, --scale. |
| Lab 05 — Pinboard meets Kubernetes | 05 | Create the kind cluster, load the images, run the API as a Pod imperatively and from YAML, read events, fix a broken Pod. |
| Lab 06 — Make Pinboard API resilient | 06 | A Deployment with probes and resources; roll 1.0 → 1.1 without errors, roll out a broken image and undo it. |
| Lab 07 — Expose Pinboard | 07 | ClusterIP Services, DNS from a debug Pod, the web tier, ingress-nginx and an Ingress on http://localhost. |
| Lab 08 — Give Pinboard a real database | 08 | Secret + ConfigMap, a PostgreSQL StatefulSet with a dynamically provisioned PVC, notes that survive a Pod deletion. |
| Lab 09 — Operate Pinboard | 09 | metrics-server, HPA under load, three break/fix drills with kubectl debug, a PDB and a node drain, Pod Security Admission. |
| Lab 10 — Capstone | 10 | Deploy the whole stack into pinboard-prod from a blank folder against a checklist; verify.sh grades it. |
Demos
- S01 Containers & CLI · S02 Building images · S03 Config, storage, networking · S04 Compose · S05 Cluster & Pods
- S06 Rollouts & probes · S07 Services & Ingress · S08 Config & storage · S09 Operations · S10 Helm & Kustomize
Slide decks
The decks are self-contained HTML — no internet required, so they run in any classroom.
Open decks/index.html, or serve the folder with any static web
server. Speaker notes are embedded (S in the deck).
Delivery & licensing
This course is delivered by Zonoth (zonoth.tech) — cloud, Infrastructure as Code and AI training and consultancy. For private/team cohorts, scheduling or licensing the materials, open an issue or get in touch.
Feedback
Found something to improve? Open an issue describing what you hit and I’ll get back to you.