Docker Compose Creator

Design and manage multi-container applications with Docker Compose for both development and production deployments.

When to Use

• Setting up local development environments

• Defining multi-service application stacks

• Managing service dependencies

• Configuring networking between services

• Environment variable management

• Production deployments (single host)

• Testing multi-service interactions

Docker Compose Versions

Version Released Features Use Case

v3.x 2016 Service definitions, networks Legacy (avoid for new projects)

v2.x 2014 Legacy format Not recommended

v3.14 2023 Full features, modern syntax Current default

Use version 3.14 or later for new projects.

Basic Structure

version: '3.14'

services:

Service definitions go here

volumes:

Named volumes

networks:

Custom networks

Full-Featured Example: Web Application Stack

version: '3.14'

services:

Frontend (Nginx)

nginx: image: nginx:1.25-alpine container_name: webapp-nginx ports: - "80:80" - "443:443" volumes: - ./nginx.conf:/etc/nginx/nginx.conf:ro - ./ssl:/etc/nginx/ssl:ro depends_on: - api networks: - frontend restart: unless-stopped healthcheck: test: ["CMD", "wget", "--quiet", "--tries=1", "--spider", "http://localhost/health"] interval: 30s timeout: 5s retries: 3 start_period: 10s

API Server (Node.js)

api: build: context: ./api dockerfile: Dockerfile target: production container_name: webapp-api environment: - NODE_ENV=production - DATABASE_HOST=postgres - REDIS_HOST=redis - LOG_LEVEL=info depends_on: postgres: condition: service_healthy redis: condition: service_started networks: - frontend - backend restart: unless-stopped healthcheck: test: ["CMD", "curl", "-f", "http://localhost:3000/health"] interval: 30s timeout: 5s retries: 3 start_period: 10s logging: driver: "json-file" options: max-size: "10m" max-file: "3"

PostgreSQL Database

postgres: image: postgres:15-alpine container_name: webapp-db environment: - POSTGRES_DB=myapp - POSTGRES_USER=appuser - POSTGRES_PASSWORD=${DB_PASSWORD:?Database password required} volumes: - postgres_data:/var/lib/postgresql/data - ./init-scripts:/docker-entrypoint-initdb.d:ro networks: - backend restart: unless-stopped healthcheck: test: ["CMD-SHELL", "pg_isready -U appuser -d myapp"] interval: 10s timeout: 5s retries: 5 start_period: 10s logging: driver: "json-file" options: max-size: "10m" max-file: "3"

Redis Cache

redis: image: redis:7-alpine container_name: webapp-cache command: redis-server --requirepass ${REDIS_PASSWORD:?Redis password required} volumes: - redis_data:/data networks: - backend restart: unless-stopped healthcheck: test: ["CMD", "redis-cli", "ping"] interval: 10s timeout: 5s retries: 5

Background Worker (Optional)

worker: build: context: ./worker dockerfile: Dockerfile container_name: webapp-worker environment: - NODE_ENV=production - DATABASE_HOST=postgres - REDIS_HOST=redis depends_on: - postgres - redis networks: - backend restart: unless-stopped

volumes: postgres_data: redis_data:

networks: frontend: driver: bridge backend: driver: bridge

Service Configuration

Image vs Build

Using pre-built image

services: app: image: myregistry/myapp:1.0.0

Building from Dockerfile

services: app: build: ./app

Advanced build options

services: app: build: context: ./app dockerfile: Dockerfile.prod args: - BUILD_ENV=production target: production

Environment Variables

Method 1: Inline

services: api: environment: - NODE_ENV=production - LOG_LEVEL=info

Method 2: From file

services: api: env_file: - .env - .env.${ENVIRONMENT}

Method 3: Mixed (with required variable check)

services: api: environment: - DATABASE_PASSWORD=${DB_PASSWORD:?Database password required} - DATABASE_HOST=postgres

Resource Limits

services: api: # Memory: 512MB max, 256MB soft limit mem_limit: 512m memswap_limit: 1g

# CPU: 1 core
cpus: '1.0'

# File descriptor limit
ulimits:
  nofile:
    soft: 65536
    hard: 65536

Restart Policy

services: api: restart: unless-stopped # Restart unless manually stopped # Options: no, always, unless-stopped, on-failure

worker: restart: on-failure restart_policy: condition: on-failure delay: 5s max_attempts: 3 window: 60s

Networking

Service Discovery

services: api: networks: - backend environment: # Access postgres by service name on backend network - DATABASE_HOST=postgres

postgres: networks: - backend

Multi-Network Setup

services: api: networks: - frontend # Can talk to nginx - backend # Can talk to postgres

nginx: networks: - frontend # Can talk to api

postgres: networks: - backend # Can talk to api, worker

networks: frontend: backend:

Port Mapping

services: api: ports: - "3000:3000" # Map container 3000 to host 3000 - "3001:3000" # Map container 3000 to host 3001 - "127.0.0.1:3000:3000" # Bind to localhost only

Volumes

Named Volumes

services: postgres: volumes: - postgres_data:/var/lib/postgresql/data

volumes: postgres_data:

Bind Mounts

services: api: volumes: # Host path : Container path - ./src:/app/src # Read-only - ./config:/app/config:ro # With options - ./logs:/app/logs:delegated

Tmpfs (Memory-backed)

services: api: tmpfs: - /tmp - /run

Depends On

Basic Dependency

services: api: depends_on: - postgres - redis

postgres: image: postgres:15

redis: image: redis:7

Conditional Dependency (Health Checks)

services: api: depends_on: postgres: condition: service_healthy redis: condition: service_started

postgres: healthcheck: test: ["CMD-SHELL", "pg_isready -U user"] interval: 10s timeout: 5s retries: 5

Health Checks

services: api: healthcheck: # Check command test: ["CMD", "curl", "-f", "http://localhost:3000/health"]

  # Check interval
  interval: 30s

  # Timeout per check
  timeout: 5s

  # Retries before failure
  retries: 3

  # Wait before first check
  start_period: 10s

Logging

services: api: logging: driver: "json-file" options: max-size: "10m" max-file: "3" labels: "service=api"

Syslog

worker: logging: driver: "syslog" options: syslog-address: "udp://127.0.0.1:514" tag: "{{.Name}}"

Development vs Production

Development (docker-compose.yml)

version: '3.14'

services: api: build: ./api ports: - "3000:3000" volumes: - ./api/src:/app/src # Hot reload environment: - NODE_ENV=development command: npm run dev

Production (docker-compose.prod.yml)

version: '3.14'

services: api: image: myregistry/myapp:1.0.0 restart: unless-stopped environment: - NODE_ENV=production healthcheck: test: ["CMD", "curl", "-f", "http://localhost:3000/health"] interval: 30s timeout: 5s retries: 3

Running with Override

Development

docker compose up

Production

docker compose -f docker-compose.yml -f docker-compose.prod.yml up -d

Common Commands

Start services

docker compose up

Start in background

docker compose up -d

Stop services

docker compose down

Stop without removing volumes

docker compose stop

Remove containers, networks, volumes

docker compose down -v

View logs

docker compose logs -f

Specific service logs

docker compose logs -f api

Execute command in service

docker compose exec api npm test

Run one-off command

docker compose run api npm test

View service status

docker compose ps

Rebuild images

docker compose up --build

Remove and rebuild

docker compose down --rmi all && docker compose up --build

Advanced Patterns

Service Override

docker-compose.override.yml (git-ignored)

services: api: volumes: - ./src:/app/src # Local development environment: - DEBUG=true

Multiple Configurations

Production with monitoring

docker compose
-f docker-compose.yml
-f docker-compose.prod.yml
-f docker-compose.monitoring.yml
up -d

Environment-Specific Files

Load .env.${ENVIRONMENT}

docker compose --env-file .env.production up -d

Production Deployment Checklist

• All services have healthchecks

• Services use restart: unless-stopped

• Sensitive data in .env (git-ignored)

• Volumes for persistent data

• Resource limits set

• Logging configured

• Networks isolated

• Use specific image tags (never latest )

• Test with docker compose up -d && docker compose ps

Troubleshooting

Check service status

docker compose ps

View detailed service info

docker compose exec postgres psql -U user -c "\l"

Network diagnosis

docker compose exec api ping postgres

Resource usage

docker stats

Rebuild and restart

docker compose down --rmi local docker compose up --build

References

• Docker Compose documentation: https://docs.docker.com/compose/

• Compose file format: https://docs.docker.com/compose/compose-file/

• Best practices: https://docs.docker.com/compose/production/