Free through lesson 3

Docker for Beginners

From installing Docker through images and containers, ports and networks, volumes, Dockerfiles, multi-stage builds, registries, Docker Compose and troubleshooting. Twenty lessons that take you to the point where you can bring up a development environment from a single compose.yaml — and work out for yourself what is wrong when it will not start. Every command and its output was produced by actually running it.

Start from lesson 1 Unlock every course

Curriculum

The 20 lessons are grouped into five chapters. Working through them in order is the best way, but you are welcome to dip into whatever interests you. Note: Docker commands cannot run inside the browser. Install Docker Desktop (or Podman or Colima) and try them in your own terminal as you follow along.

Chapter 1 — Running containers (lessons 1–5)

You sort out what Docker is for by contrasting it with virtual machines, then cover the four foundations: images, containers, ports and volumes. By the end, data you cannot afford to lose lives outside the container.

What Docker is

Sorting out the difference from a virtual machine by whether the kernel is shared. Installing it and running hello-world and nginx.

Free

Images versus containers

An image is read-only layers; a container is one writable layer on top of them. Measuring for yourself why creating many containers from one image uses no extra space.

Free

The container lifecycle

Which command moves you between Created, Up, Paused and Exited. The cause of "I started it with -d and it exited immediately", and the difference between stop, kill and rm.

Free

Ports and communication between containers

What the two sides of -p mean, name resolution on a user-defined network, and the very common trip-up that localhost inside a container is that container itself.

Volumes and bind mounts

The two ways of keeping data after a container is gone, and when to use each. Including the overwrite rules when files already exist at the mount point.

Chapter 2 — Building your own images (lessons 6–10)

You write a Dockerfile and build an image with your own app inside it. Once you understand layers and the build cache, builds go from minutes to seconds and image sizes drop by an order of magnitude.

Dockerfile basics

Turning your app into an image with fewer than ten lines. What FROM, WORKDIR, COPY, EXPOSE and CMD do, and why you write them in exec form.

Layers and the build cache

Moving two COPY lines takes a rebuild from 7.95 seconds to 0.21. Why a deleted file is still there, and when to combine commands with &&.

.dockerignore and the build context

What that final "." in docker build actually is. A .dockerignore you can write in five minutes takes 255MB down to 161MB, and stops .env being baked in.

Multi-stage builds

Separating what you need to build from what you need to run. 325MB to 13.7MB in Go, 230MB to 163MB in TypeScript.

ENTRYPOINT and CMD

What runs is ENTRYPOINT plus CMD. How to build a container that takes arguments, and why an entrypoint script needs exec "$@".

Chapter 3 — Distribution and Docker Compose (lessons 11–14)

You tag your image and push it to a registry, then move on to compose.yaml. Instead of starting containers one at a time by hand, you bring several services up together.

Tags and registries

A tag is a label you can move; a digest is the immutable thing itself. Standing up a local registry to push and pull, and measuring why latest has no place in production.

Docker Compose basics

Putting that long docker run into a file. How compose.yaml maps onto docker run, the names generated for you, and the one-character difference between down and down -v.

Connecting several services

Wiring Node.js, PostgreSQL and Redis together by service name. Keeping the database off the outside world, and isolating things by splitting networks.

Environment variables and externalising configuration

The difference between .env, environment and env_file, and which wins. A demonstration that a secret in ENV is readable via docker history, and passing build-time secrets with a secret mount.

Chapter 4 — Using it as a development environment (lessons 15–17)

You add what a day-to-day development environment needs: start-up order, health checks, hot reload. Finally you turn "where do I look when it will not work?" into a routine you can follow.

Start-up order and health checks

depends_on alone cannot wait for the database to be ready. Enforcing the order with healthcheck and condition: service_healthy, and why the app should still retry anyway.

Compose as a development environment

Making saving take effect immediately. The disappearing node_modules problem, why file watching does not reach through, and splitting dev from production with compose.override.yaml.

Troubleshooting

Systematically eliminating "it just will not work". State, logs, details, resources, networking — in that order, what to type and what to read in the output.

Chapter 5 — Operations and safety (lessons 18–20)

You clear out accumulated images and volumes and configure containers to run safely. The chapter closes by looking back over the course and mapping out what lies beyond it.

Cleaning up and managing disk space

Seeing what is using the space and removing it lowest-risk first. Why docker system prune -a --volumes is not something to type lightly.

Security basics

The default is root. USER, .dockerignore, exposure, scanning and dropping privileges organised around one idea, boiled down to eight things you can do today.

Wrapping up and what comes next

Folding 20 lessons into four concepts and three principles. With cheat sheets for the commands, the Dockerfile and compose.yaml, and an index of problems by symptom.

Once you have finished all 20 lessons, look at Linux — the server your containers run on — or shore up your defences before going live with Python Security. Membership unlocks every course.