Docker Commands Cheat Sheet

Docker’s CLI gives you full control over containers, images, volumes, and networks from the terminal. This docker commands cheatsheet organizes the complete commands list by task — from your first docker run through multi-service Compose stacks and Dockerfile authoring — so you can find what you need without digging through docs.

Quick-Start Docker Tutorial

New to Docker? These commands take you from zero to a running container in under two minutes.

docker pull nginx:latest
docker run -d --name my-nginx -p 8080:80 nginx
docker ps
docker stop my-nginx && docker rm my-nginx

That is the entire container lifecycle in six steps. Visit http://localhost:8080 after step 3 — NGINX welcome page confirms it is running. The sections below cover every flag, variation, and related command.

docker run Commands and Flags

docker run creates a new container from an image and starts it immediately. It is the single most-used entry in any docker commands list. Full syntax: docker run [OPTIONS] IMAGE [COMMAND] [ARG...].

docker run --rm \
  -e NODE_ENV=production \
  --env-file .env.production \
  -v "$(pwd)/app":/usr/src/app \
  -w /usr/src/app \
  -p 3000:3000 \
  --memory 512m \
  --cpus 1 \
  node:20-alpine npm start

One-off Python script — container disappears on exit:

docker run --rm -it python:3.12-slim python
docker run --rm -v "$(pwd)":/work -w /work python:3.12-slim python migrate.py

Full flag reference: https://docs.docker.com/engine/reference/run/

Container Lifecycle Commands

These commands manage the full lifecycle from creation to deletion.

docker stop --time 60 my-app
docker rm my-app
docker container prune --force
docker wait my-batch-job

Container Inspection and Logs

Monitor what is happening inside running containers without attaching to them directly.

docker logs -f --timestamps api
docker exec my-db psql -U postgres -c "SELECT COUNT(*) FROM users;"
docker stats --no-stream --format "table {{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}"
docker inspect my-app --format '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}'

Docker Image Commands

Images are read-only templates that containers run from. Every docker build produces a layered image stored locally.

docker build -t my-api:3.0 .
docker tag my-api:3.0 username/my-api:3.0
docker tag my-api:3.0 username/my-api:latest
docker login
docker push username/my-api:3.0 && docker push username/my-api:latest
docker image prune -a --filter "until=72h" --force

Dockerfile Instructions Reference

A Dockerfile is the script that defines how a docker image is built — each instruction creates a cached layer. Writing a well-structured dockerfile is the foundation of a lean, reproducible container image.

FROM node:20-alpine AS deps
WORKDIR /app
COPY package*.json ./
RUN npm ci --omit=dev

FROM node:20-alpine AS builder
WORKDIR /app
COPY --from=deps /app/node_modules ./node_modules
COPY . .
RUN npm run build

FROM node:20-alpine AS runner
WORKDIR /app
ENV NODE_ENV=production
COPY --from=builder /app/dist ./dist
COPY --from=deps /app/node_modules ./node_modules
EXPOSE 3000
USER node
HEALTHCHECK --interval=30s --timeout=5s CMD wget -qO- http://localhost:3000/health || exit 1
CMD ["node", "dist/server.js"]

The three-stage build discards all build tooling from the final image. Only compiled output and production node_modules are copied into the runner stage, keeping the image small and the attack surface minimal. Use docker build --target deps . to build only through the first stage.

Volume and Network Commands

Volumes provide persistent storage independent of container lifecycles. Networks control how containers discover and communicate with each other.

Volume Commands

Network Commands

docker network create app-net
docker run -d --name db \
  --network app-net \
  -e POSTGRES_PASSWORD=secret \
  -v pgdata:/var/lib/postgresql/data \
  postgres:16
docker run -d --name api \
  --network app-net \
  -e DATABASE_URL=postgres://postgres:secret@db/app \
  -p 8080:8080 \
  my-api:latest

Containers on the same network reach each other by container name — no IP addresses required. The api container resolves db automatically.

Docker Compose Commands

Docker Compose manages multi-service stacks defined in compose.yml (or docker-compose.yml). Official reference: https://docs.docker.com/compose/reference/.

services:
  web:
    build: .
    ports:
      - "8000:8000"
    environment:
      - DATABASE_URL=postgres://postgres:secret@db/myapp
    depends_on:
      db:
        condition: service_healthy
    restart: unless-stopped

  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_PASSWORD: secret
      POSTGRES_DB: myapp
    volumes:
      - pgdata:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 5s
      timeout: 5s
      retries: 5

volumes:
  pgdata:

docker compose up -d --build
docker compose run --rm web python manage.py migrate
docker compose logs -f web
docker compose scale worker=4

For deeper debugging of service output, the Docker Compose Logs guide covers filtering, timestamps, and per-service log redirection.

System and Cleanup Commands

docker system df
docker container prune --force && docker image prune --force
docker builder prune --filter "until=24h" --force
docker system prune -a --volumes --force

Keep this docker cheatsheet alongside the Linux Commands Cheat Sheet and the Git Commands Cheat Sheet — together they cover most daily terminal work. The curl Command guide pairs well for testing container HTTP endpoints once services are running.