A project-based course that takes you from your very first docker run to a production-shaped deployment on Kubernetes — building one real application, Pinboard, across all ten sessions. No prior Docker or Kubernetes experience needed.
10 sessions × 2h · Docker Engine + kind on your own Linux machine · for engineers with zero container experience
If you're comfortable in a terminal and tired of "it works on my machine", this is your on-ramp to containers and Kubernetes — starting from nothing.
Package your app in an image once and run it identically on your laptop, in CI and in a cluster.
Learn what a container really is — namespaces, cgroups, overlay filesystems — before you operate a cluster full of them.
Get the vocabulary and the habits — probes, resources, rollouts, secrets — that make Kubernetes deployments boring in the good way.
Meet Pinboard — a small three-tier app: a Go API, a static nginx front-end and a PostgreSQL database. You never write application code. Instead you run it, containerize it, compose it, then move it onto Kubernetes and grow it into something production-shaped. Every lab starts where the last one ended; nothing is throwaway.
Run the database, build the images, then wire the tiers together with networks and volumes.
The whole stack in a single compose.yaml — healthchecks, dependencies, live reload, scaling.
A kind cluster on your own machine: Pods, Deployments with probes, Services, DNS and Ingress.
ConfigMaps, Secrets, a StatefulSet database, troubleshooting and autoscaling — then the capstone.
You leave with the skills — and a complete, production-shaped Kubernetes deployment you built yourself, manifest by manifest.
Each 2-hour session pairs focused theory and live demos with a hands-on lab that moves the Pinboard project one step forward.
Why containers; namespaces, cgroups and overlay filesystems; the OCI specs; CLI → dockerd → containerd → runc; image naming, digests and the container lifecycle.
Lab 01 · Run the Pinboard database tier: Postgres in a container, psql, inspect, restart, remove.Dockerfile anatomy, how BuildKit caches, instruction ordering, .dockerignore, multi-stage builds, base image choice, non-root, publishing, multi-platform and SBOMs.
Lab 02 · Build the Pinboard images: a multi-stage API image (400 MB → ~10 MB), versions 1.0 and 1.1, plus the web image.Config via environment, ARG vs ENV, ENTRYPOINT vs CMD, PID 1 and signals; volumes, bind mounts and tmpfs; user-defined networks and DNS; memory/CPU limits, restart policies, healthchecks.
Lab 03 · Wire Pinboard together by hand: a network, a volume, three containers talking by name — notes survive a database restart.The Compose Specification (no version: key), services, healthchecks and depends_on conditions, profiles, overrides, compose watch — and what Compose can't do.
Lab 04 · Pinboard in one file: write compose.yaml, up --wait, edit the web page live, scale the API to three.Why orchestration; control plane and node components; the API object model and reconciliation; kubeconfig, contexts, namespaces, kubectl grammar; Pods, init and sidecar containers, requests and limits.
Lab 05 · Pinboard meets Kubernetes: create the kind cluster, load the image, run the API imperatively and from a manifest, then read the events of a failing Pod.Labels and selectors, ReplicaSets, Deployments, rolling-update mechanics, rollout history and undo; liveness, readiness and startup probes; DaemonSets, Jobs and CronJobs at a glance.
Lab 06 · Make the API resilient: three replicas with probes, a zero-error rolling update 1.0 → 1.1, a CrashLoopBackOff and a rollback.The Pod network model and CNI; ClusterIP, NodePort, LoadBalancer, headless; EndpointSlices and kube-proxy; cluster DNS; Ingress controllers, path and host routing, Gateway API, NetworkPolicy.
Lab 07 · Expose Pinboard: Services for api and web, a DNS test from a debug Pod, ingress-nginx on kind, and the app open in your browser.ConfigMaps and how updates propagate; Secrets, why base64 is not encryption, encryption at rest and external stores; volume types; PV, PVC, StorageClass and dynamic provisioning; StatefulSets.
Lab 08 · Give Pinboard a real database: a Secret, a ConfigMap, a StatefulSet with a 1 Gi PVC — delete the Pod and the notes are still there.A troubleshooting method and the status zoo; kubectl debug and ephemeral containers; metrics-server, k9s and Headlamp; HPA v2, PDBs, quotas and LimitRanges; RBAC and securityContext / Pod Security Admission.
Lab 09 · Operate Pinboard: autoscale the API under load, break it two ways and debug it with the method, then add a PDB and a securityContext.What "production-ready" means as a checklist; packaging with Helm and Kustomize; GitOps in one slide; what changes on managed Kubernetes; where to go next.
Capstone (80′) · Deploy the whole stack from a blank folder into pinboard-prod — and score yourself with the verification script.No four-hour lectures. Every session is short bursts of theory, live demos, then you at the keyboard.
The concepts, shown in real commands you can follow along with.
Reset, then back to it.
The second concept block, building on the first.
You move Pinboard forward — the through-line of the whole course.
Session 10 breaks the pattern: 30 minutes of theory and demos, then an 80-minute capstone lab.
No cloud account, no credit card, no shared cluster to fight over. A Linux machine with Docker Engine and a kind cluster gives you a real multi-node Kubernetes to break and rebuild as often as you like. Images are built locally and loaded straight into the cluster, so the labs work even on a closed network.
Ubuntu 22.04 or 24.04 (or a close derivative), amd64 or arm64, 20 GB free disk. A VM is fine.
With Compose v2 and Buildx/BuildKit, running as your normal user — no sudo.
A disposable Kubernetes 1.33 cluster in Docker, with port mappings for Ingress on localhost.
Used in the later sessions and the capstone. A one-command setup script installs the lot.
Short version: a terminal you're comfortable in, and a machine that can run Docker. Lab 00 walks you through the rest in about 20 minutes.
Not ten disconnected sample images — a single three-tier app you containerize, compose, deploy and operate end to end.
Compose v2 and BuildKit, containerd and the CRI, Kubernetes 1.33 on kind, StatefulSets and HPA v2 — not 2021 habits.
Non-root images, probes before rollouts, resource limits, secrets kept out of git, a debugging method you can reuse on Monday.
Ask about dates, seats and private cohorts — hello@zonoth.tech
No. Session 01 starts at "what is a container, really" and builds from there. You should be comfortable using a Linux terminal and have a basic grasp of how a web application and a database fit together.
No. Everything runs locally: Docker Engine for the container sessions and a kind cluster — Kubernetes running inside Docker — for the Kubernetes ones. Session 10 covers what changes on managed Kubernetes such as AKS, EKS or GKE.
Docker Engine 28+, kubectl, kind and helm on a Linux machine. Lab 00 is a step-by-step setup guide with a one-command install script — about 20 minutes before session one.
No. The sample application, Pinboard, is provided: a Go API, an nginx front-end and PostgreSQL. You write Dockerfiles, Compose files and Kubernetes manifests — not application code.
Yes — all decks, labs, solutions and demo files are yours to keep, and you finish with the whole Pinboard stack deployed on your own machine.
Absolutely. Private and team cohorts can be scheduled and tailored — including an offline image bundle for closed networks. Get in touch.
Join the next cohort of Containers & Kubernetes Fundamentals and walk away with real, production-shaped skills — and the running project to prove it.
Get in touch →