docker-compose.yml 模板 笔记250801

kfepiza
126 阅读9分钟

docker-compose.yml 模板 笔记250801













1️⃣ 参考 1

以下是一个通用的 docker-compose.yml 模板示例，适用于多容器应用的编排。您可以根据实际需求修改配置：

version: '3.8'  # 推荐使用 3.x 版本（兼容 Docker Engine 19.03+）

services:
  # 示例：Web 服务（如 Nginx）
  web:
    image: nginx:latest
    container_name: my_web
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf  # 挂载自定义配置
      - ./static:/usr/share/nginx/html       # 挂载静态资源
    networks:
      - my_network
    restart: always  # 容器退出时自动重启
    depends_on:
      - app  # 依赖 app 服务

  # 示例：后端应用服务（如 Node.js/Python）
  app:
    build: ./app  # 使用目录 ./app 中的 Dockerfile 构建镜像
    container_name: my_app
    expose:
      - "3000"  # 暴露端口（不映射到宿主机，仅供内部访问）
    environment:
      - DB_HOST=db
      - REDIS_HOST=redis
    volumes:
      - ./app:/usr/src/app  # 开发时挂载代码目录
    networks:
      - my_network
    restart: on-failure

  # 示例：数据库服务（如 PostgreSQL）
  db:
    image: postgres:15
    container_name: my_db
    environment:
      POSTGRES_USER: admin
      POSTGRES_PASSWORD: secret
      POSTGRES_DB: mydb
    volumes:
      - pgdata:/var/lib/postgresql/data  # 数据持久化
    ports:
      - "5432:5432"  # 生产环境建议移除，仅通过内部网络访问
    networks:
      - my_network
    healthcheck:  # 健康检查
      test: ["CMD-SHELL", "pg_isready -U admin"]
      interval: 10s
      timeout: 5s
      retries: 5

  # 示例：缓存服务（如 Redis）
  redis:
    image: redis:7
    container_name: my_redis
    command: redis-server --requirepass "redis_password"
    volumes:
      - redisdata:/data
    networks:
      - my_network
    ports:
      - "6379:6379"

# 定义网络（容器间可通过服务名通信）
networks:
  my_network:
    driver: bridge

# 定义数据卷（数据持久化）
volumes:
  pgdata:
  redisdata:

     关键配置说明：

  1. 版本选择
    version: '3.8'：兼容 Docker Engine 19.03+，支持所有现代特性（版本对照表）。

  2. 服务间通信

    • 使用自定义网络 my_network，同一网络下的容器可通过服务名（如 db、redis）互相访问。
    • depends_on：控制服务启动顺序（不等待依赖项就绪，仅控制启动顺序）。

  3. 数据持久化

    • volumes 声明命名卷（如 pgdata），避免容器重启后数据丢失。
    • 开发时可挂载本地目录（如 ./app:/code）实现代码热更新。

  4. 端口映射

    • ports：将容器端口映射到宿主机（格式 宿主机端口:容器端口）。
    • expose：仅暴露端口给其他服务，不映射到宿主机。

  5. 健康检查
    healthcheck 可确保服务完全就绪后再启动依赖项（需在应用代码中处理重连逻辑）。

     常用命令：

# 启动所有服务（后台运行）
docker-compose up -d

# 查看服务状态
docker-compose ps

# 停止所有服务
docker-compose down

# 重新构建镜像并启动
docker-compose up -d --build

# 查看日志
docker-compose logs -f web

     自定义建议：

  1. 生产环境

    • 移除不必要的 ports 映射（如数据库端口）。
    • 使用 .env 文件管理敏感环境变量： 
      # .env 文件示例
POSTGRES_PASSWORD=your_secure_password
      在 docker-compose.yml 中引用： 
      environment:
  POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}

  2. 扩展配置

    • 添加 resource 限制 CPU/内存。
    • 使用 configs 或 secrets 管理敏感文件。

根据您的具体技术栈（如 MySQL、MongoDB、React 等），替换相应镜像和配置即可。













2️⃣ 参考 2

以下是一个通用的 docker-compose.yml 模板，适用于大多数场景（如 Web 应用 + 数据库），包含详细注释：

version: '3.8'  # 推荐使用 3.8 版本（兼容 Docker Engine 19.03+）

services:
  # ==================== 前端/Web 服务 ====================
  webapp:
    image: nginx:alpine  # 使用官方镜像
    # build: ./frontend   # 如需构建镜像，取消注释并指定 Dockerfile 路径
    container_name: my_web  # 自定义容器名（可选）
    restart: unless-stopped  # 自动重启策略
    ports:
      - "80:80"       # 映射宿主机 80 端口到容器 80 端口
      - "443:443"     # HTTPS 端口（可选）
    volumes:
      - ./static:/usr/share/nginx/html  # 挂载静态文件
      - ./nginx.conf:/etc/nginx/nginx.conf  # 挂载自定义配置
    networks:
      - app-network
    depends_on:
      - backend  # 确保后端先启动

  # ==================== 后端服务 ====================
  backend:
    image: my-backend-image:latest  # 替换为你的镜像名
    build: ./backend  # 构建路径（包含 Dockerfile）
    environment:
      - DB_HOST=db
      - DB_PORT=5432
      - DEBUG=false  # 生产环境设为 false
    env_file: .env  # 从文件加载环境变量（更安全）
    networks:
      - app-network
    ports:
      - "5000:5000"  # 暴露 API 端口（按需调整）

  # ==================== 数据库服务 ====================
  db:
    image: postgres:15-alpine  # 官方 PostgreSQL 镜像
    container_name: main_db
    restart: always
    environment:
      POSTGRES_DB: mydb
      POSTGRES_USER: user
      POSTGRES_PASSWORD: mysecretpassword  # 生产环境应使用 secrets
    volumes:
      - pgdata:/var/lib/postgresql/data  # 持久化数据
    networks:
      - app-network
    healthcheck:  # 健康检查（确保依赖服务就绪）
      test: ["CMD-SHELL", "pg_isready -U user"]
      interval: 5s
      timeout: 5s
      retries: 5

  # ==================== 附加服务示例（Redis）====================
  redis:
    image: redis:alpine
    command: redis-server --requirepass myredispass  # 设置密码
    ports:
      - "6379:6379"
    networks:
      - app-network

# ==================== 网络配置 ====================
networks:
  app-network:  # 创建自定义网络（容器间可通过服务名通信）
    driver: bridge

# ==================== 卷配置 ====================
volumes:
  pgdata:  # 命名卷（由 Docker 管理存储位置）

     使用说明：

  1. 保存文件：将内容保存为 docker-compose.yml
  2. 启动服务：docker-compose up -d （后台运行）
  3. 停止服务：docker-compose down
  4. 查看日志：docker-compose logs -f webapp

     常用自定义项：

  • 端口映射：修改 ports 的左侧端口（如 "8080:80"）
  • 环境变量：
    • 直接在 environment 中定义
    • 或使用 .env 文件（避免密码硬编码）
  • 数据持久化：
    • 命名卷（推荐数据库使用）：volumes: pgdata:
    • 绑定挂载（开发时方便修改代码）：./local/path:/container/path

     生产环境建议：

  1. 使用 docker-compose.prod.yml 覆盖配置（通过 -f 指定）
  2. 敏感数据（如密码）使用 Docker Secrets 或环境变量文件
  3. 添加 healthcheck 确保服务依赖顺序

完整文档参考：Docker Compose 官方文档













3️⃣ 参考 3

以下是一个通用的 docker-compose.yml 模板，适用于大多数场景（如 Web 应用 + 数据库），包含详细注释说明：

version: '3.8'  # 推荐使用 3.8 版本（最新稳定版）

services:
  # ==================== 后端服务 ====================
  backend:
    image: your-backend-image:latest  # 替换为你的后端镜像
    container_name: my-backend         # 自定义容器名（可选）
    restart: always                   # 自动重启策略
    ports:
      - "8000:8000"                   # 端口映射（宿主机:容器）
    volumes:
      - ./app:/code                   # 挂载代码目录
      - logs:/var/log/app             # 使用命名卷存储日志
    environment:
      - DATABASE_URL=postgres://user:pass@db:5432/mydb
      - DEBUG=0
    depends_on:
      - db                            # 依赖数据库服务
    networks:
      - main-network

  # ==================== 数据库服务 ====================
  db:
    image: postgres:15-alpine         # 官方 PostgreSQL 镜像
    container_name: my-db
    restart: unless-stopped
    volumes:
      - pgdata:/var/lib/postgresql/data  # 持久化数据库数据
    environment:
      POSTGRES_USER: admin            # 初始化用户名
      POSTGRES_PASSWORD: securepass   # 初始化密码
      POSTGRES_DB: mydb               # 初始化数据库名
    networks:
      - main-network

  # ==================== 前端服务 ====================
  frontend:
    build: ./frontend                 # 使用 Dockerfile 构建镜像
    container_name: my-frontend
    ports:
      - "80:80"                      # 暴露 HTTP 端口
    volumes:
      - ./frontend/src:/app/src       # 开发时热重载
    depends_on:
      - backend
    networks:
      - main-network

  # ==================== 可选：监控服务 ====================
  # prometheus:
  #   image: prom/prometheus:latest
  #   volumes:
  #     - ./prometheus.yml:/etc/prometheus/prometheus.yml

# ==================== 网络配置 ====================
networks:
  main-network:                       # 自定义网络（容器间可通过服务名通信）
    driver: bridge

# ==================== 卷配置 ====================
volumes:
  pgdata:                             # 声明命名卷（自动管理）
  logs:                               # 后端日志存储

     关键配置说明：

  1. 服务通信

    • 同一网络中的容器可通过 服务名 通信（如 backend 中访问数据库：db:5432）
    • depends_on 控制启动顺序（不保证服务完全就绪，仅控制启动顺序）

  2. 数据持久化

    • 命名卷（如 pgdata）由 Docker 管理存储位置
    • 绑定挂载（如 ./app:/code）用于开发时代码实时同步

  3. 常用命令：

# 启动所有服务（后台模式）
docker-compose up -d

# 停止并删除容器
docker-compose down

# 查看日志
docker-compose logs -f backend

# 重建并启动服务
docker-compose up -d --build

     按需调整：

  1. 开发环境：

    • 添加 command: python app.py --reload 实现热重载
    • 挂载代码目录实现实时修改

  2. 生产环境：

    • 移除代码挂载卷（使用镜像内代码）
    • 设置 restart: always
    • 添加健康检查： 
      healthcheck:
  test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
  interval: 30s
  timeout: 5s

  3. 扩展服务：

    • Redis 服务示例： 
      redis:
  image: redis:alpine
  volumes:
    - redis-data:/data
  networks:
    - main-network

提示：使用 .env 文件管理环境变量（如数据库密码），在 docker-compose.yml 中引用 ${POSTGRES_PASSWORD}













4️⃣ 参考 4

以下是一个通用的 docker-compose.yml 模板，适用于大多数 Web 应用场景（包含前端、后端、数据库和缓存服务）：

version: '3.8'

services:
  # 前端服务（例如：React/Vue 应用）
  frontend:
    image: node:18-alpine
    container_name: myapp-frontend
    working_dir: /app
    volumes:
      - ./frontend:/app
      - /app/node_modules
    ports:
      - "3000:3000"
    command: sh -c "npm install && npm run dev"
    environment:
      - NODE_ENV=development
    depends_on:
      - backend
    networks:
      - app-network

  # 后端服务（例如：Python/Node.js/Go 应用）
  backend:
    build: 
      context: ./backend
      dockerfile: Dockerfile
    container_name: myapp-backend
    volumes:
      - ./backend:/code
    ports:
      - "5000:5000"
    environment:
      - DB_HOST=postgres
      - DB_PORT=5432
      - REDIS_HOST=redis
    depends_on:
      - postgres
      - redis
    networks:
      - app-network

  # 数据库服务（PostgreSQL）
  postgres:
    image: postgres:15-alpine
    container_name: postgres-db
    volumes:
      - postgres-data:/var/lib/postgresql/data
    environment:
      - POSTGRES_DB=mydb
      - POSTGRES_USER=admin
      - POSTGRES_PASSWORD=secret
    ports:
      - "5432:5432"
    networks:
      - app-network

  # 缓存服务（Redis）
  redis:
    image: redis:7-alpine
    container_name: redis-cache
    ports:
      - "6379:6379"
    networks:
      - app-network

  # 可选：反向代理（Nginx）
  # nginx:
  #   image: nginx:alpine
  #   ports:
  #     - "80:80"
  #   volumes:
  #     - ./nginx.conf:/etc/nginx/nginx.conf
  #   depends_on:
  #     - frontend
  #     - backend
  #   networks:
  #     - app-network

# 网络配置
networks:
  app-network:
    driver: bridge

# 数据卷声明（数据库持久化）
volumes:
  postgres-data:

     关键配置说明：

  1. 多服务架构：

    • frontend：前端开发服务（热更新支持）
    • backend：后端应用（需在 ./backend 目录提供 Dockerfile）
    • postgres：PostgreSQL 数据库（数据持久化到卷）
    • redis：Redis 缓存服务

  2. 网络配置：

    • 所有服务通过 app-network 互通，直接使用服务名通信（如 postgres）

  3. 数据持久化：

    • PostgreSQL 数据保存在命名卷 postgres-data 中
    • 前端 node_modules 通过匿名卷避免覆盖本地文件

  4. 端口映射：

    • 前端：3000
    • 后端：5000
    • 数据库：5432（建议生产环境移除外部映射）
    • Redis：6379

     使用方式：

  1. 创建目录结构：

    ├── docker-compose.yml
├── frontend/     # 前端代码
├── backend/      # 后端代码（含 Dockerfile）
└── nginx.conf    # Nginx 配置（若启用）

  2. 启动所有服务：

    docker-compose up -d --build

  3. 常用命令：

    # 查看运行状态
docker-compose ps

# 查看日志
docker-compose logs -f

# 停止服务
docker-compose down

# 清理数据（含数据库卷）
docker-compose down -v

     自定义建议：

  1. 镜像版本：根据需求修改镜像标签（如 python:3.10-slim 替代 node）
  2. 环境变量：敏感数据应使用 .env 文件管理
  3. 生产优化：
    • 移除开发模式的热更新配置
    • 启用 Nginx 反向代理
    • 添加健康检查（healthcheck 配置）
    • 使用已构建的镜像而非源码构建

提示：完整项目模板可参考 Docker 官方示例













5️⃣ 参考 5

下面是一个通用的 docker-compose.yml 模板示例，包含常用服务（Nginx + MySQL + PHP + Redis），可根据需求删减或修改：

version: '3.8'

services:
  # Web 服务器 (Nginx)
  nginx:
    image: nginx:alpine
    container_name: my-nginx
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./html:/usr/share/nginx/html
      - ./nginx/conf.d:/etc/nginx/conf.d
      - ./ssl:/etc/nginx/ssl
    depends_on:
      - php
    networks:
      - app-network

  # PHP 服务
  php:
    image: php:8.2-fpm-alpine
    container_name: my-php
    volumes:
      - ./html:/var/www/html
      - ./php/custom.ini:/usr/local/etc/php/conf.d/custom.ini
    networks:
      - app-network

  # MySQL 数据库
  mysql:
    image: mysql:8.0
    container_name: my-mysql
    environment:
      MYSQL_ROOT_PASSWORD: rootpassword
      MYSQL_DATABASE: app_db
      MYSQL_USER: app_user
      MYSQL_PASSWORD: userpassword
    volumes:
      - mysql-data:/var/lib/mysql
      - ./mysql/init.sql:/docker-entrypoint-initdb.d/init.sql
    ports:
      - "3306:3306"
    networks:
      - app-network

  # Redis 缓存
  redis:
    image: redis:alpine
    container_name: my-redis
    ports:
      - "6379:6379"
    networks:
      - app-network

# 自定义网络（提升服务间通信性能）
networks:
  app-network:
    driver: bridge

# 数据卷声明（持久化数据库）
volumes:
  mysql-data:

     关键配置说明：

  1. 目录结构建议：

    project/
├── docker-compose.yml
├── html/              # 网站代码目录
├── nginx/
│   └── conf.d/        # Nginx 虚拟主机配置
├── php/
│   └── custom.ini     # PHP 自定义配置
└── mysql/
    └── init.sql      # 数据库初始化脚本

  2. 常用命令：

    # 启动所有服务（后台运行）
docker-compose up -d

# 停止服务
docker-compose down

# 查看日志
docker-compose logs -f nginx

  3. 按需调整：

    • 删除不需要的服务：移除 redis、mysql 等未使用的服务块
    • 端口映射：修改 ports 字段调整暴露端口（格式："宿主机端口:容器端口"）
    • 环境变量：MySQL 密码等敏感信息建议使用 .env 文件管理
    • 镜像版本：指定稳定版本标签（如 mysql:8.0 代替 mysql:latest）

  4. PHP 扩展安装：
    在 php 服务中添加 build 部分安装扩展：

    php:
  build:
    context: .
    dockerfile: Dockerfile-php
  # 其他配置...

    创建 Dockerfile-php：

    FROM php:8.2-fpm-alpine
RUN docker-php-ext-install pdo pdo_mysql opcache

     最小化模板（仅含 Nginx + PHP）：

version: '3.8'

services:
  nginx:
    image: nginx:alpine
    ports: ["80:80"]
    volumes:
      - ./html:/usr/share/nginx/html
      - ./nginx.conf:/etc/nginx/nginx.conf

  php:
    image: php:8.2-fpm-alpine
    volumes:
      - ./html:/var/www/html

💡 提示：生产环境需添加安全措施（如非 root 用户运行、只读文件系统、资源限制等）。建议使用 Docker Compose 官方文档 作为参考。













6️⃣ 参考 6

以下是一个通用的 docker-compose.yml 模板，适用于常见 Web 应用场景（前端 + 后端 + 数据库），可根据需求灵活调整：

version: '3.8'

services:
  # 后端服务 (示例：Python/Django/Node.js)
  backend:
    build: 
      context: ./backend   # 后端 Dockerfile 所在目录
      dockerfile: Dockerfile
    container_name: myapp-backend
    restart: unless-stopped
    ports:
      - "8000:8000"        # 暴露端口 (主机:容器)
    volumes:
      - ./backend:/app     # 代码热重载
      - backend-data:/app/data  # 持久化数据卷
    environment:
      - DATABASE_URL=postgres://user:pass@db:5432/mydb
      - DEBUG=0
    depends_on:
      - db
    networks:
      - app-network

  # 前端服务 (示例：React/Vue)
  frontend:
    image: node:18-alpine   # 直接使用官方镜像
    container_name: myapp-frontend
    restart: unless-stopped
    ports:
      - "3000:3000"
    working_dir: /app
    volumes:
      - ./frontend:/app     # 挂载前端代码
    command: npm run dev    # 开发环境命令
    networks:
      - app-network

  # 数据库服务 (示例：PostgreSQL)
  db:
    image: postgres:15-alpine
    container_name: myapp-db
    restart: always
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: pass
      POSTGRES_DB: mydb
    volumes:
      - pgdata:/var/lib/postgresql/data  # 数据库持久化
    ports:
      - "5432:5432"   # 仅需在开发时暴露，生产环境建议移除
    networks:
      - app-network

  # 可选：反向代理 (Nginx)
  # proxy:
  #   image: nginx:alpine
  #   ports:
  #     - "80:80"
  #   volumes:
  #     - ./nginx.conf:/etc/nginx/nginx.conf
  #   depends_on:
  #     - backend
  #     - frontend

# 网络配置
networks:
  app-network:
    driver: bridge

# 数据卷声明
volumes:
  pgdata:
  backend-data:

     关键配置说明：

  1. 服务拆分：

    • backend：应用后端（需自建 Dockerfile）
    • frontend：前端服务（可直接使用官方镜像）
    • db：数据库（数据通过卷持久化）
    • （可选）proxy：Nginx 反向代理

  2. 常用配置项：

    • ports：端口映射 主机端口:容器端口
    • volumes：
      • 绑定挂载（./host/path:/container/path）：用于代码热更新
      • 命名卷（volume-name:/container/path）：用于数据持久化
    • environment：设置环境变量
    • depends_on：控制启动顺序
    • restart: unless-stopped：自动重启策略

  3. 网络：

    • 所有服务加入同一自定义网络，可通过服务名互访（如 backend 访问 db 时使用 db:5432）

     使用场景调整：

  1. 生产环境：

    • 移除代码目录挂载（避免覆盖容器内代码）
    • 前端改用静态构建：command: nginx -g 'daemon off;'
    • 添加 restart: always 策略
    • 启用 Nginx 反向代理

  2. 数据库备份：

    docker-compose exec db pg_dump -U user mydb > backup.sql

  3. 扩展服务：

    • 添加 Redis 缓存： 
      redis:
  image: redis:alpine
  networks:
    - app-network

  4. 多环境配置： 使用 docker-compose.override.yml 实现开发/生产配置分离：

    # 开发环境 (带热重载)
docker-compose -f docker-compose.yml -f docker-compose.dev.yml up

# 生产环境
docker-compose -f docker-compose.yml -f docker-compose.prod.yml up -d

     基础操作命令：

# 启动所有服务（后台模式）
docker-compose up -d

# 查看运行状态
docker-compose ps

# 查看日志（可指定服务名）
docker-compose logs -f backend

# 停止服务
docker-compose down

# 构建/重建特定服务
docker-compose build backend

提示：根据实际项目结构调整挂载路径、环境变量和端口映射。首次使用建议先阅读 Docker Compose 官方文档。













7️⃣ 参考 7

以下是一个常用的 docker-compose.yml 模板，包含常见服务配置（如Web服务、数据库等），并附有注释说明：

version: '3.8'  # Docker Compose版本

services:
  web:
    build:
      context: .       # 构建上下文路径
      dockerfile: Dockerfile  # 指定Dockerfile文件
    container_name: web_app  # 容器名称
    ports:
      - "80:80"       # 端口映射：主机端口:容器端口
      - "443:443"
    environment:
      - ENV=production  # 环境变量
      - DEBUG=False
    volumes:
      - ./app:/app    # 卷挂载：主机路径:容器路径
      - /app/node_modules  # 排除特定目录
    depends_on:
      - db            # 依赖其他服务
      - redis
    networks:
      - app_network

  db:
    image: postgres:15  # 直接使用镜像
    container_name: db_container
    ports:
      - "5432:5432"
    environment:
      POSTGRES_USER: admin
      POSTGRES_PASSWORD: secret
      POSTGRES_DB: mydb
    volumes:
      - db_data:/var/lib/postgresql/data  # 命名卷
    networks:
      - app_network
    healthcheck:      # 健康检查配置
      test: ["CMD-SHELL", "pg_isready -U admin -d mydb"]
      interval: 10s
      timeout: 5s
      retries: 5

  redis:
    image: redis:alpine
    container_name: redis_cache
    ports:
      - "6379:6379"
    networks:
      - app_network
    volumes:
      - redis_data:/data

volumes:  # 定义命名卷
  db_data:
  redis_data:

networks:  # 定义网络
  app_network:
    driver: bridge

     关键部分说明：

  1. 版本：version: '3.8' 表示使用Docker Compose v3.8格式
  2. 服务：
    • build：定义如何构建镜像（替代image）
    • ports：端口映射规则
    • environment：设置环境变量
    • volumes：数据持久化配置
    • depends_on：服务启动顺序依赖
  3. 卷和网络：
    • 使用命名卷（volumes）替代匿名卷
    • 自定义网络（networks）实现服务间通信

     常用服务模板（按需替换）：

# 通用Web服务（Node.js示例）
  web:
    image: node:18
    command: npm start
    working_dir: /app
    volumes:
      - ./src:/app
    env_file: .env  # 从文件加载环境变量

# 缓存服务（Redis示例）
  cache:
    image: redis:alpine
    command: redis-server --appendonly yes
    volumes:
      - redis_data:/data

# 消息队列（RabbitMQ示例）
  rabbitmq:
    image: rabbitmq:3-management
    ports:
      - "5672:5672"
      - "15672:15672"

     使用建议：

  1. 根据实际需求调整端口、卷路径和环境变量
  2. 生产环境建议：
    • 添加资源限制（deploy.resources）
    • 配置重启策略（restart: always）
    • 使用secrets管理敏感信息
  3. 通过 docker-compose up -d 启动服务
  4. 使用 docker-compose exec web sh 进入容器调试

可根据具体技术栈（Python/Django、Ruby/Rails、PHP等）调整构建步骤和服务配置。













8️⃣ 参考 8

以下是一个通用的 docker-compose.yml 模板，涵盖了常见的服务定义、网络、卷和环境变量配置，适用于多容器应用的基本场景：

     docker-compose.yml 模板

version: '3.9'  # 指定 Docker Compose 文件版本

services:
  # 示例：Web 服务
  web:
    image: nginx:alpine  # 使用官方 Nginx 镜像
    container_name: my-web  # 容器名称（可选）
    ports:
      - "80:80"  # 映射主机端口 80 到容器端口 80
    volumes:
      - ./html:/usr/share/nginx/html  # 挂载本地目录到容器内
    environment:
      - ENV=production  # 设置环境变量
    restart: unless-stopped  # 重启策略
    depends_on:  # 依赖的服务（确保 db 先启动）
      - db
    networks:
      - my-network  # 使用自定义网络

  # 示例：数据库服务
  db:
    image: mysql:8  # 使用 MySQL 8 镜像
    container_name: my-db
    environment:
      MYSQL_ROOT_PASSWORD: example  # 数据库 root 密码
      MYSQL_DATABASE: mydb  # 初始化数据库名
    volumes:
      - db-data:/var/lib/mysql  # 持久化数据到命名卷
    ports:
      - "3306:3306"  # 映射数据库端口
    networks:
      - my-network

volumes:
  db-data:  # 定义命名卷，数据持久化存储

networks:
  my-network:  # 定义自定义网络，服务间通信
    driver: bridge  # 使用桥接网络模式

     模板说明

  1. version
    指定 Docker Compose 文件格式版本（如 3.8、3.9）。建议使用较新的版本以支持更多功能。

  2. services
    定义所有服务（每个服务对应一个容器），常见配置项包括：

    • image: 使用的镜像（如 nginx 或自定义镜像）。
    • container_name: 自定义容器名称（不推荐大规模使用，易冲突）。
    • ports: 端口映射（格式："主机端口:容器端口"）。
    • volumes: 挂载本地目录或命名卷（用于数据持久化）。
    • environment: 环境变量（等价于 ENV 指令）。
    • depends_on: 依赖关系（控制服务启动顺序，但不保证服务完全可用）。
    • restart: 重启策略（如 unless-stopped 表示容器停止前一直重启）。
    • networks: 指定服务加入的网络。

  3. volumes
    定义命名卷，用于数据持久化（如数据库数据、应用日志等）。

  4. networks
    定义自定义网络，实现服务间通信和隔离。默认使用 bridge 驱动。

     多环境配置（可选） 如果需要区分开发、测试和生产环境，可以使用多个 docker-compose.yml 文件：

  • 基础配置：docker-compose.yml
  • 开发环境覆盖：docker-compose.override.yml
  • 生产环境覆盖：docker-compose.prod.yml

         启动命令示例

# 使用基础配置 + 开发覆盖文件
docker-compose up -d

# 使用基础配置 + 生产覆盖文件
docker-compose -f docker-compose.yml -f docker-compose.prod.yml up -d

     注意事项

  1. YAML 格式

    • 缩进必须使用空格（推荐 2 个或 4 个空格，且整份文件统一）。
    • 列表项使用短横线 - 开头。

  2. 环境变量
    可通过 .env 文件管理敏感信息（如密码），避免直接写入 docker-compose.yml：

    # .env 文件
DB_PASSWORD=your_password

    在 docker-compose.yml 中引用：

    environment:
  - MYSQL_ROOT_PASSWORD=${DB_PASSWORD}

  3. 健康检查（可选）
    为服务添加健康检查，确保依赖服务可用：

    healthcheck:
  test: ["CMD", "curl", "-f", "http://localhost/"]
  interval: 30s
  timeout: 5s
  retries: 3

     完整案例 假设有一个包含 Web 应用和 MySQL 的项目，docker-compose.yml 如下：

version: '3.9'
services:
  web:
    build: ./web-app  # 使用本地 Dockerfile 构建镜像
    ports:
      - "8080:80"
    depends_on:
      - db
    environment:
      - DB_HOST=db
      - DB_USER=root
      - DB_PASSWORD=${DB_PASSWORD}
    networks:
      - app-network

  db:
    image: mysql:8
    environment:
      MYSQL_ROOT_PASSWORD: ${DB_PASSWORD}
    volumes:
      - db-data:/var/lib/mysql
    networks:
      - app-network

volumes:
  db-data:

networks:
  app-network:
    driver: bridge

通过这个模板，你可以快速搭建多容器应用，并根据需求扩展配置。需要更复杂的场景（如负载均衡、自定义网络驱动等），可参考 Docker Compose 官方文档。













9️⃣ 参考 9

以下是一个通用的 docker-compose.yml 模板，包含了常见的多容器应用配置（Web服务、数据库、缓存等），并附带详细注释以便理解和修改：

# Docker Compose 配置模板
# 使用版本 3.8（兼容大多数现代Docker版本）
version: '3.8'

# 定义所有服务（容器）
services:
  # Web应用服务（示例：Node.js/Python/Java等应用）
  web:
    # 构建当前目录下的Dockerfile（如需使用现有镜像，可替换为image: 镜像名）
    build: .
    # 容器名称（可选）
    container_name: app-web
    # 端口映射：主机端口:容器端口
    ports:
      - "80:3000"  # 主机80端口映射到容器3000端口
    # 环境变量配置（敏感信息建议使用.env文件）
    environment:
      - NODE_ENV=production  # 示例：Node.js环境
      - DB_HOST=db           # 数据库服务名（容器间通过服务名通信）
      - DB_PORT=5432
      - REDIS_HOST=redis
    # 依赖关系：启动web前先启动db和redis
    depends_on:
      - db
      - redis
    # 挂载卷：主机目录:容器目录（持久化数据或代码热更新）
    volumes:
      - ./app:/usr/src/app   # 代码目录挂载（开发环境用）
      - logs:/usr/src/app/logs  # 日志目录持久化
    # 网络配置（使用自定义网络）
    networks:
      - app-network
    # 重启策略：容器退出时自动重启
    restart: unless-stopped

  # 数据库服务（示例：PostgreSQL）
  db:
    # 使用官方PostgreSQL镜像
    image: postgres:14-alpine
    container_name: app-db
    # 端口映射（可选，外部访问用）
    ports:
      - "5432:5432"
    environment:
      - POSTGRES_USER=${DB_USER}      # 从.env文件读取变量
      - POSTGRES_PASSWORD=${DB_PASS}
      - POSTGRES_DB=${DB_NAME}
    # 数据持久化：使用命名卷
    volumes:
      - postgres-data:/var/lib/postgresql/data
      - ./init-scripts:/docker-entrypoint-initdb.d  # 初始化脚本目录
    networks:
      - app-network
    restart: unless-stopped
    # 健康检查：确保数据库就绪
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${DB_USER} -d ${DB_NAME}"]
      interval: 10s
      timeout: 5s
      retries: 5

  # 缓存服务（示例：Redis）
  redis:
    image: redis:7-alpine
    container_name: app-redis
    ports:
      - "6379:6379"
    volumes:
      - redis-data:/data
    # Redis配置（可选）
    command: redis-server --requirepass ${REDIS_PASS}
    networks:
      - app-network
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "redis-cli", "-a", "${REDIS_PASS}", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5

# 定义命名卷（用于数据持久化）
volumes:
  postgres-data:  # 数据库数据卷
  redis-data:     # Redis数据卷
  logs:           # 日志数据卷

# 定义自定义网络（容器间通信）
networks:
  app-network:
    driver: bridge  # 桥接网络（默认）

使用说明：

  1. 环境变量配置： 建议创建 .env 文件存储敏感信息（与 docker-compose.yml 同目录），示例：

    # .env 文件内容
DB_USER=appuser
DB_PASS=strongpassword
DB_NAME=appdb
REDIS_PASS=redispassword

  2. 服务定制：

    • 根据实际需求修改 services 中的服务（添加/删除服务、修改镜像或构建方式）
    • 调整端口映射（ports）、环境变量（environment）和数据卷（volumes）

  3. 常用命令：

    # 启动所有服务（后台运行）
docker-compose up -d

# 查看服务状态
docker-compose ps

# 查看日志
docker-compose logs -f [服务名]

# 停止服务
docker-compose down

# 停止服务并删除数据卷
docker-compose down -v

  4. 扩展建议：

    • 可添加 nginx 服务作为反向代理
    • 对于生产环境，建议添加 labels 用于服务发现或监控
    • 增加 deploy 配置（需使用 docker stack 部署）实现容器编排

这个模板适用于大多数Web应用场景，可根据具体技术栈（如替换PostgreSQL为MySQL、替换Redis为Memcached等）进行调整。













🔟 参考 10

下面给出一个通用且可扩展的 docker-compose.yml 模板，涵盖了常用字段、注释说明以及典型服务示例（以 Nginx + MySQL + Redis + 自定义后端服务为例）。你可以直接复制后按需增删调整。

     ✅ 通用模板

# docker-compose.yml
# 版本号：使用兼容当前 Docker Engine 的 Compose 规范版本
# 官方文档：https://docs.docker.com/compose/compose-file/
version: "3.9"

# 全局网络：让服务之间通过服务名即可互通
networks:
  app_net:
    driver: bridge

# 全局卷：持久化数据，避免容器删除后数据丢失
volumes:
  mysql_data:
  redis_data:
  app_logs:

services:
  # ----------------- Nginx -----------------
  nginx:
    image: nginx:1.25-alpine
    container_name: nginx
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro        # 主配置
      - ./nginx/conf.d:/etc/nginx/conf.d:ro               # 站点配置
      - ./nginx/ssl:/etc/nginx/ssl:ro                     # 证书
      - app_logs:/var/log/nginx                           # 日志持久化
    depends_on:
      - backend
    networks:
      - app_net

  # ----------------- MySQL -----------------
  mysql:
    image: mysql:8.0
    container_name: mysql
    restart: unless-stopped
    environment:
      MYSQL_ROOT_PASSWORD: rootpwd
      MYSQL_DATABASE: appdb
      MYSQL_USER: appuser
      MYSQL_PASSWORD: apppwd
    ports:
      - "3306:3306"
    volumes:
      - mysql_data:/var/lib/mysql
      - ./mysql/init:/docker-entrypoint-initdb.d          # 初始化脚本
    command:
      [
        "--character-set-server=utf8mb4",
        "--collation-server=utf8mb4_unicode_ci",
        "--default-authentication-plugin=mysql_native_password"
      ]
    networks:
      - app_net

  # ----------------- Redis -----------------
  redis:
    image: redis:7-alpine
    container_name: redis
    restart: unless-stopped
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
    command: redis-server --appendonly yes --requirepass redispwd
    networks:
      - app_net

  # ----------------- 自定义后端服务 -----------------
  backend:
    build:
      context: ./backend             # Dockerfile 所在目录
      dockerfile: Dockerfile         # 可省略，默认为 Dockerfile
    container_name: backend
    restart: unless-stopped
    environment:
      # 将敏感信息放到 .env 文件，这里仅示例
      DB_HOST: mysql
      DB_PORT: 3306
      DB_NAME: appdb
      DB_USER: appuser
      DB_PASS: apppwd
      REDIS_HOST: redis
      REDIS_PORT: 6379
      REDIS_PASS: redispwd
    depends_on:
      - mysql
      - redis
    volumes:
      - ./backend:/app               # 开发时可挂载源码热重载
      - app_logs:/app/logs           # 日志持久化
    networks:
      - app_net

     📁 推荐目录结构

project-root/
├── docker-compose.yml
├── .env                      # 环境变量
├── nginx/
│   ├── nginx.conf
│   ├── conf.d/
│   │   └── default.conf
│   └── ssl/
├── mysql/
│   └── init/
├── redis/
├── backend/
│   ├── Dockerfile
│   └── ...

     🔐 .env 示例（可选）

# .env
MYSQL_ROOT_PASSWORD=rootpwd
MYSQL_DATABASE=appdb
MYSQL_USER=appuser
MYSQL_PASSWORD=apppwd
REDIS_PASSWORD=redispwd

     🚦 常用命令

# 启动并后台运行
docker-compose up -d

# 查看日志
docker-compose logs -f [service]

# 重启单个服务
docker-compose restart [service]

# 停止并删除容器、网络
docker-compose down

# 重建镜像
docker-compose build --no-cache [service]

     ✅ 可扩展方向

  • 多环境（dev/test/prod）：使用 docker-compose.override.yml 或 -f 指定不同文件
  • 健康检查：给每个服务加 healthcheck 字段
  • 资源限制：加 deploy.resources.limits（Swarm 或 Compose v2.4+）
  • 日志驱动：配置 logging.driver 到 Loki / ELK
  • 安全：使用 secrets 管理敏感信息（Swarm/K8s 场景）

如果你有具体技术栈（如 Node.js、Spring Boot、Django、Go 等），告诉我，我可以帮你再精简一份针对性模板。













🤔 参考 11

Docker Compose 文件模板示例

Docker Compose 是一个用于定义和运行多容器 Docker 应用程序的工具，其核心是 docker-compose.yml 文件。该文件通过 YAML 语法配置服务、网络、卷等资源，帮助您轻松部署和管理应用。下面我将逐步提供一个实用的模板示例，并解释关键部分。模板基于常见最佳实践，确保真实可靠。

     基本模板示例 这是一个简单但完整的 docker-compose.yml 模板，适用于一个 Web 应用（如 Nginx）和一个数据库服务（如 PostgreSQL）。它覆盖了版本定义、服务配置、网络和卷等核心元素。

# 指定 Docker Compose 文件版本，确保兼容性（推荐使用 '3.8' 或更高）
version: '3.8'

# 定义服务（每个服务对应一个容器）
services:
  # Web 服务示例（例如 Nginx）
  web:
    image: nginx:latest  # 使用官方镜像
    container_name: my_web_container  # 自定义容器名称
    ports:
      - "8080:80"  # 映射主机端口到容器端口
    volumes:
      - ./html:/usr/share/nginx/html  # 挂载主机目录到容器
      - ./nginx.conf:/etc/nginx/nginx.conf  # 挂载配置文件
    environment:
      - NGINX_ENV=production  # 设置环境变量
    restart: always  # 容器退出时自动重启
    networks:
      - app_network  # 连接到自定义网络

  # 数据库服务示例（例如 PostgreSQL）
  db:
    image: postgres:13
    container_name: my_db_container
    environment:
      POSTGRES_USER: admin
      POSTGRES_PASSWORD: secret  # 建议使用 secrets 更安全
    volumes:
      - db_data:/var/lib/postgresql/data  # 使用持久化卷
    restart: on-failure
    networks:
      - app_network

# 定义网络（确保服务间通信）
networks:
  app_network:
    driver: bridge  # 使用桥接网络

# 定义卷（用于持久化数据）
volumes:
  db_data:  # 卷名称
    driver: local  # 本地存储驱动

     关键部分解释

  1. version：指定文件格式版本（如 '3.8'），确保与 Docker Engine 兼容。新版本支持更多功能如资源限制。
  2. services：每个服务代表一个容器：
    • image：指定 Docker 镜像（如 nginx:latest）。
    • ports：端口映射格式为 "主机端口:容器端口"。
    • volumes：挂载主机目录或卷，例如 ./html:/usr/share/nginx/html 将本地目录绑定到容器。
    • environment：设置环境变量，可直接列出或使用文件（如 env_file: .env）。
    • restart：定义重启策略（always 或 on-failure）。
    • networks：连接自定义网络，确保服务间隔离和通信。
  3. networks：创建自定义网络（如 app_network），使用 driver: bridge 作为默认选项。
  4. volumes：定义持久化存储卷（如 db_data），避免容器重启时数据丢失。支持本地或 NFS 驱动。

     稍复杂的模板示例（带资源限制） 如果需要更高级配置（如 CPU/内存限制），可扩展模板。以下示例添加了资源管理和多环境支持：

version: '3.8'

services:
  web:
    image: nginx:alpine
    container_name: optimized_web
    ports:
      - "80:80"
    volumes:
      - type: bind
        source: ./config
        target: /etc/nginx
    environment:
      - TZ=Asia/Shanghai  # 设置时区
    deploy:  # 资源限制（适用于 Docker Swarm 或单机）
      resources:
        limits:
          cpus: '0.5'  # 限制 CPU 使用率
          memory: 256M  # 限制内存
    networks:
      - backend

  api:
    image: python:3.9
    command: python app.py
    depends_on:  # 依赖其他服务
      - db
    env_file: .env  # 从文件加载环境变量
    networks:
      - backend

  db:
    image: postgres:14
    volumes:
      - pg_data:/var/lib/postgresql/data
    environment:
      POSTGRES_DB: mydb

networks:
  backend:
    driver: bridge

volumes:
  pg_data:
    driver: local
    driver_opts:
      type: nfs  # 使用 NFS 存储
      o: addr=192.168.1.1,rw
      device: ":/nfs/share"

     使用指南

  1. 保存文件：将上述代码复制到名为 docker-compose.yml 的文件中。
  2. 启动服务：在终端运行 docker-compose up -d 启动所有服务（-d 表示后台运行）。
  3. 管理服务：使用命令如 docker-compose ps 查看状态，docker-compose down 停止服务。
  4. 自定义：根据您的应用修改镜像、端口或卷路径（例如，将 nginx 替换为您的应用镜像）。

这些模板覆盖了常见场景，您可根据需求调整。Docker Compose 的灵活性使其适用于开发、测试和生产环境。













🤔 参考 12

以下是一个常用的 docker-compose.yml 模板，结合了多服务配置、网络管理、数据卷挂载等核心功能，并附关键字段解析：

version: '3.8'  # 指定Compose文件版本 services:
  web:
    image: nginx:latest  # 使用官方Nginx镜像
    container_name: web_server  # 自定义容器名称 ports:
      - "8080:80"  # 主机端口:容器端口映射 volumes:
      - ./html:/usr/share/nginx/html  # 主机目录挂载
      - ./nginx.conf:/etc/nginx/nginx.conf  # 配置文件挂载
    environment:
      - NGINX_ENV=production  # 环境变量 depends_on:
      - db  # 服务依赖顺序 restart: always  # 重启策略 networks:
      - app_network  # 加入自定义网络

  db:
    image: mysql:8.0  # 使用MySQL 8.0镜像
    container_name: mysql_db
    environment:
      - MYSQL_ROOT_PASSWORD=root123  # 数据库密码
      - MYSQL_DATABASE=myapp  # 初始化数据库
    volumes:
      - db_data:/var/lib/mysql  # 数据持久化 ports:
      - "3306:3306"
    restart: unless-stopped  # 优雅重启策略
    networks:
      - app_network

  redis:
    image: redis:alpine  # 轻量级Redis镜像
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data  # 数据持久化
    networks:
      - app_network

volumes:  # 全局数据卷定义 db_data:
redis_data:

networks:  # 自定义网络 app_network:
  driver: bridge  # 使用桥接网络

     核心配置解析

  1. 版本声明
    version: '3.8' 指定Compose文件格式版本，建议使用最新稳定版（如3.8+）。

  2. 服务配置

    • image：指定镜像名称及标签
    • build：通过Dockerfile构建镜像（需配合context和dockerfile字段）
    • ports：端口映射格式为主机端口:容器端口
    • environment：设置环境变量，支持数组格式
    • depends_on：定义服务启动顺序（不保证服务就绪）
    • restart：重启策略（always/unless-stopped/on-failure）

  3. 数据持久化

    • volumes：
      • 绑定挂载：./data:/var/lib/mysql（主机目录↔容器目录）
      • 命名卷：db_data:/var/lib/mysql（跨容器共享数据）

  4. 网络配置

    • networks：自定义网络便于服务间通信
    • driver：网络驱动类型（默认bridge）

     高级配置建议

  1. 健康检查

    healthcheck:
  test: ["CMD", "curl", "-f", "http://localhost:80"]
  interval: 30s
  timeout: 10s
  retries: 3

  2. 资源限制

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

  3. 多环境配置

    environment:
  - DB_HOST=${DB_HOST}  # 通过.env文件引用变量

     使用场景示例

  • Web应用：Nginx + 后端API + 数据库 + 缓存
  • 微服务架构：多个微服务共享网络和数据卷
  • 开发/生产环境：通过不同Compose文件切换配置

提示：建议将敏感信息（如密码）通过.env文件或Docker Secrets管理，避免硬编码 。













🤔 参考 13

以下是一个通用的 docker-compose.yml 模板示例，适用于大多数 Docker Compose 场景。根据你的具体需求（如 Web 服务、数据库、缓存等），可以在此基础上扩展配置。

version: '3.8'  # 推荐使用较新的语法版本

services:
  #---------- 示例 1: Web 服务 ----------
  webapp:
    image: your-web-image:latest  # 使用镜像名称
    build: .  # 或通过 Dockerfile 构建（如果本地没有镜像）
    container_name: my_webapp  # 自定义容器名称（可选）
    restart: unless-stopped  # 自动重启策略
    ports:
      - "8080:80"  # 宿主机端口:容器端口
    volumes:
      - ./app:/var/www/html  # 挂载本地目录到容器
    environment:
      - ENV_VARIABLE=value
    depends_on:
      - db  # 依赖其他服务
      - redis

  #---------- 示例 2: 数据库服务 ----------
  db:
    image: mysql:8.0
    container_name: mysql_db
    restart: always
    ports:
      - "3306:3306"
    volumes:
      - mysql_data:/var/lib/mysql  # 持久化数据卷
    environment:
      MYSQL_ROOT_PASSWORD: rootpassword
      MYSQL_DATABASE: mydb
      MYSQL_USER: user
      MYSQL_PASSWORD: password

  #---------- 示例 3: Redis 服务 ----------
  redis:
    image: redis:alpine
    container_name: my_redis
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
    command: redis-server --requirepass yourpassword  # 设置密码

#---------- 自定义网络（可选） ----------
networks:
  default:  # 使用默认网络
    driver: bridge

#---------- 数据卷声明 ----------
volumes:
  mysql_data:  # 对应 db 服务的 volumes
  redis_data:  # 对应 redis 服务的 volumes

     常用命令

# 启动服务（后台运行）
docker-compose up -d

# 停止并删除容器
docker-compose down

# 查看日志
docker-compose logs -f

# 重新构建镜像并启动
docker-compose up --build

# 仅启动特定服务（如仅启动 db 和 redis）
docker-compose up -d db redis

     常见配置说明

  1. version: 不同版本语法有差异，推荐 3.x。
  2. volumes:
    • 挂载本地目录: ./local/path:/container/path
    • 命名数据卷: volume_name:/container/path
  3. environment:
    • 直接定义变量: KEY=value
    • 使用 .env 文件: env_file: .env
  4. networks:
    • 自定义网络可实现服务隔离
  5. depends_on: 控制服务启动顺序（但不保证服务完全就绪）

     实用提示

  1. 复杂项目拆分：可以用多个 Compose 文件（如 docker-compose.override.yml）管理不同环境
  2. 端口冲突：如果端口被占用，修改宿主机端口（如 "新端口:容器端口"）
  3. 调试工具：临时启动工具容器：
debug-tool:
  image: busybox
  command: sleep 3600
  networks:
    - default













🤔 参考 14

Of course! Here is a comprehensive guide to docker-compose.yml, starting with a simple, well-commented template and then explaining its parts with practical examples.

     Quick Answer: The Most Common Minimal docker-compose.yml

This is the most common starting point for a single web application like WordPress, Ghost, or a custom Node.js app. It uses an official image from Docker Hub.

# Use this file to easily start a single containerized app
version: '3.8' # Version of the Compose file format (good practice to specify)

services:
  webapp: # You can name this service anything you want
    image: nginx:latest       # Use the latest Nginx image from Docker Hub
    ports:
      - "8080:80"             # Map port 8080 on your host to port 80 in the container
    restart: unless-stopped   # Auto-restart the container unless explicitly stopped

To run it, save this as docker-compose.yml and execute docker compose up in the same directory. You can stop it with docker compose down.

     Full Explanation & More Powerful Examples

Below is a detailed, commented template followed by breakdowns of each section. We will build upon a more complex hypothetical scenario: a Python/Flask web application connected to a PostgreSQL database.

         The Complete Example Template

This example demonstrates multiple services, environment variables, volumes, and networks—the most common production-like setup.

# =========================================================================================
#                                  EXAMPLE PROJECT
# =========================================================================================
# This file defines two services: a Flask web application and a PostgreSQL database.
# They are linked together and will be treated as a single application unit.

version: '3.8' # Specifies the version of the Compose File format. '3.8' is modern and stable.

services:       # Top-level key. Lists all the containers involved in our application.

  # -----------------------------------
  # Service 1: The Backend API (App)
  # -----------------------------------
  app:                     # Name of the service (can be anything, e.g., "backend", "api")
    build: .              # Tells Compose to build an image from a Dockerfile in the current directory
                            # This is useful for your own custom applications. Instead of `image`, we use `build`.
    image: my-flask-app   # Optionally specify a tag name for the built image. Deviates from 'none':latest
    container_name: flask_container # A friendly name for the container itself (visible in `docker ps`)
    environment:          # Set environment variables inside the container
      - APP_SETTINGS=production
      - DATABASE_URL=postgresql://postgres:mysecretpassword@db:5432/mydatabase # Refers to the 'db' service below
    secrets:              # More secure way to pass sensitive data than environment variables
      - db_password      # Must match the secret definition below
    depends_on:           # Ensures this service starts only after the following ones are ready
      - db               # Our app needs the database running first
    restart: unless-stopped # Gracefully restart the container if it exits, unless manually stopped
    networks:             # Connect this service to a specific network
      - app-network      # Allows communication with other services on this network

  # -----------------------------------
  # Service 2: The Database (PostgreSQL)
  # -----------------------------------
  db:                           # Name of the second service
    image: postgres:15-alpine # Use a specific version of an official Postgres image. 'alpine' is smaller.
    volumes:                    # Persist data even if the container is deleted. CRITICAL FOR DBs!
      - db_data:/var/lib/postgresql/data # Create a named volume 'db_data' and map it to the DB storage directory
    environment:
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD_FILE=/run/secrets/db_password # Special variable watched by Postgres
    secrets:
      - db_password
    networks:
      - app-network

  # -----------------------------------
  # Service 3: The Frontend (React App)
  # -----------------------------------
  frontend:
    image: my-react-app     # Assumes you have built and pushed this image yourself
    stdin_open: true        # Allows catching keyboard interrupts (Ctrl+C) even if not attached
    depends_on:
      - app                # Frontend depends on the API being available
    networks:
      - app-network

# -----------------------------------
# Top-Level Options Affecting All Services Globally
# -----------------------------------
volumes:                 # VROLUMNES DEFINED AT THE TOP LEVEL BECOME "NAMED" VOLUMES
  db_data:               # This creates a reusable, persistent volume named 'db_data'
                         # Using a named volume makes it easier to manage and backup.

secrets:                 # Another top-level section for managing sensitive data securely
  db_password:           # Named secret. Its content comes from the file below.
    file: ./db_password.txt # Create this file with the actual password inside (one per line)

networks:                # Custom networks allow controlled communication between services.
  app-network:           # Named network. Only services explicitly added can communicate.
    driver: bridge        # Most common network driver. Other options exist (host, none, overlay).

     Key Concepts & Commands Breakdown

         1. services: (Core Concept) This is the heart of your file. Each item under services: represents one container. You can define multiple microservices that make up your application.

FieldPurposeExample
buildBuild an image from a Dockerfile instead of pulling a pre-made one.build: . (looks for Dockerfile in the current dir)
imageUse a pre-existing image from a registry like Docker Hub.image: postgres:15
container_nameA human-readable name for the running container instance.container_name: my_special_container
portsMap ports from your host machine to the container. HOST:CONTAINER.ports: "8080:80" (Host port 8080 → Container port 80)
environmentSet non-sensitive environment variables.environment: - FOO=bar - BAR=baz
secretsSecurely pass sensitive data (credentials, API keys). Preferred over env vars.secrets: - my_super_secret
depends_onControl the startup order of services. Does not wait for health.depends_on: - db - redis
restartPolicy for automatically restarting the container on failure.restart: unless-stopped, restart: always, no
volumesMount paths from the host or named volumes into the container. Primarily for persisting data.volumes: - ./config:/app/config - db_data:/var/lib/mysql

         2. Top-Level Keywords (Outside services:) These apply globally across your entire stack.

FieldPurposeExample
versionDeclares the syntax version of the Compose file. Always include it!version: '3.8'
volumesDefine named volumes here to make them easy to manage and reuse across services.volumes: db_data:
networksDefine custom networks to control which services can communicate with each other.networks: app-network:
secretsStore sensitive data files centrally. Used in combination with the secrets: field inside a service.secrets: db_password: file: ./secrets/db_pw.txt

         Essential docker compose Commands

  • Start Up: docker compose up
    • Add -d for detached mode (runs in the background): docker compose up -d
    • To follow logs in real-time: docker compose logs -f
  • Stop & Remove: docker compose down
    • Removes containers and networks. With volumes, it removes named volumes declared at the top level (be careful!). Add -v to also remove anonymous volumes attached to containers.
  • View Status: docker compose ps (shows running containers)
  • Build Images: docker compose build (before up if you changed the Dockerfile)

     Simpler Variations

         Variation 1: Using docker-compose config to validate your YML file Before running anything, always validate your syntax!

docker compose config

This command will print out the final configuration that Compose will use, including any merged defaults. It's excellent for debugging.

         Variation 2: Minimalist File for a Single Service using image Perfect for quick tests or simple apps.

version: '3.8'
services:
  myservice:
    image: busybox # Tiny base image for testing
    stdin_open: true # Allows you to interact with it via `docker exec`

Run it with docker compose up, then run docker compose exec myservice sh to get a shell inside.













🤔 参考 15

以下是一个通用的 docker-compose.yml 文件模板，结合了常见配置项和最佳实践，适用于大多数多容器应用场景。模板基于 Docker Compose v3.8（兼容 Docker Engine 19.03+），并附详细注释说明：

version: '3.8'  # 推荐使用 3.8 版本，兼容性好且功能全面

services:
  # Web 服务示例（如 Nginx）
  web:
    image: nginx:latest  # 使用官方镜像
    container_name: my_web  # 自定义容器名称（若需扩展副本，建议省略此配置）
    ports:
      - "8080:80"  # 宿主机端口:容器端口映射
    volumes:
      - ./html:/usr/share/nginx/html  # 挂载主机目录到容器（静态文件）
      - ./nginx.conf:/etc/nginx/nginx.conf  # 挂载配置文件
    environment:
      - TZ=Asia/Shanghai  # 设置时区
      - NGINX_ENV=production  # 自定义环境变量
    networks:
      - app_network  # 加入自定义网络
    depends_on:
      - db  # 控制启动顺序（不保证服务就绪）
    restart: unless-stopped  # 重启策略（推荐）
    healthcheck:  # 健康检查（确保服务可用）
      test: ["CMD", "curl", "-f", "http://localhost:80"]
      interval: 30s
      timeout: 10s
      retries: 3

  # 数据库服务示例（如 MySQL）
  db:
    image: mysql:8.0
    container_name: my_db
    environment:
      MYSQL_ROOT_PASSWORD: rootpass  # 必填项
      MYSQL_DATABASE: app_db
      MYSQL_USER: user
      MYSQL_PASSWORD: pass
    volumes:
      - db_data:/var/lib/mysql  # 持久化数据到命名卷
    networks:
      - app_network
    command: --default-authentication-plugin=mysql_native_password  # 覆盖启动命令
    deploy:  # 资源限制（v3 格式）
      resources:
        limits:
          cpus: '0.5'
          memory: 1G

# 数据卷定义（持久化存储）
volumes:
  db_data:  # 命名卷，由 Docker 管理存储位置

# 自定义网络（隔离容器通信）
networks:
  app_network:
    driver: bridge  # 默认桥接模式，支持服务间域名解析

     关键配置说明

  1. 服务编排

    • depends_on：控制服务启动顺序（但需配合健康检查确保依赖就绪）。
    • healthcheck：推荐添加，避免依赖服务未完全启动导致问题（如数据库初始化）。

  2. 数据持久化

    • 命名卷（如 db_data）：由 Docker 管理存储位置，适合数据库文件。
    • 主机目录挂载（如 ./html）：开发时方便修改代码或配置。

  3. 资源限制
    使用 deploy.resources 限制 CPU/内存（生产环境必选），避免单容器耗尽主机资源。

  4. 网络隔离
    自定义 bridge 网络提供安全隔离，服务间可通过服务名（如 db）直接通信。

     进阶使用场景          1. 自定义镜像构建

services:
  app:
    build:
      context: .  # Dockerfile 所在目录
      dockerfile: Dockerfile.prod  # 指定文件名
      args:  # 构建参数
        APP_VERSION: 1.0
    image: my_app:latest  # 构建后的镜像名称

         2. 多容器初始化顺序

services:
  worker:
    depends_on:
      db:
        condition: service_healthy  # 依赖服务通过健康检查后才启动

         3. 环境变量管理

env_file: .env  # 从文件加载环境变量（避免硬编码）

     常见问题

  • YAML 格式错误：严格使用空格缩进（禁用 Tab），键值后保留空格（如 ports: - "80:80"）。
  • 版本兼容性：Compose 文件版本需匹配 Docker Engine 版本（查看兼容矩阵）。
  • 服务扩展限制：若需使用 docker-compose up --scale web=3 扩展副本，不要设置 container_name。

完整示例可参考 Docker 官方文档 或 CSDN 示例。实际部署时，建议根据应用需求调整资源限制、健康检查策略和持久化方案。













🤔 参考 16

以下是一个基本的 docker-compose.yml 模板及注释说明，适用于常见的多容器应用场景：

# 指定 Docker Compose 版本（推荐版本 3+）
version: '3.8'

# 定义所有服务（容器）
services:
  # 第一个服务：Web 应用（示例）
  web:
    # 使用 Dockerfile 构建镜像（或直接使用现有镜像）
    build: .
    # 从 .env 文件加载环境变量（可选）
    env_file:
      - .env
    # 设置环境变量（优先级高于 env_file）
    environment:
      - APP_ENV=production
    # 容器名称（可选）
    container_name: my_web_app
    # 端口映射：主机端口:容器端口
    ports:
      - "80:80"
      - "443:443"
    # 挂载卷（持久化数据）
    volumes:
      - ./app:/app
      - static_data:/app/static
    # 依赖的服务（会先启动依赖项）
    depends_on:
      - db
      - redis
    # 自定义网络
    networks:
      - app_network

  # 第二个服务：数据库（以 PostgreSQL 为例）
  db:
    image: postgres:15
    container_name: postgres_db
    restart: always
    environment:
      POSTGRES_USER: admin
      POSTGRES_PASSWORD: secret
      POSTGRES_DB: mydb
    volumes:
      - pg_data:/var/lib/postgresql/data
    networks:
      - app_network

  # 第三个服务：Redis 缓存
  redis:
    image: redis:7
    container_name: redis_cache
    command: redis-server --requirepass yourpassword
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
    networks:
      - app_network

# 定义卷（数据持久化）
volumes:
  static_data:
  pg_data:
  redis_data:

# 自定义网络（容器间通信隔离）
networks:
  app_network:
    driver: bridge

     核心配置说明

  1. version
    指定 Compose 文件格式版本，3.x+ 支持 Docker Swarm 等现代特性。

  2. services
    定义多个容器服务，每个服务对应一个容器配置项：

    • build: 通过本地 Dockerfile 构建镜像
    • image: 直接使用 Docker Hub 或私有仓库中的镜像
    • ports: 端口映射（主机端口:容器端口）
    • volumes: 挂载持久化数据卷
    • environment/env_file: 环境变量配置
    • depends_on: 定义服务启动顺序依赖
    • networks: 指定容器连接的网络

  3. volumes
    声明命名的持久化存储卷，避免容器重启后数据丢失。

  4. networks
    自定义容器间的通信网络（默认使用 bridge 驱动）。

     常用扩展配置

# 资源限制（CPU/内存）
deploy:
  resources:
    limits:
      cpus: '0.5'
      memory: 512M

# 健康检查
healthcheck:
  test: ["CMD", "curl", "-f", "http://localhost"]
  interval: 30s
  timeout: 10s
  retries: 3

# 重启策略
restart: unless-stopped  # 选项：no, always, on-failure, unless-stopped

     使用方式

  1. 将文件保存为 docker-compose.yml
  2. 启动服务（后台运行加 -d 参数）： 
    docker-compose up -d
  3. 停止并删除容器： 
    docker-compose down

可以根据您的具体需求调整服务、卷和网络配置！













🤔 参考 17

以下是一个标准化的 docker-compose.yml 文件模板，结合了多容器应用的常见配置场景，并附带关键字段解析和最佳实践建议。内容综合自 Docker 官方文档及行业实践。

     docker-compose.yml 模板

version: '3.8'  # 推荐使用 3.8 版本（需 Docker Engine 19.03+）

services:
  # Web 服务（示例：Nginx）
  web:
    image: nginx:alpine  # 使用轻量级镜像
    container_name: my_web  # 自定义容器名称（注意：指定后无法扩展副本）
    ports:
      - "80:80"  # 主机端口:容器端口
      - "443:443"
    volumes:
      - ./html:/usr/share/nginx/html  # 绑定挂载（主机目录:容器目录）
      - nginx_config:/etc/nginx/conf.d  # 命名卷
    environment:
      - TZ=Asia/Shanghai  # 时区设置
    depends_on:
      - app  # 依赖 app 服务先启动
    networks:
      - frontend
    restart: unless-stopped  # 容器退出时自动重启（除非手动停止）
    healthcheck:  # 健康检查
      test: ["CMD", "curl", "-f", "http://localhost"]
      interval: 30s
      timeout: 10s
      retries: 3

  # 应用服务（示例：自定义构建）
  app:
    build:
      context: ./app  # Dockerfile 所在目录
      dockerfile: Dockerfile.prod
      args:  # 构建参数
        NODE_ENV: production
    image: my_app:1.0  # 构建后的镜像名称
    env_file: .env  # 从文件加载环境变量（避免敏感信息硬编码）
    volumes:
      - app_data:/var/lib/data  # 命名卷持久化数据
    networks:
      - frontend
      - backend
    deploy:  # 资源限制（适用于生产环境）
      resources:
        limits:
          cpus: '0.5'
          memory: 512M

  # 数据库服务（示例：PostgreSQL）
  db:
    image: postgres:14
    environment:
      POSTGRES_USER: ${DB_USER}  # 从 .env 文件注入变量
      POSTGRES_PASSWORD_FILE: /run/secrets/db_password  # 使用 Docker Secrets
    volumes:
      - db_data:/var/lib/postgresql/data  # 命名卷持久化数据库
    networks:
      - backend
    secrets:
      - db_password  # 引用敏感数据

# 网络配置（隔离不同服务组）
networks:
  frontend:
    driver: bridge  # 默认桥接网络
  backend:
    ipam:
      config:
        - subnet: 172.20.0.0/24  # 自定义子网

# 卷配置（持久化数据）
volumes:
  nginx_config:  # 命名卷
  app_data:
  db_data:  # 数据库数据卷

# 敏感数据管理（Docker Secrets）
secrets:
  db_password:
    file: ./secrets/db_password.txt  # 密码存储在外部文件

     关键配置解析

  1. 服务依赖（depends_on）
    控制启动顺序（如 web 依赖 app），但不会等待依赖服务完全就绪。需结合 healthcheck 确保服务可用性。

  2. 数据持久化（volumes）

    • 命名卷（如 db_data）：由 Docker 管理存储位置，适合数据库文件。
    • 绑定挂载（如 ./html）：直接映射主机目录，适合代码或配置文件。

  3. 敏感信息管理

    • 使用 env_file 加载环境变量文件（避免密码硬编码）。
    • 生产环境推荐：secrets 字段从外部文件加载敏感数据（如数据库密码）。

  4. 健康检查（healthcheck）
    定义容器就绪状态检测策略，避免依赖服务未准备好时请求失败。

  5. 资源限制（deploy.resources）
    防止单个容器耗尽主机资源，需 Docker Swarm 或 Kubernetes 支持。

     最佳实践建议

  1. 版本控制

    • 固定 version: '3.8' 以保证兼容性。
    • 将 docker-compose.yml 和 .dockerignore 纳入 Git 仓库。

  2. 多环境配置

    • 基础配置：docker-compose.yml
    • 覆盖配置：docker-compose.override.yml（开发环境）、docker-compose.prod.yml（生产环境）
    • 启动命令：docker-compose -f docker-compose.yml -f docker-compose.prod.yml up。

  3. 网络隔离

    • 为前端、后端服务分配独立网络（如 frontend/backend），提升安全性。

  4. 避免常见错误

    • YAML 格式：缩进必须用空格（非 Tab），冒号后需空格（如 ports: - "80:80"）。
    • 端口冲突：使用 netstat -tulnp | grep <端口> 检查主机占用。

完整配置文档可参考：docs.docker.com/compose/com…













🤔 参考 18

以下是一个通用的 docker-compose.yml 模板，包含了常见的服务配置（Web服务、数据库、缓存等），你可以根据实际需求进行修改和扩展：

version: '3.8'

# 定义网络，使服务之间可以相互通信
networks:
  app-network:
    driver: bridge

# 定义数据卷，用于持久化数据
volumes:
  mysql-data:
  redis-data:
  app-data:

services:
  # Web服务器（Nginx示例）
  webserver:
    image: nginx:alpine
    container_name: webserver
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx/conf.d:/etc/nginx/conf.d
      - ./nginx/ssl:/etc/nginx/ssl
      - app-data:/var/www/html
    depends_on:
      - app
    networks:
      - app-network
    environment:
      - TZ=Asia/Shanghai

  # 应用服务（Node.js示例，可替换为Python/Java等）
  app:
    build:
      context: ./app
      dockerfile: Dockerfile
    container_name: app
    restart: unless-stopped
    volumes:
      - ./app:/usr/src/app
      - /usr/src/app/node_modules
      - app-data:/var/www/html
    depends_on:
      - mysql
      - redis
    networks:
      - app-network
    environment:
      - NODE_ENV=production
      - DB_HOST=mysql
      - DB_USER=root
      - DB_PASS=secret
      - DB_NAME=appdb
      - REDIS_HOST=redis
      - TZ=Asia/Shanghai
    # 健康检查
    healthcheck:
      test: ["CMD", "node", "healthcheck.js"]
      interval: 30s
      timeout: 10s
      retries: 3

  # 数据库（MySQL示例）
  mysql:
    image: mysql:8.0
    container_name: mysql
    restart: unless-stopped
    volumes:
      - mysql-data:/var/lib/mysql
      - ./mysql/init:/docker-entrypoint-initdb.d
    networks:
      - app-network
    environment:
      - MYSQL_ROOT_PASSWORD=secret
      - MYSQL_DATABASE=appdb
      - MYSQL_USER=appuser
      - MYSQL_PASSWORD=apppass
      - TZ=Asia/Shanghai
    command: --default-authentication-plugin=mysql_native_password
    # 健康检查
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost", "-u", "root", "-p$$MYSQL_ROOT_PASSWORD"]
      interval: 10s
      timeout: 5s
      retries: 5

  # 缓存服务（Redis示例）
  redis:
    image: redis:alpine
    container_name: redis
    restart: unless-stopped
    volumes:
      - redis-data:/data
    networks:
      - app-network
    environment:
      - TZ=Asia/Shanghai
    command: redis-server --requirepass redissecret
    # 健康检查
    healthcheck:
      test: ["CMD", "redis-cli", "-a", "redissecret", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5

这个模板包含以下特点：

  1. 多服务配置：包含Web服务器（Nginx）、应用服务（Node.js示例）、数据库（MySQL）和缓存（Redis）
  2. 数据持久化：使用volumes保存数据库和缓存数据
  3. 网络配置：自定义自定义网络确保服务间安全通信
  4. 环境配置：通过environment设置环境变量，敏感信息建议使用.env文件
  5. 健康检查：为关键服务添加健康检查确保服务可用性
  6. 时区配置：统一设置时区为Asia/Shanghai
  7. 自动重启：配置restart策略确保服务故障后自动恢复

使用方法：

  1. 根据实际需求修改服务镜像、端口映射和环境变量
  2. 可以删除不需要的服务（如不需要Redis可直接移除该部分）
  3. 敏感信息建议使用.env文件管理，在docker-compose.yml中用${VAR_NAME}引用
  4. 运行docker-compose up -d启动所有服务

你可以根据项目需求增减服务或调整配置参数。













🤔 参考 19

以下是一个通用的 docker-compose.yml 模板，涵盖了常见的配置选项，你可以根据具体的应用需求进行修改和扩展。

# 指定 Docker Compose 文件格式版本
# 常用版本：'3.8' (推荐，兼容性好，功能丰富)
version: '3.8'

# 定义服务（容器）
services:

  # 服务名称（自定义，如 web, db, redis 等）
  web:
    # 指定构建上下文，可以是路径或 Dockerfile 内容
    # 如果使用已存在的镜像，则用 `image` 替代 `build`
    # build:
    #   context: .          # 构建上下文目录（默认是当前目录）
    #   dockerfile: Dockerfile  # 指定 Dockerfile 文件名（可选）
    #   args:               # 构建时传递的参数
    #     BUILD_VERSION: 1.0

    # 或者直接使用已构建好的镜像
    image: nginx:alpine    # 例如使用官方 Nginx 镜像

    # 容器名称（可选，不推荐全局使用，避免冲突）
    # container_name: my-web-container

    # 端口映射：宿主机:容器
    ports:
      - "80:80"           # HTTP
      - "443:443"         # HTTPS

    # 卷挂载：宿主机目录/文件:容器目录
    volumes:
      - ./html:/usr/share/nginx/html   # 静态文件
      - ./nginx.conf:/etc/nginx/nginx.conf:ro  # 配置文件，只读

    # 环境变量
    environment:
      - ENV=production
      - DEBUG=false
    # 或从文件加载环境变量
    # env_file:
    #   - .env

    # 依赖的服务，确保 db 先启动
    depends_on:
      - db

    # 重启策略
    restart: unless-stopped

    # 网络
    networks:
      - app-network

  # 数据库服务示例
  db:
    image: mysql:8.0
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: example_root_password
      MYSQL_DATABASE: myapp
      MYSQL_USER: user
      MYSQL_PASSWORD: password
    volumes:
      - db_data:/var/lib/mysql   # 使用命名卷持久化数据
      - ./init.sql:/docker-entrypoint-initdb.d/init.sql  # 初始化脚本
    ports:
      - "3306:3306"
    networks:
      - app-network

  # 缓存服务示例
  redis:
    image: redis:alpine
    restart: always
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
    networks:
      - app-network

# 定义命名卷（用于数据持久化）
volumes:
  db_data:       # MySQL 数据卷
  redis_data:    # Redis 数据卷
  # 可以指定驱动或外部卷
  # db_data:
  #   driver: local
  #   driver_opts:
  #     type: none
  #     device: /path/on/host
  #     o: bind

# 定义网络
networks:
  app-network:
    driver: bridge   # 使用桥接网络
    # 可以指定子网、网关等
    # ipam:
    #   config:
    #     - subnet: 172.28.0.0/16

     🔧 常用命令

# 启动所有服务（后台运行）
docker-compose up -d

# 查看服务状态
docker-compose ps

# 查看日志
docker-compose logs -f

# 停止并删除容器、网络
docker-compose down

# 重新构建镜像（当 build 配置变化时）
docker-compose up -d --build

# 进入某个容器
docker-compose exec web sh

     ✅ 使用建议

  • 环境变量安全：敏感信息（如密码）建议通过 .env 文件管理，不要硬编码在 docker-compose.yml 中。
  • 命名卷：用于数据库等需要持久化数据的场景。
  • depends_on：仅控制启动顺序，不等待服务“就绪”，如需等待数据库完全启动，需配合脚本使用。
  • 版本选择：推荐使用 version: '3.8'，功能完整且兼容性好。

你可以根据你的应用栈（如 Node.js + MongoDB、Python + PostgreSQL 等）替换对应的服务配置。需要我为你生成某个具体技术栈的模板吗？













🤔 参考 20

以下是一个结构清晰、功能全面的 docker-compose.yml 模板，涵盖服务定义、网络配置、数据卷管理、依赖关系等核心功能，适用于大多数多容器应用场景：

version: '3.9'  # 推荐使用最新稳定版本

services:
  # Web服务示例（Nginx）
  web:
    image: nginx:latest  # 使用官方镜像或指定版本
    container_name: my_web_server  # 可选：自定义容器名称
    ports:
      - "8080:80"  # 主机端口:容器端口
    volumes:
      - ./html:/usr/share/nginx/html  # 绑定挂载（开发环境）
      - ./nginx.conf:/etc/nginx/nginx.conf  # 自定义配置文件
    environment:
      - NGINX_ENV_VAR=value  # 环境变量
    networks:
      - frontend
    depends_on:
      - app  # 依赖后端服务
    restart: always  # 自动重启策略

  # 后端服务示例（Node.js）
  app:
    build: ./app  # 基于本地Dockerfile构建
    container_name: my_app_server
    environment:
      - NODE_ENV=production
      - DB_HOST=db  # 服务发现（通过网络名称访问）
    networks:
      - frontend
      - backend
    depends_on:
      - db  # 依赖数据库服务
      - redis  # 依赖缓存服务

  # 数据库服务示例（MySQL）
  db:
    image: mysql:8.0
    container_name: my_database
    ports:
      - "3306:3306"
    volumes:
      - db_data:/var/lib/mysql  # 命名卷（生产环境推荐）
    environment:
      - MYSQL_ROOT_PASSWORD=rootpassword
      - MYSQL_DATABASE=myapp
    networks:
      - backend
    healthcheck:  # 健康检查
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
      interval: 10s
      timeout: 5s
      retries: 3

  # 缓存服务示例（Redis）
  redis:
    image: redis:latest
    container_name: my_redis
    ports:
      - "6379:6379"
    networks:
      - backend
    command: redis-server --requirepass redispassword  # 覆盖默认命令

# 自定义网络配置
networks:
  frontend:  # 前端网络（Web与App通信）
    driver: bridge
  backend:   # 后端网络（App、DB、Redis通信）
    driver: bridge
    internal: true  # 仅内部服务可访问

# 命名卷配置（持久化数据）
volumes:
  db_data:  # MySQL数据卷
    driver: local

     核心功能说明

  1. 服务定义

    • 每个服务独立配置镜像、端口、环境变量等。
    • 支持 image（直接使用镜像）或 build（基于Dockerfile构建）。

  2. 网络配置

    • 自定义网络：通过 networks 定义逻辑隔离的网络（如 frontend 和 backend）。
    • 服务发现：容器间通过服务名称（如 db）直接通信，无需硬编码IP。
    • 网络别名：可通过 aliases 为服务设置额外域名（示例未展示）。

  3. 数据持久化

    • 命名卷：db_data 卷确保MySQL数据持久化，即使容器销毁数据不丢失。
    • 绑定挂载：开发环境中将本地目录映射到容器（如 ./html:/usr/share/nginx/html）。

  4. 依赖管理

    • depends_on 控制服务启动顺序（如Web依赖App，App依赖DB）。
    • 健康检查：通过 healthcheck 确保服务完全就绪后再启动依赖服务。

  5. 重启策略

    • restart: always 确保容器崩溃时自动重启，提高可用性。

  6. 环境变量

    • 支持直接定义（environment）或从文件加载（env_file，示例未展示）。

     使用场景

  • 开发环境：

    • 使用绑定挂载实现代码热更新（如挂载本地代码目录到容器）。
    • 通过 docker-compose up -d 快速启动所有服务。

  • 生产环境：

    • 使用命名卷保障数据安全。
    • 结合 healthcheck 和 restart 策略提高稳定性。
    • 通过 .env 文件管理敏感信息（如数据库密码）。

     扩展建议

  • 多环境配置：通过 docker-compose -f docker-compose.yml -f docker-compose.prod.yml up 叠加不同环境配置。
  • 资源限制：添加 mem_limit、cpus 等字段限制容器资源使用。
  • Swarm模式：如需集群部署，可添加 deploy 字段（示例未展示）。

此模板可直接修改服务名称、镜像和配置参数以适配具体项目需求。





















avatar
文章
阅读
粉丝