docker-setup

name	docker-setup
description	Docker containerization setup and configuration. Use when containerizing applications, creating development environments, or setting up deployment workflows.

Purpose

Package applications and their dependencies into containers for consistent deployment across environments.

When to Use

• Containerizing applications
• Creating reproducible development environments
• Setting up microservices
• Deploying to production
• Isolating dependencies

Installation

Linux

curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh
sudo usermod -aG docker $USER

macOS

# Install Docker Desktop
brew install --cask docker

Windows

# Install Docker Desktop from https://docker.com/products/docker-desktop

Dockerfile Basics

Simple Node.js App

FROM node:20-alpine
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
EXPOSE 3000
CMD ["npm", "start"]

Python App

FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
EXPOSE 8000
CMD ["python", "app.py"]

Multi-stage Build

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

# Production stage
FROM node:20-alpine AS production
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY package*.json ./
RUN npm install --production
EXPOSE 3000
CMD ["node", "dist/index.js"]

Common Dockerfile Patterns

React App

FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

FROM nginx:alpine
COPY --from=builder /app/build /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

Next.js App

FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

FROM node:20-alpine AS runner
WORKDIR /app
ENV NODE_ENV production
COPY --from=builder /app/public ./public
COPY --from=builder /app/.next/standalone ./
COPY --from=builder /app/.next/static ./.next/static
EXPOSE 3000
CMD ["node", "server.js"]

Go App

FROM golang:1.21-alpine AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 go build -o app

FROM alpine:latest
WORKDIR /root/
COPY --from=builder /app/app .
EXPOSE 8080
CMD ["./app"]

Docker Compose

Basic Web App + Database

version: '3.8'
services:
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - DATABASE_URL=postgres://user:pass@db:5432/mydb
    depends_on:
      - db

  db:
    image: postgres:15-alpine
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=pass
      - POSTGRES_DB=mydb
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:

Development Environment

version: '3.8'
services:
  app:
    build: .
    volumes:
      - .:/app
      - /app/node_modules
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=development
    command: npm run dev

Multi-Service Setup

version: '3.8'
services:
  frontend:
    build: ./frontend
    ports:
      - "3000:3000"

  backend:
    build: ./backend
    ports:
      - "8000:8000"
    environment:
      - DATABASE_URL=postgres://user:pass@db:5432/mydb

  db:
    image: postgres:15-alpine
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=pass
      - POSTGRES_DB=mydb
    volumes:
      - postgres_data:/var/lib/postgresql/data

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"

volumes:
  postgres_data:

Docker Compose Commands

# Start services
docker-compose up

# Start in detached mode
docker-compose up -d

# Stop services
docker-compose down

# Rebuild and start
docker-compose up --build

# View logs
docker-compose logs -f

# Execute command in container
docker-compose exec app sh

# View running containers
docker-compose ps

# Remove volumes
docker-compose down -v

Docker Commands

Images

# Build image
docker build -t myapp:1.0 .

# List images
docker images

# Remove image
docker rmi myapp:1.0

# Pull image
docker pull node:20-alpine

# Push image
docker push myrepo/myapp:1.0

Containers

# Run container
docker run -p 3000:3000 myapp:1.0

# Run in detached mode
docker run -d -p 3000:3000 myapp:1.0

# List containers
docker ps

# Stop container
docker stop <container-id>

# Remove container
docker rm <container-id>

# Execute command
docker exec -it <container-id> sh

Volumes

# Create volume
docker volume create myvolume

# List volumes
docker volume ls

# Remove volume
docker volume rm myvolume

Networks

# Create network
docker network create mynetwork

# List networks
docker network ls

# Connect container to network
docker network connect mynetwork mycontainer

Best Practices

Dockerfile

• Use specific base image tags (not latest)
• Use multi-stage builds for smaller images
• Combine RUN commands to reduce layers
• Use .dockerignore to exclude files
• Run as non-root user when possible
• Set HEALTHCHECK for monitoring
• Use build args for configuration

Docker Compose

• Use version 3.8+ for compatibility
• Define volumes for persistent data
• Use environment variables for configuration
• Set resource limits
• Use depends_on for service dependencies
• Use restart policies for production

Security

• Scan images for vulnerabilities
• Use official base images
• Keep images updated
• Don't run as root
• Use secrets management
• Limit container capabilities

.dockerignore

node_modules
npm-debug.log
.git
.env
.DS_Store
coverage
.next
dist
build
*.log

Common Issues

Container Won't Start

# Check logs
docker logs <container-id>

# Check if port is in use
netstat -tulpn | grep <port>

# Check container status
docker ps -a

Out of Space

# Remove unused images
docker image prune -a

# Remove unused containers
docker container prune

# Remove unused volumes
docker volume prune

# Remove everything unused
docker system prune -a

Permission Issues

# Add user to docker group
sudo usermod -aG docker $USER

# Fix file permissions
docker run -u $(id -u):$(id -g) ...

Production Deployment

Docker Registry

# Login to registry
docker login registry.example.com

# Tag image
docker tag myapp:1.0 registry.example.com/myapp:1.0

# Push image
docker push registry.example.com/myapp:1.0

Docker Swarm

# Initialize swarm
docker swarm init

# Deploy stack
docker stack deploy -c docker-compose.yml mystack

# List services
docker service ls

# Scale service
docker service scale mystack_app=3

Kubernetes (using Kompose)

# Install kompose
curl -L https://github.com/kubernetes/kompose/releases/download/v1.28.0/kompose-linux-amd64 -o kompose
chmod +x kompose
sudo mv kompose /usr/local/bin/

# Convert docker-compose to kubernetes
kompose convert

# Apply to kubernetes
kubectl apply -f .

Scripts

build.sh

#!/bin/bash
docker build -t myapp:$(git rev-parse --short HEAD) .

deploy.sh

#!/bin/bash
docker-compose down
docker-compose up -d --build
docker-compose logs -f

clean.sh

#!/bin/bash
docker-compose down -v
docker system prune -a