A course that runs on your own machineβeta

Docker and Kubernetes,
made visible.

Most tutorials stop at a hello-world container. This one starts there, walking you through your first Dockerfile a line at a time, then hands you a small production system: eight containers, five languages, all running locally. You learn by taking it apart and watching it put itself back together.

Start with Chapter 0 →Look at the dashboard first
49
lessons
8
chapters
8
containers
5
languages
the fleet
dashboardTypeScript:3000
workerTypeScript:3001
aiPython:8000
utilGo:8080
computeC:9000
postgresPostgres:5432
redisRedis:6379
socket-proxyInfra:2375

Five languages on purpose. The tooling treats a C program and a Python program identically, which is why these skills transfer to any codebase.

Nothing is simulated

Every command is a real command against real containers running on your machine. The output you see is the output your terminal produced, including the errors.

It checks what it can

Where the system can prove you did something, it watches for it: a request counter rising, a restart count moving, a container id being replaced. Where it genuinely cannot tell, it asks you instead of pretending to know.

You break it on purpose

Crash a service and watch it revive. Scale to five copies. Roll out a new version with no downtime, then roll it back. Recovery is only convincing once you have caused the failure.

How it all fits together

Three tools, three scales, one idea repeated at each: package a program, run it, keep it running. Nothing here needs to be understood yet — it is the map, so you can see where every chapter lands before you start.

01

One program

dockerChapters 0–2

A folder with your code and a Dockerfile becomes an image. An image is a template on disk. A container is one running instance made from it. Those three nouns are most of Docker.

on your machine
server.js + Dockerfile
An ordinary folder. Your code does not know it is about to be containerized.
docker build
template
quest-hello:1.0
An image: files plus a default way to start. Sits on disk, runs nothing.
docker run
instance
container
A process with a private view of files, network and process list. One image, as many as you like.
docker push / docker pull
registry
Docker Hub and friends. Where images go to travel between machines — the reason the thing you built runs the same on a server you have never touched.
02

One machine, several containers

docker composeChapters 3–4

Real systems are not one container. Compose is a file listing several of them and one command that starts the lot. They get a private network and find each other by name.

one machine · your laptopdocker compose up
dashboard:3000
worker:3001
ai:8000
util:8080
compute:9000
postgres:5432
redis:6379
socket-proxy:2375
Private network. The dashboard reaches the Go service at http://util:8080 — by name, never by IP, because names survive a restart and IP addresses do not.
published: -p 3000:3000
your browser
Only the ports you publish are reachable. Everything else talks privately.
03

Many machines, kept alive

kubernetesChapters 5–6

Compose runs containers. It does not put them back when they die, spread them over machines, or replace them one at a time. Kubernetes does, and it follows from a single idea: you describe what should be true, and a loop makes reality match.

you write
replicas: 3
A desired state, in a file. Not an instruction to start anything.
control loopcompares, forever
the cluster · many machines
node 1
podpod
node 2
poddiedpodnew

One died. Nobody was paged, and nobody typed anything. The loop noticed two where three were asked for, and started a replacement.

Docker

Builds an image and runs one container from it.

Compose

Runs a set of containers together on one machine.

Kubernetes

Keeps a set of containers alive across many machines.

What you need to know first

Being precise about this matters. A course that quietly assumes you already know half of what it teaches is worse than one that says so up front.

Assumed

  • You can open a terminal and run a command someone gives you.
  • You know roughly what a program, a file, and a network port are.
  • You can read a little code without needing to write C, Go, or Python.
  • You have a Mac or Linux machine you can install software on.

Not assumed

  • Any Docker knowledge at all. Chapter 0 starts from why containers exist and has you build one by hand, one line at a time.
  • Any Kubernetes knowledge. Every term is defined before it is used.
  • A systems, ops, or DevOps background of any kind.
  • Networking theory. The parts that matter are taught where they first bite.
  • YAML, cloud accounts, or a credit card. Everything runs locally and for free.

Tools to install

Only the first two are needed to begin. Run make doctor and it will tell you what is missing.

dockerChapter 0 onward. Install OrbStack or Docker Desktop.
nodeVersion 22 or newer, to run the dashboard.
kubectlChapter 5 onward, to talk to the cluster.
kindChapter 5 onward, to create a local cluster.

The path

Docker first, then Compose, then Kubernetes. That is the order they were invented, and the order in which each one's problems make the next one make sense.

  1. 00Getting started13 lessons
  2. 01What a container actually is4 lessons
  3. 02Images and how they're built4 lessons
  4. 03Networking, Compose, and data6 lessons
  5. 04When things break4 lessons
  6. 05Kubernetes6 lessons
  7. 06Ship your own app3 lessons
  8. 07Ship beyond your laptop9 lessons

Run it for real

You can read every lesson here, with real recorded output. But the point is to run the commands yourself and watch your own system respond. Clone the repo, start the fleet, and the dashboard turns live.

Start the course →View on GitHub
# start all eight containers
$ make up
# check every tool is present
$ make doctor
# five languages, one JSON shape
$ make meta