WITHOUT Docker:
Your app: "Works on my laptop! 🎉"
Server:    "Doesn work. Node version wrong. Library missing. OS different." 💀

WITH Docker:
Your app: "Here's a box with everything inside. Run this box." 📦
Server:    "Running the box. Works perfectly." ✅

Virtual Machine:
┌─────────────────────────────────────┐
│         Host Operating System        │
│  ┌───────────────────────────────┐  │
│ │       Guest OS (full Linux)     │  │
│ │  ┌─────────────────────────┐   │  │
│  │  │     Your App           │   │  │
│  │  │     + Dependencies     │   │  │
│  │  └─────────────────────────┘   │  │
│  └───────────────────────────────┘  │
└─────────────────────────────────────┘
Heavy: Full OS per VM = GBs of space, minutes to boot


Docker Container:
┌─────────────────────────────────────┐
│         Host Operating System        │
│  ┌───────────────────────────────┐  │
│ │      Docker Engine            │  │
│ │  ┌─────┐ ┌─────┐ ┌─────┐     │  │
│  │ │ App1│ │ App2│ │ App3│     │  │
│  │ └─────┘ └─────┘ └─────┘     │  │
│  └───────────────────────────────┘  │
└─────────────────────────────────────┘
Light: Shared kernel = MBs, seconds to start

# Dockerfile — instructions to build your container image

# Base image (start from something that already exists)
FROM node:22-alpine

# Set working directory
WORKDIR /app

# Copy package files first (layer caching!)
COPY package*.json ./

# Install dependencies
RUN npm ci --only=production

# Copy source code
COPY . .

# Expose port
EXPOSE 3000

# Command to run
CMD ["node", "server.js"]

# Build an image from Dockerfile
docker build -t myapp:v1 .

# List images
docker images

# Remove image
docker rmi myapp:v1

# Run a container from an image
docker run -d -p 3000:3000 --name myapp myapp:v1

# List running containers
docker ps

# Stop container
docker stop myapp

# Start stopped container
docker start myapp

# Remove container
docker rm myapp

// server.js
const http = require('http');
const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'application/json' });
  res.end(JSON.stringify({ 
    message: 'Hello from Docker!', 
    time: new Date().toISOString(),
    hostname: require('os').hostname()
  }));
});
server.listen(3000, () => console.log('Running on :3000'));

// package.json
{
  "name": "docker-demo",
  "version": "1.0.0",
  "main": "server.js"
}

# Dockerfile
FROM node:22-alpine
WORKDIR /app
COPY package*.json .
RUN npm install
COPY . .
EXPOSE 3000
CMD ["node", "server.js"]

# .dockerignore (like .gitignore for Docker)
node_modules
Dockerfile
.git
.env
npm-debug.log

# Build the image
docker build -t docker-demo .

# Run it!
docker run -d -p 3000:3000 docker-demo

# Test it
curl http://localhost:3000
# {"message":"Hello from Docker!","time":"...","hostname":"abc123"}

# It's running in a container! 🎉

# docker-compose.yml
version: '3.8'

services:
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - DATABASE_URL=postgres://user:pass@db:5432/mydb
      - REDIS_URL=redis://redis:6379
    depends_on:
      - db
      - redis
    restart: unless-stopped

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

  redis:
    image: redis:7-alpine
    volumes:
      - redis_data:/data
    restart: unless-stopped

volumes:
  postgres_data:
  redis_data:

# Start all services
docker compose up -d

# View logs of all services
docker compose logs -f

# Logs of one service
docker compose logs -f app

# Stop everything
docker compose down

# Stop + remove volumes (fresh start)
docker compose down -v

# Rebuild after code changes
docker compose up -d --build

# Stage 1: Build
FROM node:22 AS builder
WORKDIR /app
COPY package*.json .
RUN npm ci
COPY . .
RUN npm run build

# Stage 2: Production (much smaller!)
FROM node:22-alpine AS production
WORKDIR /app
COPY --from=builder /app/node_modules ./node_modules
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/package.json ./
EXPOSE 3000
CMD ["node", "dist/server.js"]

# Always exclude these
node_modules
dist
build
.git
.gitignore
*.md
.env.env.*
!.env.example
Dockerfile
docker-compose.yml
.npmrc
coverage
.vscode
.idea

FROM node:22-alpine

# Create non-root user
RUN addgroup -g 1001 appgroup && \
    adduser -u 1001 -G appgroup -s /bin/sh -D appuser

WORKDIR /app
COPY --chown=appuser:appgroup . .

USER appuser

EXPOSE 3000
CMD ["node", "server.js"]

FROM node:22-alpine
WORKDIR /app
COPY . .
RUN npm ci
EXPOSE 3000

HEALTHCHECK --interval=30s --timeout=3s \
  CMD wget --no-verbose --tries=1 --spider http://localhost:3000/health || exit 1

CMD ["node", "server.js"]

# Docker builds use layer caching. Force rebuild:
docker build --no-cache -t myapp .

# Or with Compose:
docker compose up -d --build

# Check why:
docker logs <container-name>

# Common causes:
# 1. Process crashes → fix the error in logs
# 2. No foreground process → use CMD or entrypoint
# 3. Port conflict → change port mapping

# Shell into a running container
docker exec -it <container-name> sh

# Check file system
ls -la /app

# Check installed packages
cat /etc/os-release
node -v
npm -v

# Test commands manually
node -e "console.log(require('./package.json'))"

# Clean up Docker
docker system prune -af --volumes

# Check what's using space
docker system df