DockerCompose编排多容器

本文目录导读：

1. Docker Compose 基本概念
2. 基础示例：Web应用 + 数据库
3. 实际项目：Node.js + MongoDB + Redis
4. 微服务架构示例
5. 常用命令
6. 高级配置示例
7. 最佳实践

我来详细介绍Docker Compose编排多容器应用的方法和实践。

Docker Compose 基本概念

什么是 Docker Compose

• 用于定义和运行多容器Docker应用的工具
• 通过YAML文件配置应用服务
• 单个命令即可创建和启动所有服务

基础示例：Web应用 + 数据库

创建 docker-compose.yml 文件

version: '3.8'
services:
  web:
    image: nginx:alpine
    ports:
      - "8080:80"
    volumes:
      - ./html:/usr/share/nginx/html
    depends_on:
      - app
    networks:
      - frontend
  app:
    build: ./app
    ports:
      - "3000:3000"
    environment:
      - DB_HOST=db
      - DB_PORT=3306
    depends_on:
      db:
        condition: service_healthy
    volumes:
      - ./app:/usr/share/app
    networks:
      - frontend
      - backend
  db:
    image: mysql:8.0
    ports:
      - "3306:3306"
    environment:
      - MYSQL_ROOT_PASSWORD=root123
      - MYSQL_DATABASE=myapp
    volumes:
      - mysql_data:/var/lib/mysql
    networks:
      - backend
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
      timeout: 20s
      retries: 10
volumes:
  mysql_data:
networks:
  frontend:
  backend:

实际项目：Node.js + MongoDB + Redis

docker-compose.yml

version: '3.8'
services:
  # Node.js 应用
  app:
    build:
      context: .
      dockerfile: Dockerfile
      target: production
    container_name: node-app
    restart: always
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - MONGODB_URI=mongodb://mongo:27017/myapp
      - REDIS_HOST=redis
      - REDIS_PORT=6379
    volumes:
      - ./uploads:/usr/src/app/uploads
    depends_on:
      mongo:
        condition: service_healthy
      redis:
        condition: service_started
    networks:
      - app-network
  # MongoDB 数据库
  mongo:
    image: mongo:6.0
    container_name: mongodb
    restart: always
    ports:
      - "27017:27017"
    environment:
      - MONGO_INITDB_ROOT_USERNAME=admin
      - MONGO_INITDB_ROOT_PASSWORD=admin123
      - MONGO_INITDB_DATABASE=myapp
    volumes:
      - mongo-data:/data/db
      - ./mongo-init:/docker-entrypoint-initdb.d
    networks:
      - app-network
    healthcheck:
      test: echo 'db.runCommand("ping").ok' | mongosh localhost:27017 --quiet
      interval: 30s
      timeout: 10s
      retries: 3
  # Redis 缓存
  redis:
    image: redis:7.0-alpine
    container_name: redis
    restart: always
    ports:
      - "6379:6379"
    volumes:
      - redis-data:/data
    command: redis-server --appendonly yes
    networks:
      - app-network
  # Nginx 反向代理
  nginx:
    image: nginx:alpine
    container_name: nginx-proxy
    restart: always
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
      - ./nginx/ssl:/etc/nginx/ssl:ro
    depends_on:
      - app
    networks:
      - app-network
volumes:
  mongo-data:
  redis-data:
networks:
  app-network:
    driver: bridge

对应的 Node.js Dockerfile

# 多阶段构建
FROM node:18-alpine AS base
WORKDIR /usr/src/app
# 依赖安装阶段
FROM base AS deps
COPY package*.json ./
RUN npm ci --only=production
# 构建阶段
FROM base AS build
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build
# 生产阶段
FROM base AS production
COPY --from=deps /usr/src/app/node_modules ./node_modules
COPY --from=build /usr/src/app/dist ./dist
EXPOSE 3000
CMD ["node", "dist/main.js"]

微服务架构示例

docker-compose.yml

version: '3.8'
services:
  # 服务注册与发现
  consul:
    image: consul:1.15
    container_name: consul
    ports:
      - "8500:8500"
    command: "agent -server -bootstrap -ui -client=0.0.0.0"
    networks:
      - microservices
  # API 网关
  gateway:
    build: ./gateway
    ports:
      - "8080:8080"
    environment:
      - CONSUL_HOST=consul
    depends_on:
      - consul
    networks:
      - microservices
  # 用户服务
  user-service:
    build: ./services/user
    ports:
      - "8081:8081"
    environment:
      - CONSUL_HOST=consul
      - DB_HOST=user-db
    depends_on:
      - consul
      - user-db
    networks:
      - microservices
    deploy:
      replicas: 2
      resources:
        limits:
          memory: 512M
        reservations:
          memory: 256M
  # 订单服务
  order-service:
    build: ./services/order
    ports:
      - "8082:8082"
    environment:
      - CONSUL_HOST=consul
      - DB_HOST=order-db
    depends_on:
      - consul
      - order-db
    networks:
      - microservices
    deploy:
      replicas: 3
      resources:
        limits:
          memory: 256M
  # 消息队列
  rabbitmq:
    image: rabbitmq:3-management
    ports:
      - "5672:5672"
      - "15672:15672"
    environment:
      - RABBITMQ_DEFAULT_USER=admin
      - RABBITMQ_DEFAULT_PASS=admin123
    networks:
      - microservices
  # 用户数据库
  user-db:
    image: postgres:15
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=user123
      - POSTGRES_DB=users
    volumes:
      - user-db-data:/var/lib/postgresql/data
    networks:
      - microservices
  # 订单数据库
  order-db:
    image: postgres:15
    environment:
      - POSTGRES_USER=order
      - POSTGRES_PASSWORD=order123
      - POSTGRES_DB=orders
    volumes:
      - order-db-data:/var/lib/postgresql/data
    networks:
      - microservices
  # 监控
  prometheus:
    image: prom/prometheus
    volumes:
      - ./monitoring/prometheus.yml:/etc/prometheus/prometheus.yml
    ports:
      - "9090:9090"
    networks:
      - microservices
  grafana:
    image: grafana/grafana
    ports:
      - "3000:3000"
    depends_on:
      - prometheus
    networks:
      - microservices
volumes:
  user-db-data:
  order-db-data:
networks:
  microservices:
    driver: overlay

常用命令

# 基本命令
docker-compose up                          # 启动所有服务
docker-compose up -d                       # 后台启动
docker-compose down                        # 停止并删除容器
docker-compose down -v                     # 同时删除卷
# 构建和启动
docker-compose up --build                  # 重新构建镜像并启动
docker-compose build                       # 构建所有服务
docker-compose build service_name          # 构建特定服务
# 查看状态
docker-compose ps                          # 查看服务状态
docker-compose logs                        # 查看所有日志
docker-compose logs -f                     # 实时查看日志
docker-compose logs service_name           # 查看特定服务日志
# 管理服务
docker-compose start service_name          # 启动服务
docker-compose stop service_name           # 停止服务
docker-compose restart service_name        # 重启服务
docker-compose scale service_name=3        # 扩展服务实例数
# 执行命令
docker-compose exec service_name bash      # 进入容器
docker-compose run service_name cmd        # 运行一次性命令

高级配置示例

使用环境变量文件

version: '3.8'
services:
  app:
    image: myapp:latest
    env_file:
      - ./config/common.env
      - ./config/production.env
    environment:
      - NODE_ENV=production
      - SECRET=${SECRET:-default_secret}

数据卷备份

version: '3.8'
services:
  backup:
    image: alpine
    volumes:
      - mysql_data:/data/mysql
      - ./backups:/backups
    command: >
      sh -c "tar czf /backups/backup-$$(date +%Y%m%d-%H%M%S).tar.gz /data/mysql"
    depends_on:
      - db

最佳实践

健康检查配置

services:
  db:
    image: mysql:8.0
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s

资源限制

services:
  app:
    deploy:
      resources:
        limits:
          cpus: '0.5'
          memory: 512M
        reservations:
          cpus: '0.25'
          memory: 256M

日志配置

services:
  app:
    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "3"

Docker Compose 让多容器应用的管理变得简单高效，适合开发、测试和生产环境使用。