Docker Cheatsheet Docker Cheatsheet

docker build -t myapp:1.0 .               # Build from Dockerfile in current dir
docker build -t myapp:1.0 -f prod.Dockerfile .   # Custom Dockerfile name
docker build --no-cache -t myapp:1.0 .    # Ignore build cache
docker tag myapp:1.0 registry.example.com/team/myapp:1.0
docker push registry.example.com/team/myapp:1.0
docker pull nginx:1.27-alpine
docker images                             # List local images
docker image inspect myapp:1.0            # Full metadata (JSON)
docker history myapp:1.0                  # Layer-by-layer sizes
docker save myapp:1.0 -o myapp.tar        # Export image to tarball
docker load -i myapp.tar                  # Import from tarball

docker run -d --name web -p 8080:80 nginx:1.27-alpine
docker run --rm -it ubuntu:24.04 bash     # Throwaway interactive container
docker run -d --restart unless-stopped -e TZ=America/Edmonton myapp:1.0

docker ps                                 # Running containers
docker ps -a                              # Include stopped ones
docker exec -it web sh                    # Shell into a running container
docker exec web env                       # One-off command, no TTY
docker logs web                           # Dump logs
docker logs -f --tail 100 web             # Follow, last 100 lines
docker logs --since 15m web               # Logs from the last 15 minutes
docker inspect web                        # Full JSON: mounts, IP, env, state
docker inspect -f '{{ .NetworkSettings.IPAddress }}' web
docker stats                              # Live CPU/mem/net per container
docker top web                            # Processes inside the container
docker cp web:/etc/nginx/nginx.conf ./    # Copy files out (or in)
docker stop web && docker rm web          # Stop then remove
docker kill web                           # SIGKILL immediately

# Stage 1: build
FROM golang:1.24-alpine AS builder
WORKDIR /src
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 go build -ldflags="-s -w" -o /app ./cmd/server

# Stage 2: minimal runtime
FROM alpine:3.21
RUN adduser -D -u 10001 appuser
COPY --from=builder /app /app
USER appuser
EXPOSE 8080
ENTRYPOINT ["/app"]

docker volume create pgdata
docker volume ls
docker volume inspect pgdata              # Shows host mountpoint
docker volume rm pgdata

docker network create backend             # User-defined bridge (has DNS)
docker network ls
docker network inspect backend
docker network connect backend web       # Attach a running container
docker network disconnect backend web

# Bind mount (host path) vs named volume
docker run -v $(pwd)/conf:/etc/nginx/conf.d:ro nginx   # bind, read-only
docker run -v pgdata:/var/lib/postgresql/data postgres # named volume

docker compose up -d                      # Start stack in background
docker compose up -d --build              # Rebuild images first
docker compose down                       # Stop and remove containers/networks
docker compose down -v                    # ...and volumes (destructive!)
docker compose ps                         # Status of services
docker compose logs -f api                # Follow one service's logs
docker compose exec api sh               # Shell into a service
docker compose restart worker            # Restart one service
docker compose pull                       # Refresh images

services:
  api:
    build: .
    ports:
      - "8080:8080"
    environment:
      DATABASE_URL: postgres://app:secret@db:5432/app
    depends_on:
      db:
        condition: service_healthy
    restart: unless-stopped

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

volumes:
  pgdata:

docker system df                          # What's eating disk
docker system prune                       # Stopped containers, dangling images, unused networks
docker system prune -a --volumes          # Everything unused, incl. volumes - careful
docker image prune                        # Dangling images only
docker image prune -a                     # All images not used by a container
docker container prune                    # All stopped containers
docker volume prune                       # Unused volumes
docker builder prune                      # Build cache

docker logs --details web                          # Extra log metadata
docker inspect -f '{{ .State.ExitCode }}' web      # Why did it die?
docker inspect -f '{{ json .State.Health }}' web | jq   # Healthcheck history
docker events --filter container=web               # Live daemon events
docker run --rm -it --entrypoint sh myapp:1.0      # Bypass a crashing entrypoint
docker exec -it web sh -c 'wget -qO- localhost:8080/healthz'   # Test from inside
docker run --rm --network container:web nicolaka/netshoot      # Netshoot in the container's netns
docker diff web                                    # Files changed since start