Docker

Container Management

# Run a container
docker run <image>
docker run -d <image>              # Detached mode
docker run -it <image> /bin/bash   # Interactive terminal
docker run --name myapp <image>    # Named container
docker run -p 8080:80 <image>      # Port mapping
docker run -v /host:/container <image>  # Volume mount
docker run --rm <image>            # Remove after exit
docker run -e VAR=value <image>    # Environment variable
docker run --env-file .env <image> # Env file

# List containers
docker ps                # Running containers
docker ps -a             # All containers
docker ps -q             # Only IDs

# Start/Stop containers
docker start <container>
docker stop <container>
docker restart <container>
docker kill <container>  # Force stop

# Remove containers
docker rm <container>
docker rm -f <container>       # Force remove
docker container prune         # Remove all stopped

Image Management

# List images
docker images
docker images -a         # Include intermediate

# Pull/Push images
docker pull <image>:<tag>
docker push <image>:<tag>

# Build image
docker build -t <name>:<tag> .
docker build -f Dockerfile.dev -t <name> .
docker build --no-cache -t <name> .

# Tag image
docker tag <image> <new-name>:<tag>

# Remove images
docker rmi <image>
docker image prune       # Remove unused
docker image prune -a    # Remove all unused

Dockerfile

# Base image
FROM node:18-alpine

# Set working directory
WORKDIR /app

# Copy package files
COPY package*.json ./

# Install dependencies
RUN npm install

# Copy source code
COPY . .

# Build application
RUN npm run build

# Expose port
EXPOSE 3000

# Environment variables
ENV NODE_ENV=production

# Run command
CMD ["npm", "start"]

# Alternative: Entrypoint
ENTRYPOINT ["node", "server.js"]

Multi-stage Build

# Build stage
FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# Production stage
FROM node:18-alpine AS production
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
EXPOSE 3000
CMD ["node", "dist/server.js"]

Docker Compose

# docker-compose.yml
version: '3.8'

services:
  web:
    build: .
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://db:5432/mydb
    depends_on:
      - db
    volumes:
      - ./src:/app/src
    networks:
      - app-network

  db:
    image: postgres:15
    environment:
      POSTGRES_DB: mydb
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
    volumes:
      - postgres-data:/var/lib/postgresql/data
    networks:
      - app-network

volumes:
  postgres-data:

networks:
  app-network:
    driver: bridge

Compose Commands

# Start services
docker-compose up
docker-compose up -d           # Detached
docker-compose up --build      # Rebuild images
docker-compose up --scale web=3  # Scale service

# Stop services
docker-compose down
docker-compose down -v         # Remove volumes
docker-compose down --rmi all  # Remove images

# Manage services
docker-compose start
docker-compose stop
docker-compose restart
docker-compose pause
docker-compose unpause

# View logs
docker-compose logs
docker-compose logs -f         # Follow
docker-compose logs web        # Specific service

# Execute command
docker-compose exec web sh
docker-compose run web npm test

Logs & Debugging

# View logs
docker logs <container>
docker logs -f <container>       # Follow
docker logs --tail 100 <container>  # Last 100 lines
docker logs --since 1h <container>  # Last hour

# Execute command in container
docker exec -it <container> sh
docker exec -it <container> /bin/bash
docker exec <container> ls -la

# Inspect container
docker inspect <container>
docker inspect --format='{{.NetworkSettings.IPAddress}}' <container>

# Resource usage
docker stats
docker stats <container>

# Container processes
docker top <container>

Networking

# List networks
docker network ls

# Create network
docker network create <name>
docker network create --driver bridge <name>

# Connect/disconnect
docker network connect <network> <container>
docker network disconnect <network> <container>

# Inspect network
docker network inspect <network>

# Remove network
docker network rm <network>
docker network prune

Volumes

# List volumes
docker volume ls

# Create volume
docker volume create <name>

# Inspect volume
docker volume inspect <name>

# Remove volume
docker volume rm <name>
docker volume prune

# Use volume in run
docker run -v <volume>:/path <image>
docker run -v /host/path:/container/path <image>
docker run -v /container/path <image>  # Anonymous volume

System Commands

# System info
docker info
docker version

# Disk usage
docker system df
docker system df -v

# Clean up
docker system prune           # Remove unused data
docker system prune -a        # Include images
docker system prune --volumes # Include volumes

# Events
docker events
docker events --filter 'container=myapp'

Useful Patterns

# Copy files from container
docker cp <container>:/path/file ./local/path

# Copy files to container
docker cp ./local/file <container>:/path/

# Export/Import container
docker export <container> > container.tar
docker import container.tar <image>

# Save/Load image
docker save <image> > image.tar
docker load < image.tar

# Run one-off command
docker run --rm -it <image> <command>

# Check container health
docker inspect --format='{{.State.Health.Status}}' <container>