Skip to main content
RunBook Academy

Docker & Containers · Curriculum

Curriculum

237 lessons across 40 parts. Lessons build on each other; later parts assume familiarity with earlier material.

Part I

Foundations

Containers vs VMs, OCI ecosystem, Docker architecture, Linux primitives.

6 lessons
  1. 01Welcome to Docker & Containers for Production SysadminsCourse introduction · foundation · ~18 min
  2. 02Containers vs virtual machinesContainers vs VMs · foundation · ~22 min
  3. 03The OCI ecosystemOCI ecosystem · foundation · ~26 min
  4. 04Docker architecture at a glanceArchitecture · foundation · ~28 min
  5. 05What production-readiness means hereProduction lens · foundation · ~22 min
  6. 06The Linux primitives behind a containerLinux primitives · foundation · ~20 min

Part II

Linux Internals

Namespaces, cgroups v2, OverlayFS, capabilities, the kernel features Docker relies on.

8 lessons
  1. 01Linux namespaces — the foundation of every containerNamespaces · foundation · ~30 min
  2. 02cgroups v2 — the resource side of container isolationcgroups · intermediate · ~28 min
  3. 03OverlayFS — the filesystem underneath every containerOverlayFS · intermediate · ~22 min
  4. 04Linux capabilities — fine-grained rootCapabilities · intermediate · ~24 min
  5. 05Processes, signals, and PID 1Processes · intermediate · ~22 min
  6. 06Seccomp and AppArmor — restricting what a container can doSeccomp and LSMs · advanced · ~28 min
  7. 07User namespaces and rootless DockerUser namespaces · advanced · ~26 min
  8. 08Container startup from CLI to running processStartup deep-dive · advanced · ~32 min

Part III

Installation & Daemon

Repositories, version pinning, Docker Engine, containerd, runc, systemd, daemon.json.

7 lessons
  1. 01Supported installation methodsInstallation methods · foundation · ~26 min
  2. 02Repository setup and version pinningRepositories and pinning · intermediate · ~28 min
  3. 03Docker Engine, containerd, runc — what is in the packageComponents · intermediate · ~26 min
  4. 04systemd integration — managing dockerd as a unitsystemd · intermediate · ~26 min
  5. 05daemon.json — every production-relevant keydaemon.json · intermediate · ~30 min
  6. 06Log drivers at the daemon levelLogging · intermediate · ~28 min
  7. 07Live restore — surviving daemon restartsLive restore · intermediate · ~24 min

Part IV

Images

Layers, manifests, digests, tags, multi-platform, inspection, lifecycle.

6 lessons
  1. 01Layers and the copy-on-write filesystemLayers · foundation · ~24 min
  2. 02Manifests, digests, and content addressingManifests · intermediate · ~30 min
  3. 03Tags — mutable references to digestsTags · foundation · ~26 min
  4. 04Multi-platform imagesMulti-platform · intermediate · ~28 min
  5. 05Inspecting an imageInspection · foundation · ~26 min
  6. 06Image lifecycle — pull, tag, push, prune, retainLifecycle · intermediate · ~28 min

Part V

Dockerfiles & BuildKit

Instructions, caching, multi-stage, secrets, reproducibility, minimal images.

8 lessons
  1. 01Dockerfile instructions — every operator-relevant instructionInstructions · foundation · ~28 min
  2. 02BuildKit — the modern builderBuildKit · intermediate · ~28 min
  3. 03Build caching — when it hits and when it does notCaching · intermediate · ~30 min
  4. 04Multi-stage builds — separating build from runtimeMulti-stage · intermediate · ~28 min
  5. 05Build secrets and SSH mountsBuild secrets · advanced · ~26 min
  6. 06Reproducibility — pinned bases, deterministic layersReproducibility · intermediate · ~26 min
  7. 07Minimal images — distroless, scratch, and when to use whichMinimal images · intermediate · ~28 min
  8. 08Secure image constructionSecure construction · advanced · ~30 min

Part VI

Container Lifecycle

run / create / start / stop / exec / signals / PID 1 / graceful shutdown.

6 lessons
  1. 01Container lifecycle, signals, and graceful shutdownContainer lifecycle · foundation · ~20 min
  2. 02create and start — the two-phase lifecycle and what is immutableCreation and configuration · intermediate · ~22 min
  3. 03exec and attach — working inside a running containerWorking with running containers · intermediate · ~22 min
  4. 04stop, kill, and pause — the three ways to interrupt a containerInterrupting a container · intermediate · ~24 min
  5. 05Container states, exit codes, and the event streamObserving the lifecycle · intermediate · ~24 min
  6. 06Removing and recreating containers — what removal destroysRemoval and replacement · intermediate · ~22 min

Part VII

Networking

Namespaces, veth, bridge, host, macvlan, ipvlan, DNS, published ports.

8 lessons
  1. 01Docker networking primitives — namespaces, veth, bridgesPrimitives · advanced · ~32 min
  2. 02Bridge networks — the default and how to use them wellBridge networking · intermediate · ~22 min
  3. 03Host networking — when to break out of isolationHost networking · intermediate · ~22 min
  4. 04macvlan and ipvlan — when you need L2 adjacencymacvlan and ipvlan · advanced · ~30 min
  5. 05DNS and the embedded resolverDNS · intermediate · ~26 min
  6. 06Published ports and the userland proxyPublished ports · intermediate · ~24 min
  7. 07Network troubleshooting — packet flow and toolsNetwork troubleshooting · advanced · ~28 min
  8. 08The none network driver — when to disconnect a containerNone driver · intermediate · ~18 min

Part VIII

Storage

Writable layers, volumes, bind mounts, tmpfs, UID/GID, network storage.

7 lessons
  1. 01Storage drivers — overlay2 and what the others are forStorage drivers · intermediate · ~24 min
  2. 02Volumes — named, anonymous, lifecycleVolumes · foundation · ~26 min
  3. 03Bind mounts — host paths in containersBind mounts · intermediate · ~24 min
  4. 04tmpfs mounts — ephemeral, fast storagetmpfs · intermediate · ~20 min
  5. 05Permissions and ownership — the UID/GID trapPermissions · intermediate · ~26 min
  6. 06Network and shared storage — NFS, CIFS, Ceph, iSCSINetwork storage · advanced · ~26 min
  7. 07Storage performance — overlay2, drivers, and tuningPerformance · advanced · ~24 min

Part IX

Docker Compose

Services, networks, volumes, secrets, healthchecks, profiles, production patterns.

7 lessons
  1. 01Compose v2 architecture — the plugin, the project modelCompose architecture · foundation · ~24 min
  2. 02Services, networks, volumes — the three primitivesCompose primitives · foundation · ~28 min
  3. 03Healthchecks in Compose — and what they do not doHealthchecks · intermediate · ~26 min
  4. 04Dependencies and startup orderDependencies · intermediate · ~26 min
  5. 05Secrets in ComposeCompose secrets · intermediate · ~24 min
  6. 06Profiles — optional services in one fileCompose profiles · foundation · ~18 min
  7. 07Production Compose patterns — what works at scaleProduction patterns · advanced · ~28 min

Part X

Production Architecture

Host design, reverse proxies, TLS, segmentation, capacity, operational boundaries.

6 lessons
  1. 01Docker host design — single host, multi host, edge casesHost design · advanced · ~30 min
  2. 02Reverse proxy, TLS, and the edgeEdge · intermediate · ~26 min
  3. 03Network segmentation and management accessSegmentation · intermediate · ~26 min
  4. 04Capacity planning — CPU, RAM, disk, networkCapacity planning · intermediate · ~26 min
  5. 05Operational boundaries — when Docker stops being the right toolBoundaries · intermediate · ~22 min
  6. 06Where state lives — stateful services on a production Docker hostState · advanced · ~20 min

Part XI

Container & Host Security

Capabilities, seccomp, AppArmor, rootless, no-new-privileges, Docker socket risk.

6 lessons
  1. 01Linux security modules — AppArmor and SELinux for containersLSMs · advanced · ~32 min
  2. 02User namespaces and rootless Docker (security perspective)User namespaces · advanced · ~30 min
  3. 03Read-only root filesystems and no-new-privilegesHardening flags · intermediate · ~24 min
  4. 04The Docker socket — the most dangerous API on the hostDocker socket · advanced · ~28 min
  5. 05Privileged containers and the security boundaryPrivileged containers · advanced · ~24 min
  6. 06Device access and bind mount risksDevices and binds · intermediate · ~26 min

Part XII

Supply Chain

Image provenance, SBOM, CVEs, scanners, signing, Cosign.

6 lessons
  1. 01Image provenance — SLSA, attestations, and what they proveProvenance · advanced · ~26 min
  2. 02SBOM — software bill of materials for imagesSBOM · intermediate · ~24 min
  3. 03CVE scanning — Trivy, Grype, Docker ScoutCVE scanning · intermediate · ~26 min
  4. 04Image signing — Cosign, Sigstore, and verificationSigning · advanced · ~28 min
  5. 05Registry trust — pulling from who you think you areRegistry trust · intermediate · ~22 min
  6. 06Supply-chain incident response — finding every affected image and containerIncident response · advanced · ~22 min

Part XIII

Registries

Docker Hub, private registries, auth, digests, retention, backup.

6 lessons
  1. 01Docker Hub — limits, namespaces, official imagesDocker Hub · foundation · ~20 min
  2. 02Private registries — Distribution, Harbor, GitLab, QuayPrivate registries · intermediate · ~26 min
  3. 03Registry authentication — basic, token, OIDCRegistry auth · intermediate · ~22 min
  4. 04Immutable digests — why tags are not enoughDigests · foundation · ~22 min
  5. 05Retention policies — keeping your registry from filling the diskRetention · intermediate · ~24 min
  6. 06Registry backup and restoreBackup and restore · advanced · ~24 min

Part XIV

Secrets

Build secrets, runtime secrets, external secret managers.

6 lessons
  1. 01Why environment variables are not secretsWhy not env vars · foundation · ~20 min
  2. 02Docker build secrets and runtime secretsSecret patterns · advanced · ~24 min
  3. 03External secret managers — Vault, AWS SM, Doppler, InfisicalExternal managers · intermediate · ~24 min
  4. 04Secret rotation — without breaking productionRotation · intermediate · ~22 min
  5. 05A secret is already in the image — layer forensics and remediationLeaked secrets · advanced · ~20 min
  6. 06Preventing the leak — build context hygiene and CI secret scanningLeaked secrets · intermediate · ~18 min

Part XV

Resource Controls

CPU, memory, swap, PIDs, I/O, OOM behaviour, noisy neighbours.

6 lessons
  1. 01CPU shares, quotas, and pinningCPU · intermediate · ~30 min
  2. 02Memory limits and OOM behaviourMemory · intermediate · ~30 min
  3. 03PIDs limit and process controlsPIDs · foundation · ~22 min
  4. 04I/O controls and block device limitsBlock I/O · intermediate · ~26 min
  5. 05Noisy neighbours and how to prevent themNoisy neighbours · intermediate · ~26 min
  6. 06Auditing resource limits — proving the limit you set is the limit in forceVerification · advanced · ~20 min

Part XVI

Performance

Storage drivers, image size, startup, eBPF, Linux perf tools.

6 lessons
  1. 01Storage drivers and image layoutStorage drivers · intermediate · ~26 min
  2. 02Image size and the cost of layersImage size · intermediate · ~26 min
  3. 03Linux performance tools for containersLinux tools · intermediate · ~30 min
  4. 04Container startup time — what dominates and how to measureStartup · intermediate · ~24 min
  5. 05eBPF — an introduction for container operatorseBPF · advanced · ~24 min
  6. 06Container network performance — the datapath and how to measure itNetwork · advanced · ~22 min

Part XVII

Logging

Drivers, rotation, journald, syslog, Fluent Bit, Loki.

6 lessons
  1. 01Stdout and stderr — the container logging contractStdout contract · foundation · ~20 min
  2. 02Logging drivers — json-file, local, journald, and the remote onesDrivers · intermediate · ~26 min
  3. 03Log rotation and disk consumptionRotation · intermediate · ~22 min
  4. 04Central log collection — Fluent Bit, Vector, LokiCentral collection · intermediate · ~30 min
  5. 05Failure lab — unbounded logs fill the diskFailure lab · intermediate · ~35 minLab
  6. 06journald and syslog — container logs where the host already looksHost integration · intermediate · ~20 min

Part XVIII

Monitoring

Host, Docker, container, application metrics; Prometheus, cAdvisor, Grafana.

6 lessons
  1. 01What to monitor — host, Docker, container, applicationWhat to monitor · foundation · ~28 min
  2. 02Prometheus + node_exporter + cAdvisor + GrafanaPrometheus stack · intermediate · ~30 min
  3. 03What the daemon can tell you — stats, events, healthchecks, /metricsDaemon signals · intermediate · ~22 min
  4. 04Where the numbers come from — cgroup v2 metric sourcesMetric sources · advanced · ~24 min
  5. 05Alerting rules that page — and the ones that should notAlerting · advanced · ~24 min
  6. 06Blind spots — what the monitoring stack cannot seeBlind spots · advanced · ~22 min

Part XIX

Observability

Metrics, logs, traces, OpenTelemetry, Tempo, end-to-end correlation.

6 lessons
  1. 01Distributed tracing with OpenTelemetryOpenTelemetry · advanced · ~24 min
  2. 02End-to-end correlation — request IDs across signalsCorrelation · intermediate · ~22 min
  3. 03The three pillars of observabilityPillars · intermediate · ~22 min
  4. 04Running the OpenTelemetry Collector on a Docker hostOpenTelemetry · advanced · ~22 min
  5. 05Tempo — storing and querying tracesTrace backend · advanced · ~20 min
  6. 06Sampling — head, tail, and what you stop being able to seeTrace backend · advanced · ~20 min

Part XX

Health & Failure Detection

Healthchecks, restart policies, dependency failures.

6 lessons
  1. 01Health checks — what they can and cannot doHealthchecks · intermediate · ~26 min
  2. 02Restart policies — no, always, unless-stopped, on-failureRestart policies · intermediate · ~22 min
  3. 03Dependency failures and cascading outagesDependencies · intermediate · ~24 min
  4. 04Healthcheck timing — the detection-latency budgetHealthchecks · intermediate · ~18 min
  5. 05Reading health state — inspect, events, and acting on transitionsFailure detection · intermediate · ~18 min
  6. 06Failure lab — the container that stayed healthy through an outageFailure lab · intermediate · ~20 min

Part XXI

Backup

Volumes, bind mounts, application-consistent backups, offsite copies, restore tests.

6 lessons
  1. 01Why `docker commit` is not a backupWhy not docker commit · foundation · ~20 min
  2. 02Volume backups — tar, restic, BorgVolume backups · intermediate · ~26 min
  3. 03Bind mount backups — preserving the host path layoutBind mount backups · intermediate · ~22 min
  4. 04Application-consistent backups — quiesce and snapshotApplication consistency · advanced · ~28 min
  5. 05Offsite copies and the 3-2-1 ruleOffsite · intermediate · ~22 min
  6. 06Restore validation — the part most teams skipRestore validation · advanced · ~26 min

Part XXII

Disaster Recovery

RPO/RTO, destroyed-host recovery, restore, exercise cadence.

6 lessons
  1. 01Disaster recovery — the production host is goneDR · advanced · ~30 min
  2. 02RPO and RTO — defining recovery objectivesRPO and RTO · advanced · ~24 min
  3. 03Backup strategy and restore testingBackup strategy · advanced · ~26 min
  4. 04What is actually stateful — and why /var/lib/docker is not the answerState inventory · advanced · ~24 min
  5. 05Rebuilding a host from images plus volume backupsRebuild · advanced · ~26 min
  6. 06DR exercises — levels, cadence and the findings they produceExercise cadence · advanced · ~22 min

Part XXIII

High Availability

Standalone Docker limits, multi-host patterns, external load balancing, when orchestration is needed.

6 lessons
  1. 01Standalone Docker limits — when one host is not enoughStandalone limits · intermediate · ~24 min
  2. 02External load balancing — HA without an orchestratorExternal LB · intermediate · ~28 min
  3. 03Availability arithmetic — what a nine actually costsAvailability targets · intermediate · ~18 min
  4. 04What restart policies and healthchecks cannot recoverRecovery layers · intermediate · ~20 min
  5. 05Zero-downtime deploys without an orchestratorDeployment · advanced · ~24 min
  6. 06Failover, VIPs, and split-brain across two hostsFailover · advanced · ~22 min

Part XXIV

Reverse Proxies & TLS

nginx, HAProxy, Traefik, Caddy, HTTP versions, WebSockets.

6 lessons
  1. 01nginx as a Docker reverse proxynginx · intermediate · ~26 min
  2. 02HAProxy — TCP and HTTP load balancingHAProxy · advanced · ~26 min
  3. 03Traefik — container-native reverse proxyTraefik · intermediate · ~26 min
  4. 04Caddy — automatic HTTPS by defaultCaddy · intermediate · ~24 min
  5. 05Client IP through a proxy — X-Forwarded-For and the trust boundaryClient identity · advanced · ~20 min
  6. 06HTTP versions through a reverse proxy — 1.1, 2, 3 and WebSocket upgradesProtocols · advanced · ~20 min

Part XXV

Certificates & PKI

TLS, ACME, automated renewal, failure modes.

6 lessons
  1. 01TLS termination, ACME, and Let's EncryptTLS termination · intermediate · ~26 min
  2. 02Expired-certificate troubleshooting scenariosFailure lab · intermediate · ~26 min
  3. 03CA trust inside the container — works on the host, fails in the imageTrust stores · intermediate · ~22 min
  4. 04Registry TLS — certs.d, private CAs, and the insecure escape hatchRegistry trust · intermediate · ~20 min
  5. 05Protecting the daemon socket with mutual TLSDaemon PKI · advanced · ~24 min
  6. 06Delivering and rotating certificates into running containersLifecycle · advanced · ~20 min

Part XXVI

DNS & Service Discovery

Embedded DNS, troubleshooting.

6 lessons
  1. 01Embedded DNS — how service name resolution worksEmbedded DNS · intermediate · ~24 min
  2. 02Custom DNS for service discoveryCustom DNS · advanced · ~26 min
  3. 03Building the resolver — where a container gets /etc/resolv.confResolver configuration · intermediate · ~20 min
  4. 04Search domains and ndots — the lookups you did not ask forResolver configuration · advanced · ~20 min
  5. 05Names, aliases, and what breaks when they changeService identity · intermediate · ~18 min
  6. 06Resolver behaviour and timeouts — glibc, musl, and slow lookupsService identity · advanced · ~22 min

Part XXVII

Firewalls

nftables, iptables, ufw, Docker port exposure, effective validation.

6 lessons
  1. 01nftables and iptables — the host firewall in the Docker eraHost firewall · advanced · ~30 min
  2. 02Verifying actual network exposureVerifying exposure · intermediate · ~24 min
  3. 03Published ports bypass the host firewallThe bypass · advanced · ~24 min
  4. 04The DOCKER-USER chain, and making rules survive a rebootDOCKER-USER · advanced · ~24 min
  5. 05nftables hosts — which ruleset is actually in chargenftables · expert · ~22 min
  6. 06Limiting exposure by designExposure design · intermediate · ~20 min

Part XXVIII

Maintenance

Disk consumption, prune, build cache, image cleanup.

6 lessons
  1. 01Where the disk went — reading `docker system df` correctlyDisk accounting · intermediate · ~20 min
  2. 02Prune semantics — exactly what each variant deletesReclaiming disk · intermediate · ~24 min
  3. 03Build cache maintenance — the quiet largest consumerReclaiming disk · intermediate · ~22 min
  4. 04Image hygiene on the host — a retention policy you can defendImage hygiene · intermediate · ~22 min
  5. 05Volume lifecycle — orphans, anonymous volumes, and safe reclamationVolume hygiene · intermediate · ~24 min
  6. 06A maintenance schedule you can actually leave runningScheduling · intermediate · ~24 min

Part XXIX

Docker Upgrades

Change review, backups, rollback, maintenance window.

6 lessons
  1. 01What actually moves in a Docker upgradeUpgrade anatomy · intermediate · ~22 min
  2. 02Change review — what to read before you touch the packagesPre-upgrade · intermediate · ~24 min
  3. 03Pre-upgrade capture — what to save and what it is actually worthPre-upgrade · intermediate · ~22 min
  4. 04The in-place daemon upgrade — what happens to running containersExecution · advanced · ~26 min
  5. 05Rollback — putting Docker back the way it wasExecution · advanced · ~24 min
  6. 06Running the maintenance windowExecution · advanced · ~24 min

Part XXX

Host Maintenance

Kernel updates, reboots, security patching, filesystem maintenance.

6 lessons
  1. 01Host patching strategy — what a Docker host needs and how oftenPatching · intermediate · ~22 min
  2. 02Kernel updates — what every container inherits from the hostKernel · intermediate · ~22 min
  3. 03Planned reboot — what happens to containers, in orderReboots · intermediate · ~24 min
  4. 04Draining a Docker host before maintenanceDraining · advanced · ~24 min
  5. 05Filesystem maintenance for /var/lib/dockerStorage · advanced · ~26 min
  6. 06Post-maintenance verification — proving the host came backVerification · advanced · ~22 min

Part XXXI

Troubleshooting

Startup, networking, DNS, storage, OOM, TLS, daemon, logging, registry, dependencies.

6 lessons
  1. 01Troubleshooting framework — the systematic approachTroubleshooting · intermediate · ~30 min
  2. 02Container won't start — diagnosisContainer won't start · foundation · ~26 min
  3. 03Networking failures — packets not reaching the containerNetworking · intermediate · ~32 min
  4. 04Storage failures — out of disk, permission deniedStorage · intermediate · ~30 min
  5. 05Image pull failures — registry, auth, networkImage pull · foundation · ~26 min
  6. 06Performance problems — slow application, container, hostPerformance · advanced · ~34 min

Part XXXII

Docker Internals

dockerd, containerd, shim, runc, OCI runtime lifecycle.

6 lessons
  1. 01dockerd internals — what the daemon actually doesdockerd · advanced · ~30 min
  2. 02containerd and shims — the supervisor layercontainerd · advanced · ~28 min
  3. 03runc and the OCI runtimerunc · advanced · ~28 min
  4. 04The storage driver on disk — overlay2, and what replaced itStorage driver · expert · ~24 min
  5. 05Inspecting a container from the host — PIDs, namespaces, cgroupsHost-side inspection · expert · ~24 min
  6. 06The Engine API — what the CLI is really doingEngine API · advanced · ~22 min

Part XXXIII

Incident Response

Triage, evidence, containment, root cause, recovery, prevention.

6 lessons
  1. 01Triage — the first 15 minutes of an incidentTriage · intermediate · ~28 min
  2. 02Incident review — what makes a useful postmortemPostmortem · intermediate · ~26 min
  3. 03Evidence capture — what docker restart destroysEvidence · intermediate · ~22 min
  4. 04Containment — shrinking the blast radius without losing the evidenceContainment · intermediate · ~20 min
  5. 05Communication — roles, cadence, and the channel as the recordCommunication · intermediate · ~16 min
  6. 06Recovery — restart, roll back, restore, or rebuildRecovery · advanced · ~20 min

Part XXXIV

Capacity Planning

CPU, memory, disk, network, growth, operational headroom.

6 lessons
  1. 01Capacity planning for Docker hostsCapacity · intermediate · ~28 min
  2. 02Memory capacity — sizing limits against what the cgroup actually countsCapacity · advanced · ~26 min
  3. 03CPU capacity — quota, throttling, and the utilisation you can actually useCapacity · advanced · ~26 min
  4. 04Disk capacity — modelling how /var/lib/docker growsCapacity · intermediate · ~24 min
  5. 05Network capacity — bandwidth, connections, and the tables that fill upCapacity · advanced · ~24 min
  6. 06Growth, headroom, and the quarterly capacity reviewCapacity · advanced · ~26 min

Part XXXV

Production Hardening

Host, daemon, container, network, storage, image, secrets, monitoring, backup checklists.

6 lessons
  1. 01Host hardening — the production baselineHardening · advanced · ~30 min
  2. 02Daemon hardening — and the evidence that it took effectHardening · advanced · ~26 min
  3. 03Auditing the running fleet — container controls and their proofHardening · advanced · ~28 min
  4. 04Network and storage hardening — proving the boundaries holdHardening · advanced · ~28 min
  5. 05Image and secret hardening — proving nothing leakedHardening · advanced · ~28 min
  6. 06Keeping the posture — drift detection, audit trails and backup as a controlHardening · advanced · ~26 min

Part XXXVI

Automation

Shell, systemd, Ansible, CI/CD concepts.

6 lessons
  1. 01Automation with shell, systemd, and AnsibleAutomation · intermediate · ~30 min
  2. 02CI/CD for Docker images — build, scan, sign, pushCI/CD · advanced · ~30 min
  3. 03systemd units for Compose stacks — boot ordering and the racessystemd · advanced · ~26 min
  4. 04Idempotent shell automation — scripts that can run twiceShell · intermediate · ~24 min
  5. 05Ansible for Docker hosts — and the tasks that are not idempotentAnsible · advanced · ~26 min
  6. 06CI/CD failure modes — the green pipeline that ships a broken imageCI/CD · advanced · ~26 min

Part XXXVII

Orchestration Transition

Why orchestrators exist; Swarm, Kubernetes, Nomad at a glance.

6 lessons
  1. 01Orchestration — when Compose is not enoughOrchestration · advanced · ~28 min
  2. 02What an orchestrator actually does — the reconciliation loopThe orchestration model · advanced · ~22 min
  3. 03Cross-host networking and service discovery — the hard partThe orchestration model · advanced · ~24 min
  4. 04Docker Swarm at a glance — what you get and what it costsThe orchestrators · advanced · ~24 min
  5. 05Kubernetes at a glance — the object model and the operational billThe orchestrators · advanced · ~26 min
  6. 06Nomad at a glance, and choosing between the threeThe orchestrators · advanced · ~24 min

Part XXXVIII

Capstone

A complete production Docker environment, end-to-end.

6 lessons
  1. 01Capstone — the production Docker environmentCapstone · advanced · ~120 min
  2. 02Capstone stage 1 — the host under the environmentCapstone · advanced · ~45 minLab
  3. 03Capstone stage 2 — building and pinning the three imagesCapstone · advanced · ~50 minLab
  4. 04Capstone stage 3 — data plane, edge, and the first requestCapstone · advanced · ~55 minLab
  5. 05Capstone stage 4 — wiring observability to an SLOCapstone · advanced · ~50 minLab
  6. 06Capstone stage 5 — the DR drill and the go-live sign-offCapstone · expert · ~60 minLab

Part XXXIX

Break/Fix Scenarios

Deliberate operational incidents.

0 lessons
20 break/fix scenarios →

Part XL

Final Assessment

Production-readiness examination.

0 lessons

No lessons published in this part yet. The full curriculum is planned in docs/courses/docker/curriculum.md on GitHub.