Learn Docker in 7 Easy Steps - Full Beginner's Tutorial

Docker is a practical way to package software so it runs the same way on any machine—solving the classic “it works on my machine” problem by reproducing the exact runtime environment. That promise comes from three core building blocks: Dockerfiles (blueprints), Docker images (immutable templates built from those blueprints), and Docker containers (running processes created from an image). A developer defines the environment in a Dockerfile, the build produces an image snapshot, and anyone can pull that image from a registry to spawn identical containers—making deployment and scaling far more predictable. This consistency is why tools like Kubernetes and swarm can later scale containers across large workloads.

The tutorial then walks through a beginner-to-intermediate workflow using a containerized Node.js app. It starts with installation: Docker Desktop is recommended for macOS and Windows because it provides the command-line tooling plus a GUI to inspect containers. From the terminal, the key command is `docker ps`, which lists running containers along with unique IDs and the image each container is based on. For authoring Dockerfiles, it recommends installing a Docker extension for VS Code (or another IDE) to get language support and smoother integration with registries.

The centerpiece is the Dockerfile. It begins with a `FROM` instruction that selects a base image; rather than using a generic Ubuntu image and installing Node manually, it uses the officially supported Node.js base image (Node version 12). Next comes `WORKDIR` to set the working directory inside the container, followed by a layered build strategy that improves caching. The Dockerfile copies `package.json` first, runs `npm install`, and commits the installed dependencies as a cached layer. Only after that does it copy the application source code. To avoid overwriting container-installed dependencies with local ones, it uses a `.dockerignore` file (modeled after `.gitignore`) to exclude `node_modules` from being copied into the image.

To run the app, the Dockerfile sets environment variables with `ENV`, declares the service port (listening on port 8080), and finishes with a single `CMD` instruction in exec form (array of strings) to start the Express server without launching an extra shell. Building the image uses `docker build` with `-t` to tag it (for example, `fireship/demo-app`). After a successful build, the image can be pushed to a registry with `docker push` and later pulled elsewhere with `docker pull`, but locally it’s run with `docker run`.

A common stumbling block follows: exposing a port in the Dockerfile doesn’t automatically make it reachable from the host. The fix is port forwarding using `-p`, mapping a host port (like 5000) to the container’s port 8080. The tutorial also covers operational realities: containers keep running even after the terminal closes, and stopping a container can discard its internal state. For persistent shared data, it introduces volumes—host-backed folders created with `docker volume create` and mounted into containers so files survive restarts and can be shared across multiple containers.

Finally, it addresses debugging and multi-service setups. Docker Desktop provides log viewing and an interactive CLI entry point, while `docker exec` enables command-line access from the terminal. For “one container, one process,” it recommends microservice design and introduces `docker compose` to orchestrate multiple containers via a `docker-compose.yaml` file—such as a Node.js `web` service plus a `db` MySQL service with a persistent volume—managed together with `docker compose up` and stopped with `docker compose down`. The result is a complete path from Docker fundamentals to practical deployment patterns.