Docker Compose Commands & Setup

 1# Start services
 2docker-compose up
 3docker-compose up -d  # Detached mode
 4
 5# Start specific services
 6docker-compose up app db
 7
 8# Build and start
 9docker-compose up --build
10
11# Stop services
12docker-compose stop
13
14# Stop and remove containers
15docker-compose down
16
17# Stop and remove containers, volumes, images
18docker-compose down -v --rmi all
19
20# View logs
21docker-compose logs
22docker-compose logs -f  # Follow
23docker-compose logs -f app  # Specific service
24
25# List containers
26docker-compose ps
27
28# Execute command in service
29docker-compose exec app bash
30docker-compose exec db psql -U postgres
31
32# Run one-off command
33docker-compose run app npm test
34docker-compose run --rm app npm test  # Remove after
35
36# View config
37docker-compose config
38
39# Validate config
40docker-compose config --quiet
41
42# Build services
43docker-compose build
44docker-compose build --no-cache
45
46# Pull images
47docker-compose pull
48
49# Restart services
50docker-compose restart
51docker-compose restart app
52
53# Pause services
54docker-compose pause
55
56# Unpause services
57docker-compose unpause
58
59# View service logs
60docker-compose logs --tail=100 app

  1version: '3.8'
  2
  3services:
  4  # Frontend
  5  frontend:
  6    build:
  7      context: ./frontend
  8      dockerfile: Dockerfile
  9      target: production
 10    image: myapp-frontend:latest
 11    container_name: frontend
 12    ports:
 13      - "3000:3000"
 14    environment:
 15      - REACT_APP_API_URL=http://localhost:8080
 16    volumes:
 17      - ./frontend:/app
 18      - /app/node_modules
 19    networks:
 20      - app-network
 21    depends_on:
 22      - backend
 23    restart: unless-stopped
 24
 25  # Backend API
 26  backend:
 27    build:
 28      context: ./backend
 29      dockerfile: Dockerfile
 30    image: myapp-backend:latest
 31    container_name: backend
 32    ports:
 33      - "8080:8080"
 34    environment:
 35      - NODE_ENV=production
 36      - DATABASE_URL=postgres://postgres:password@db:5432/mydb
 37      - REDIS_URL=redis://redis:6379
 38      - JWT_SECRET=${JWT_SECRET}
 39    env_file:
 40      - .env
 41    volumes:
 42      - ./backend:/app
 43      - /app/node_modules
 44      - uploads:/app/uploads
 45    networks:
 46      - app-network
 47    depends_on:
 48      db:
 49        condition: service_healthy
 50      redis:
 51        condition: service_started
 52    restart: unless-stopped
 53    healthcheck:
 54      test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
 55      interval: 30s
 56      timeout: 10s
 57      retries: 3
 58      start_period: 40s
 59
 60  # PostgreSQL Database
 61  db:
 62    image: postgres:15-alpine
 63    container_name: postgres
 64    environment:
 65      POSTGRES_DB: mydb
 66      POSTGRES_USER: postgres
 67      POSTGRES_PASSWORD: password
 68    volumes:
 69      - postgres-data:/var/lib/postgresql/data
 70      - ./db/init.sql:/docker-entrypoint-initdb.d/init.sql
 71    networks:
 72      - app-network
 73    ports:
 74      - "5432:5432"
 75    restart: unless-stopped
 76    healthcheck:
 77      test: ["CMD-SHELL", "pg_isready -U postgres"]
 78      interval: 10s
 79      timeout: 5s
 80      retries: 5
 81
 82  # Redis Cache
 83  redis:
 84    image: redis:7-alpine
 85    container_name: redis
 86    command: redis-server --appendonly yes --requirepass ${REDIS_PASSWORD}
 87    volumes:
 88      - redis-data:/data
 89    networks:
 90      - app-network
 91    ports:
 92      - "6379:6379"
 93    restart: unless-stopped
 94    healthcheck:
 95      test: ["CMD", "redis-cli", "ping"]
 96      interval: 10s
 97      timeout: 3s
 98      retries: 3
 99
100  # Nginx Reverse Proxy
101  nginx:
102    image: nginx:alpine
103    container_name: nginx
104    ports:
105      - "80:80"
106      - "443:443"
107    volumes:
108      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
109      - ./nginx/ssl:/etc/nginx/ssl:ro
110    networks:
111      - app-network
112    depends_on:
113      - frontend
114      - backend
115    restart: unless-stopped
116
117volumes:
118  postgres-data:
119  redis-data:
120  uploads:
121
122networks:
123  app-network:
124    driver: bridge

  1version: '3.8'
  2
  3services:
  4  # API Gateway
  5  gateway:
  6    build: ./gateway
  7    ports:
  8      - "8080:8080"
  9    environment:
 10      - AUTH_SERVICE_URL=http://auth:8081
 11      - USER_SERVICE_URL=http://user:8082
 12      - ORDER_SERVICE_URL=http://order:8083
 13    networks:
 14      - microservices
 15    depends_on:
 16      - auth
 17      - user
 18      - order
 19
 20  # Auth Service
 21  auth:
 22    build: ./services/auth
 23    environment:
 24      - DATABASE_URL=postgres://postgres:password@auth-db:5432/auth
 25      - JWT_SECRET=${JWT_SECRET}
 26    networks:
 27      - microservices
 28      - auth-network
 29    depends_on:
 30      - auth-db
 31
 32  auth-db:
 33    image: postgres:15-alpine
 34    environment:
 35      POSTGRES_DB: auth
 36      POSTGRES_PASSWORD: password
 37    volumes:
 38      - auth-db-data:/var/lib/postgresql/data
 39    networks:
 40      - auth-network
 41
 42  # User Service
 43  user:
 44    build: ./services/user
 45    environment:
 46      - DATABASE_URL=postgres://postgres:password@user-db:5432/users
 47    networks:
 48      - microservices
 49      - user-network
 50    depends_on:
 51      - user-db
 52
 53  user-db:
 54    image: postgres:15-alpine
 55    environment:
 56      POSTGRES_DB: users
 57      POSTGRES_PASSWORD: password
 58    volumes:
 59      - user-db-data:/var/lib/postgresql/data
 60    networks:
 61      - user-network
 62
 63  # Order Service
 64  order:
 65    build: ./services/order
 66    environment:
 67      - DATABASE_URL=postgres://postgres:password@order-db:5432/orders
 68      - RABBITMQ_URL=amqp://rabbitmq:5672
 69    networks:
 70      - microservices
 71      - order-network
 72    depends_on:
 73      - order-db
 74      - rabbitmq
 75
 76  order-db:
 77    image: postgres:15-alpine
 78    environment:
 79      POSTGRES_DB: orders
 80      POSTGRES_PASSWORD: password
 81    volumes:
 82      - order-db-data:/var/lib/postgresql/data
 83    networks:
 84      - order-network
 85
 86  # Message Queue
 87  rabbitmq:
 88    image: rabbitmq:3-management-alpine
 89    ports:
 90      - "5672:5672"
 91      - "15672:15672"
 92    environment:
 93      RABBITMQ_DEFAULT_USER: admin
 94      RABBITMQ_DEFAULT_PASS: password
 95    volumes:
 96      - rabbitmq-data:/var/lib/rabbitmq
 97    networks:
 98      - microservices
 99
100volumes:
101  auth-db-data:
102  user-db-data:
103  order-db-data:
104  rabbitmq-data:
105
106networks:
107  microservices:
108    driver: bridge
109  auth-network:
110    driver: bridge
111  user-network:
112    driver: bridge
113  order-network:
114    driver: bridge

 1version: '3.8'
 2
 3services:
 4  app:
 5    build:
 6      context: .
 7      target: development
 8    volumes:
 9      - .:/app
10      - /app/node_modules
11    ports:
12      - "3000:3000"
13    environment:
14      - NODE_ENV=development
15      - DATABASE_URL=postgres://postgres:password@db:5432/dev
16    command: npm run dev
17    networks:
18      - dev-network
19    depends_on:
20      - db
21      - redis
22
23  db:
24    image: postgres:15-alpine
25    environment:
26      POSTGRES_DB: dev
27      POSTGRES_PASSWORD: password
28    volumes:
29      - postgres-dev-data:/var/lib/postgresql/data
30    ports:
31      - "5432:5432"
32    networks:
33      - dev-network
34
35  redis:
36    image: redis:7-alpine
37    ports:
38      - "6379:6379"
39    networks:
40      - dev-network
41
42  # Database admin tool
43  adminer:
44    image: adminer
45    ports:
46      - "8080:8080"
47    networks:
48      - dev-network
49    depends_on:
50      - db
51
52  # Redis admin tool
53  redis-commander:
54    image: rediscommander/redis-commander:latest
55    environment:
56      - REDIS_HOSTS=local:redis:6379
57    ports:
58      - "8081:8081"
59    networks:
60      - dev-network
61    depends_on:
62      - redis
63
64volumes:
65  postgres-dev-data:
66
67networks:
68  dev-network:
69    driver: bridge

1version: '3.8'
2services:
3  app:
4    image: myapp:latest
5    environment:
6      - NODE_ENV=production

1version: '3.8'
2services:
3  app:
4    build: .
5    volumes:
6      - .:/app
7    environment:
8      - NODE_ENV=development
9    command: npm run dev

 1version: '3.8'
 2services:
 3  app:
 4    image: myapp:${VERSION}
 5    restart: always
 6    deploy:
 7      replicas: 3
 8      resources:
 9        limits:
10          cpus: '0.5'
11          memory: 512M

1# Use override (default)
2docker-compose up
3
4# Use specific file
5docker-compose -f docker-compose.yml -f docker-compose.prod.yml up
6
7# Multiple override files
8docker-compose -f docker-compose.yml -f docker-compose.override.yml -f docker-compose.local.yml up

 1# Database
 2POSTGRES_DB=mydb
 3POSTGRES_USER=postgres
 4POSTGRES_PASSWORD=secretpassword
 5
 6# Application
 7NODE_ENV=production
 8JWT_SECRET=your-secret-key
 9API_PORT=8080
10
11# Redis
12REDIS_PASSWORD=redispassword
13
14# Version
15VERSION=1.0.0

1version: '3.8'
2services:
3  app:
4    image: myapp:${VERSION:-latest}
5    environment:
6      - NODE_ENV=${NODE_ENV}
7      - JWT_SECRET=${JWT_SECRET}
8    ports:
9      - "${API_PORT}:8080"

 1services:
 2  app:
 3    healthcheck:
 4      test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
 5      interval: 30s
 6      timeout: 10s
 7      retries: 3
 8      start_period: 40s
 9  
10  db:
11    healthcheck:
12      test: ["CMD-SHELL", "pg_isready -U postgres"]
13      interval: 10s
14      timeout: 5s
15      retries: 5
16  
17  redis:
18    healthcheck:
19      test: ["CMD", "redis-cli", "ping"]
20      interval: 10s
21      timeout: 3s
22      retries: 3

 1services:
 2  app:
 3    deploy:
 4      resources:
 5        limits:
 6          cpus: '0.50'
 7          memory: 512M
 8        reservations:
 9          cpus: '0.25'
10          memory: 256M

1services:
2  app:
3    logging:
4      driver: "json-file"
5      options:
6        max-size: "10m"
7        max-file: "3"

 1.PHONY: up down build logs shell test clean
 2
 3up:
 4	docker-compose up -d
 5
 6down:
 7	docker-compose down
 8
 9build:
10	docker-compose build
11
12logs:
13	docker-compose logs -f
14
15shell:
16	docker-compose exec app bash
17
18test:
19	docker-compose run --rm app npm test
20
21clean:
22	docker-compose down -v --rmi all
23	docker system prune -f

 1# View service logs
 2docker-compose logs -f app
 3
 4# Rebuild service
 5docker-compose up -d --build app
 6
 7# Recreate containers
 8docker-compose up -d --force-recreate
 9
10# Remove volumes
11docker-compose down -v
12
13# Check service health
14docker-compose ps
15
16# Validate compose file
17docker-compose config
18
19# View service IPs
20docker-compose exec app cat /etc/hosts