Docker for Developers: A Practical Getting-Started Guide

Table of Contents

• Why Docker?
• Key Concepts
• Your First Dockerfile
• Essential Docker Commands
• Docker Compose
• Best Practices

Why Docker?

"Works on my machine" is the classic developer problem. Docker packages your app with everything it needs — runtime, dependencies, configuration — into a container that runs identically everywhere: local dev, CI, staging, production.

Key Concepts

• Image: A blueprint (read-only template) for creating containers — like a class in OOP
• Container: A running instance of an image — like an object
• Dockerfile: Instructions to build a custom image
• Docker Compose: Tool for running multi-container apps (app + database + cache)
• Registry: Storage for images (Docker Hub, GitHub Container Registry)

Your First Dockerfile

Containerizing a Node.js app:

# Use official Node.js LTS image as base
FROM node:20-alpine

# Set working directory inside container
WORKDIR /app

# Copy package files first (better layer caching)
COPY package*.json ./
RUN npm ci --omit=dev

# Copy source code
COPY . .

# Create non-root user for security
RUN addgroup -S appgroup && adduser -S appuser -G appgroup
USER appuser

# Expose port and define startup command
EXPOSE 3000
CMD ["node", "server.js"]

# Build the image
docker build -t my-app:latest .

# Run a container from it
docker run -p 3000:3000 my-app:latest

Essential Docker Commands

# Images
docker images                      # list images
docker pull node:20-alpine         # download image
docker rmi my-app:latest           # delete image

# Containers
docker ps                          # list running containers
docker ps -a                       # include stopped containers
docker run -d -p 3000:3000 my-app  # run in background
docker stop <id>                   # stop container
docker logs <id>                   # view logs
docker exec -it <id> sh            # open shell inside container

# Cleanup
docker system prune                # remove unused data

Docker Compose

Define your entire application stack in one file:

# docker-compose.yml
services:
  app:
    build: .
    ports:
      - '3000:3000'
    environment:
      - DATABASE_URL=postgresql://user:pass@db:5432/myapp
    depends_on:
      - db

  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: pass
      POSTGRES_DB: myapp
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:

docker compose up -d      # start everything
docker compose down       # stop and remove containers
docker compose logs -f    # follow logs

Best Practices

• Use alpine base images to minimize size (node:20-alpine vs node:20 = ~200MB difference)
• Copy package.json before source code to cache npm install layer
• Use .dockerignore to exclude node_modules, .git, *.env
• Never run as root in production containers
• Use multi-stage builds to keep production images small