Docker Quest

Tracks

1. 01📦Why Containers? Foundations

   0/7 lessons

   From dependency hell to OCI portability

   Before commands, the mental model. Containers are isolated processes with cgroup-enforced limits and union filesystems — not virtual machines, not magic. Learn the kernel primitives, the engine layers, and what 'OCI compliant' actually buys you.

   Lesson list (7)

   • 01
     Dependency Hell — "It Works on My Machine"~15 min · foundations, motivation
   • 02
     VM vs Container — Kernel-sharing vs Hypervisor~18 min · foundations, isolation
   • 03
     What Docker Actually Does — Namespaces, cgroups, OverlayFS~18 min · foundations, kernel
   • 04
     Images vs Containers — Class vs Instance~15 min · foundations, mental-model
   • 05
     Engine Architecture — CLI, dockerd, containerd, runc~14 min · foundations, architecture
   • 06
     OCI Standard — Why You Are Not Locked In~12 min · foundations, standards
   • 07
     The Ecosystem — Engine, Desktop, Alternatives, When Not to Use~14 min · foundations, tooling

2. 02⚡Images & Containers — Core Commands

   0/5 lessons

   The CLI vocabulary you will use every day

   Pull, run, ps, exec, logs, inspect, prune. The handful of commands that 90% of daily Docker work flows through. Each one has flags worth knowing — and one or two that will save you on a bad day.

   Lesson list (5)

   • 01
     Pulling Images — Tags, Variants, Digests~12 min · commands, registry
   • 02
     docker run — The Flag Vocabulary~18 min · commands, lifecycle
   • 03
     Port Mapping — Host:Container, Bind Address, Random~12 min · commands, networking
   • 04
     Lifecycle — ps, stop, start, kill, rm, prune~14 min · commands, lifecycle
   • 05
     Inside a Running Container — exec, logs, inspect~16 min · commands, debugging

3. 03🛠️Building Images — Dockerfile

   0/6 lessons

   Layered, cached, multi-stage, secure

   A Dockerfile is a recipe for an image. The order of instructions controls the cache. The choice of base image controls size and security. Multi-stage builds let you ship the artifact, not the toolchain.

   Lesson list (6)

   • 01
     Dockerfile Basics — FROM, WORKDIR, COPY, RUN, CMD~16 min · dockerfile, basics
   • 02
     Build Context & .dockerignore — Don't Send Your .git~10 min · dockerfile, performance
   • 03
     Layer Caching — Order Matters~16 min · dockerfile, performance
   • 04
     Multi-Stage Builds — Build Big, Ship Small~18 min · dockerfile, size
   • 05
     Base Image Choice — full / slim / alpine / distroless / scratch~14 min · dockerfile, size, security
   • 06
     Production-Ready Dockerfile — non-root, healthcheck, labels~16 min · dockerfile, production, security

4. 04💾Volumes & Data Persistence

   0/5 lessons

   Database survives container deletion

   Containers are ephemeral. Your database isn't. Volumes give state a place to live that outlasts any single container. Bind mounts give your dev loop a way to edit code on the host and see it inside the container instantly.

   Lesson list (5)

   • 01
     The Ephemeral Problem — Why Containers Forget~10 min · data, concepts
   • 02
     Three Storage Types — Volumes, Bind Mounts, tmpfs~14 min · data, concepts
   • 03
     Named Volumes — The Right Default for State~14 min · data, volumes
   • 04
     Bind Mounts — The Dev Loop Trick~14 min · data, development
   • 05
     Backup and Restore — Don't Discover This During an Outage~14 min · data, operations

5. 05🕸️Networking & Compose

   0/4 lessons

   Multi-container apps, service discovery, one YAML

   Custom networks give you DNS-based service discovery. Compose lets you describe your whole stack in a single YAML and bring it up with one command. The combo is what most local dev environments and small production deployments actually look like.

   Lesson list (4)

   • 01
     Custom Networks — DNS by Service Name~14 min · networking
   • 02
     Why Compose — One Command, Whole Stack~12 min · compose
   • 03
     depends_on + healthchecks — Wait Until Actually Ready~14 min · compose, production
   • 04
     Profiles & Override Files — Dev vs Prod from One Repo~14 min · compose, operations

6. 06🔐Production Discipline — Security, Secrets, Scanning

   0/3 lessons

   Non-root, scanned, scoped, observable

   What separates a Dockerfile that 'works' from one you'd ship to production: non-root user, real secret handling, image scanning, log management, and resource limits. Each is small. Skipping any of them is how breaches happen.

   Lesson list (3)

   • 01
     Non-root + Resource Limits — The Two Defaults~14 min · security, production
   • 02
     Secrets — Don't Bake, Don't Commit~14 min · security, secrets
   • 03
     Image Size + Scanning — Two Levers, Same Goal~14 min · security, size

7. 07🔍Debugging Containers — Read the Exit Code

   0/3 lessons

   Logs, exec, exit codes, network probes

   When a container won't start, won't respond, or won't behave, the answer is almost always in the logs, the exit code, or one shell session inside the container. Learn the systematic checklist that turns guessing into diagnosis.

   Lesson list (3)

   • 01
     The 'Why Won't It Start?' Checklist~14 min · debug
   • 02
     Exit Codes — What 137 Means~12 min · debug, lifecycle
   • 03
     Network Debugging — netshoot, dig, curl, nslookup~14 min · debug, networking

8. 08🚀Beyond Docker — Registries, Orchestration, Future

   0/3 lessons

   Where containers go after your laptop

   Containers don't stop at `docker compose up`. Registries store and version your images. Managed services run them in production without Kubernetes. Kubernetes runs them at scale when you actually need it. Wasm hints at what comes next.

   Lesson list (3)

   • 01
     Registries & Tagging — Push Once, Pull Anywhere~14 min · production, registry
   • 02
     Managed Container Services — Kubernetes Is Often Overkill~14 min · production
   • 03
     What's Next — Dev Containers, Wasm, and the Trajectory~12 min · production, future