Docker Compose 多容器编排语法和实践

在现代微服务架构中，一个应用往往由多个相互协作的容器组成。手动管理这些容器的生命周期、网络连接和数据卷挂载不仅繁琐，而且容易出错。Docker Compose作为Docker官方推出的多容器编排工具，通过声明式的YAML配置文件，让我们能够以代码的方式定义和管理整个应用栈，实现”一键部署”和”环境一致性”。

本文将从基础概念入手，深入解析Docker Compose的核心语法，通过三个完整的实战案例展示其强大功能，并分享生产环境中的最佳实践。无论你是刚接触容器化的新手，还是希望提升部署效率的运维工程师，都能从本文中获得有价值的知识。

一、Docker Compose 基础#

1.1 什么是Docker Compose#

Docker Compose是一个用于定义和运行多容器Docker应用程序的工具。它使用YAML文件来配置应用程序的服务，然后通过单个命令创建并启动所有服务。

Compose的核心优势在于：

声明式配置：用YAML文件描述应用架构，比命令行参数更易读、易维护
一键部署：单个docker compose up命令即可启动整个应用栈
环境一致性：开发、测试、生产环境使用相同的配置文件
服务依赖管理：自动处理服务之间的启动顺序和依赖关系
隔离环境：每个项目使用独立的网络命名空间，避免端口冲突

适用场景
Docker Compose特别适合单主机的开发、测试环境部署。对于跨主机的生产环境集群，建议使用Kubernetes等更强大的编排工具。

1.2 Docker Compose 安装#

Docker Compose现在已经集成在Docker Desktop中，Windows和Mac用户安装Docker Desktop后即可直接使用。对于Linux用户，需要单独安装：

1
# 下载Docker Compose v2.27.0（最新稳定版）
2
sudo curl -L "https://github.com/docker/compose/releases/download/v2.27.0/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
3

4
# 添加执行权限
5
sudo chmod +x /usr/local/bin/docker-compose
6

7
# 创建符号链接（可选，用于兼容旧命令）
8
sudo ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose
9

10
# 验证安装
11
docker-compose --version

版本选择建议
从Docker Compose V2开始，官方推荐使用docker compose（空格分隔）代替docker-compose（连字符分隔）命令。两者功能完全一致，本文将统一使用docker compose格式，更加符合Docker CLI的设计理念。

1.3 Docker Compose 工作流程#

Docker Compose的工作流程非常简单：

编写Dockerfile：为每个服务定义构建规则
编写docker-compose.yml：定义应用的服务、网络和数据卷
运行docker compose up：启动整个应用栈

Compose会自动完成以下工作：

创建一个以项目目录名为前缀的隔离网络
构建或拉取所需的镜像
创建并启动所有定义的服务
按照依赖关系顺序启动服务
将服务连接到共享网络

二、docker-compose.yml 核心语法详解#

docker-compose.yml是Docker Compose的核心配置文件，它使用YAML语法定义应用的各个组件。一个完整的docker-compose.yml文件通常包含以下顶级元素：

1
version: '3.8'  # Compose文件格式版本
2

3
services:       # 定义应用的服务
4
  service1:
5
    # 服务1的配置
6
  service2:
7
    # 服务2的配置
8

9
networks:       # 定义自定义网络
10
  network1:
11
    # 网络配置
12

13
volumes:        # 定义数据卷
14
  volume1:
15
    # 数据卷配置

2.1 版本声明#

Compose文件格式有多个版本，不同版本支持的功能不同。目前最常用的是3.x系列，最新稳定版是3.8。

版本	兼容性	主要特性
1.x	旧版	不支持网络和数据卷的顶级声明
2.x	Docker Engine 1.10+	引入网络和数据卷的顶级声明
3.x	Docker Engine 1.13+	支持Swarm模式，增加了部署、健康检查等功能
3.8	Docker Engine 19.03.0+	最新稳定版，支持所有现代特性

版本兼容性
版本声明是必须的，且必须是文件的第一行。不同版本的语法有差异，使用错误的版本会导致配置失效。建议统一使用3.8版本以获得最佳特性支持。

2.2 services 配置#

services是Compose文件中最重要的部分，它定义了应用的各个服务。每个服务都是一个容器的实例。下面是一个完整的服务配置示例：

1
services:
2
  web:
3
    image: nginx:alpine
4
    container_name: my-nginx
5
    ports:
6
      - "80:80"
7
      - "443:443"
8
    volumes:
9
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
10
      - html:/usr/share/nginx/html
11
    environment:
12
      - TZ=Asia/Shanghai
13
    networks:
14
      - frontend
15
    depends_on:
16
      - db
17
    restart: unless-stopped
18
    healthcheck:
19
      test: ["CMD", "curl", "-f", "http://localhost"]
20
      interval: 30s
21
      timeout: 10s
22
      retries: 3

下面详细解释每个常用指令：

2.2.1 image#

指定服务使用的镜像。可以是镜像名、镜像ID，或者带有标签的镜像名。

1
services:
2
  # 使用官方nginx镜像，标签为alpine
3
  web:
4
    image: nginx:alpine
5

6
  # 使用完整的镜像仓库地址
7
  app:
8
    image: registry.example.com/my-app:v1.0.0
9

10
  # 使用镜像ID
11
  db:
12
    image: sha256:abcdef123456

2.2.2 build#

如果服务需要从Dockerfile构建镜像，可以使用build指令。它可以是一个包含构建上下文的字符串，或者一个详细的配置对象。

1
services:
2
  app:
3
    # 简单形式：指定构建上下文为当前目录
4
    build: .
5

6
  backend:
7
    # 详细形式
8
    build:
9
      context: ./app           # 构建上下文路径
10
      dockerfile: Dockerfile.prod  # Dockerfile文件名
11
      args:                    # 构建参数
12
        - NODE_ENV=production
13
        - API_VERSION=v2
14
      target: production       # 多阶段构建的目标阶段
15
      cache_from:              # 缓存来源
16
        - myapp:latest
17
      labels:                  # 镜像标签
18
        - "com.example.version=1.0"

构建缓存优化
使用cache_from可以显著加速构建过程，特别是在CI/CD环境中。配合多阶段构建可以进一步减小镜像体积。

2.2.3 ports#

映射容器端口到主机端口。格式为主机端口:容器端口，或者只指定容器端口（主机端口随机分配）。

1
services:
2
  web:
3
    image: nginx
4
    ports:
5
      - "80:80"               # 映射主机80端口到容器80端口
6
      - "443:443"             # 映射主机443端口到容器443端口
7
      - "8080:8080/tcp"       # 指定协议为TCP
8
      - "53:53/udp"           # 指定协议为UDP
9
      - "3000"                # 随机分配主机端口到容器3000端口
10
      - "127.0.0.1:5000:5000" # 仅绑定到本地回环地址

端口格式说明
端口映射必须用引号括起来，否则YAML会将53:53解析为时间格式，导致错误。如需限制访问来源，可以指定绑定的IP地址。

2.2.4 volumes#

挂载数据卷到容器。可以是命名卷、主机路径挂载，或者临时文件系统。

1
services:
2
  db:
3
    image: mysql:8.0
4
    volumes:
5
      # 命名卷挂载
6
      - mysql_data:/var/lib/mysql
7

8
      # 主机路径挂载（相对路径）
9
      - ./conf:/etc/mysql/conf.d
10

11
      # 主机路径挂载（绝对路径）
12
      - /data/mysql/logs:/var/log/mysql
13

14
      # 只读挂载
15
      - ./my.cnf:/etc/mysql/my.cnf:ro
16

17
      # 临时文件系统（数据不持久化）
18
      - /tmp
19

20
      # 高级配置
21
      - type: volume
22
        source: mysql_data
23
        target: /var/lib/mysql
24
        volume:
25
          nocopy: true
26

27
volumes:
28
  mysql_data:  # 声明命名卷
29
    driver: local

2.2.5 environment#

设置容器的环境变量。可以是列表形式或字典形式。

1
services:
2
  db:
3
    image: mysql:8.0
4

5
    # 列表形式
6
    environment:
7
      - MYSQL_ROOT_PASSWORD=root123
8
      - MYSQL_DATABASE=myapp
9
      - MYSQL_USER=user
10
      - MYSQL_PASSWORD=pass123
11

12
  app:
13
    image: myapp
14
    # 字典形式（推荐，更清晰）
15
    environment:
16
      NODE_ENV: production
17
      API_KEY: ${API_KEY}  # 从.env文件读取
18
      DB_HOST: db
19
      DB_PORT: "3306"

2.2.6 depends_on#

指定服务之间的依赖关系，决定服务的启动顺序。

1
services:
2
  web:
3
    image: nginx
4
    depends_on:
5
      - app
6
      - db
7

8
  app:
9
    build: ./app
10
    depends_on:
11
      db:
12
        condition: service_healthy  # 等待db健康检查通过
13

14
  db:
15
    image: mysql:8.0
16
    healthcheck:
17
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
18
      interval: 10s
19
      timeout: 5s
20
      retries: 5

启动顺序与就绪状态
depends_on只保证容器的启动顺序，不保证容器内的应用完全就绪。例如，MySQL容器启动后，数据库服务可能还需要几秒钟才能接受连接。推荐配合健康检查使用，或在应用中实现连接重试逻辑。

2.2.7 restart#

指定容器的重启策略。

1
services:
2
  web:
3
    image: nginx
4
    restart: unless-stopped  # 除非手动停止，否则总是重启（推荐生产环境）
5

6
  app:
7
    image: myapp
8
    restart: always         # 总是重启
9

10
  worker:
11
    image: worker
12
    restart: on-failure     # 仅在失败时重启
13

14
  test:
15
    image: test
16
    restart: "no"           # 不重启（默认，注意要加引号）

2.2.8 container_name#

指定容器的名称。默认情况下，Compose会使用项目名_服务名_序号的格式命名容器。

1
services:
2
  web:
3
    image: nginx
4
    container_name: my-nginx

扩展限制
如果指定了container_name，那么该服务将无法进行扩展（scale），因为容器名称必须是唯一的。如果需要扩展服务，请勿设置container_name。

2.2.9 networks#

指定服务连接的网络。

1
services:
2
  web:
3
    image: nginx
4
    networks:
5
      frontend:
6
        ipv4_address: 172.20.0.2  # 指定静态IP
7
      backend:
8
        aliases:                   # 网络别名
9
          - web-server
10

11
  app:
12
    build: ./app
13
    networks:
14
      - backend
15

16
  db:
17
    image: mysql:8.0
18
    networks:
19
      - backend
20

21
networks:
22
  frontend:
23
    driver: bridge
24
  backend:
25
    driver: bridge
26
    internal: true  # 内部网络，隔离外部访问

2.3 networks 配置#

networks顶级元素用于定义自定义网络。默认情况下，Compose会为每个项目创建一个桥接网络，所有服务都会连接到这个网络。

1
networks:
2
  # 默认桥接网络
3
  frontend:
4

5
  # 指定驱动为bridge
6
  backend:
7
    driver: bridge
8

9
  # 自定义子网和网关
10
  custom:
11
    driver: bridge
12
    ipam:
13
      driver: default
14
      config:
15
        - subnet: 172.20.0.0/16
16
          gateway: 172.20.0.1
17
          ip_range: 172.20.5.0/24
18

19
  # 使用已存在的外部网络
20
  external_network:
21
    external: true
22
    name: my-pre-existing-network
23

24
  # overlay网络（用于Swarm模式）
25
  overlay:
26
    driver: overlay
27
    attachable: true

2.4 volumes 配置#

volumes顶级元素用于定义命名卷。命名卷可以在多个服务之间共享，并且在容器删除后仍然保留数据。

1
volumes:
2
  # 默认驱动的命名卷
3
  mysql_data:
4

5
  # 指定驱动为local
6
  postgres_data:
7
    driver: local
8
    driver_opts:
9
      type: none
10
      o: bind
11
      device: /data/postgres
12

13
  # 使用已存在的外部卷
14
  external_volume:
15
    external: true
16
    name: my-external-volume
17

18
  # NFS挂载
19
  nfs_data:
20
    driver: local
21
    driver_opts:
22
      type: nfs
23
      o: addr=10.0.0.1,rw
24
      device: ":/exported/path"

三、Docker Compose 常用命令#

Docker Compose提供了丰富的命令来管理应用的整个生命周期。下面是最常用的命令：

3.1 启动应用#

1
# 启动所有服务（前台运行，可以看到实时日志）
2
docker compose up
3

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

7
# 构建镜像并启动服务
8
docker compose up --build
9

10
# 强制重新创建容器
11
docker compose up --force-recreate
12

13
# 只启动指定服务及其依赖
14
docker compose up web
15

16
# 启动时移除孤立容器
17
docker compose up --remove-orphans

3.2 查看状态#

1
# 查看所有服务的状态
2
docker compose ps
3

4
# 查看所有服务（包括已停止的）
5
docker compose ps -a
6

7
# 查看服务的日志
8
docker compose logs
9

10
# 实时查看服务的日志
11
docker compose logs -f
12

13
# 查看指定服务的日志
14
docker compose logs web
15

16
# 查看最后100行日志
17
docker compose logs --tail=100
18

19
# 显示时间戳
20
docker compose logs -t

3.3 停止和删除#

1
# 停止所有服务（不删除容器和数据卷）
2
docker compose stop
3

4
# 停止指定服务
5
docker compose stop web
6

7
# 启动已停止的服务
8
docker compose start
9

10
# 重启所有服务
11
docker compose restart
12

13
# 删除所有容器和网络
14
docker compose down
15

16
# 删除所有容器、网络和数据卷
17
docker compose down -v
18

19
# 删除所有容器、网络和镜像
20
docker compose down --rmi all
21

22
# 暂停服务
23
docker compose pause
24

25
# 恢复暂停的服务
26
docker compose unpause

3.4 执行命令#

1
# 在运行中的容器中执行命令
2
docker compose exec web bash
3

4
# 以root用户执行
5
docker compose exec -u root web bash
6

7
# 在新容器中执行命令（不会影响原容器）
8
docker compose run web bash
9

10
# 执行一次性命令
11
docker compose run --rm web python manage.py migrate

3.5 扩展服务#

1
# 将web服务扩展到3个实例
2
docker compose up -d --scale web=3
3

4
# 同时扩展多个服务
5
docker compose up -d --scale web=3 --scale worker=5
6

7
# 查看扩展后的服务
8
docker compose ps

3.6 其他常用命令#

1
# 验证docker-compose.yml语法
2
docker compose config
3

4
# 显示合并后的配置
5
docker compose config --services
6

7
# 查看镜像
8
docker compose images
9

10
# 查看服务端口
11
docker compose port web 80
12

13
# 查看服务进程
14
docker compose top
15

16
# 查看服务事件
17
docker compose events

四、实战案例1：LNMP环境部署#

LNMP（Linux + Nginx + MySQL + PHP）是最常用的Web服务器环境之一。下面我们使用Docker Compose来部署一个完整的LNMP环境。

4.1 项目结构#

1
lnmp/
2
├── docker-compose.yml
3
├── nginx/
4
│   ├── nginx.conf
5
│   └── logs/
6
├── php/
7
│   ├── Dockerfile
8
│   └── php.ini
9
├── mysql/
10
│   ├── conf/
11
│   │   └── my.cnf
12
│   └── logs/
13
└── www/
14
    └── index.php

4.2 docker-compose.yml 配置#

1
version: '3.8'
2

3
services:
4
  nginx:
5
    image: nginx:alpine
6
    container_name: lnmp-nginx
7
    ports:
8
      - "80:80"
9
      - "443:443"
10
    volumes:
11
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
12
      - ./www:/var/www/html
13
      - ./nginx/logs:/var/log/nginx
14
    depends_on:
15
      - php
16
    networks:
17
      - lnmp-network
18
    restart: unless-stopped
19
    healthcheck:
20
      test: ["CMD", "wget", "--quiet", "--tries=1", "--spider", "http://localhost"]
21
      interval: 30s
22
      timeout: 10s
23
      retries: 3
24

25
  php:
26
    build: ./php
27
    container_name: lnmp-php
28
    volumes:
29
      - ./www:/var/www/html
30
      - ./php/php.ini:/usr/local/etc/php/php.ini:ro
31
    networks:
32
      - lnmp-network
33
    restart: unless-stopped
34
    environment:
35
      - TZ=Asia/Shanghai
36

37
  mysql:
38
    image: mysql:8.0
39
    container_name: lnmp-mysql
40
    ports:
41
      - "3306:3306"
42
    volumes:
43
      - mysql_data:/var/lib/mysql
44
      - ./mysql/conf:/etc/mysql/conf.d:ro
45
      - ./mysql/logs:/var/log/mysql
46
    environment:
47
      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD:-root123456}
48
      MYSQL_DATABASE: ${MYSQL_DATABASE:-lnmp}
49
      MYSQL_USER: ${MYSQL_USER:-lnmp}
50
      MYSQL_PASSWORD: ${MYSQL_PASSWORD:-lnmp123456}
51
      TZ: Asia/Shanghai
52
    networks:
53
      - lnmp-network
54
    restart: unless-stopped
55
    healthcheck:
56
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost", "-u", "root", "-p$${MYSQL_ROOT_PASSWORD}"]
57
      interval: 10s
58
      timeout: 5s
59
      retries: 5
60
    command: --default-authentication-plugin=mysql_native_password
61

62
networks:
63
  lnmp-network:
64
    driver: bridge
65

66
volumes:
67
  mysql_data:
68
    driver: local

4.3 PHP Dockerfile#

1
FROM php:8.2-fpm-alpine
2

3
# 安装系统依赖
4
RUN apk add --no-cache \
5
    libpng-dev \
6
    libjpeg-turbo-dev \
7
    freetype-dev \
8
    zip \
9
    libzip-dev
10

11
# 安装PHP扩展
12
RUN docker-php-ext-configure gd --with-freetype --with-jpeg \
13
    && docker-php-ext-install -j$(nproc) \
14
        pdo_mysql \
15
        mysqli \
16
        gd \
17
        zip \
18
        opcache
19

20
# 安装Redis扩展
21
RUN pecl install redis \
22
    && docker-php-ext-enable redis
23

24
# 设置时区
25
ENV TZ=Asia/Shanghai
26
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
27

28
# 设置工作目录
29
WORKDIR /var/www/html
30

31
# 优化PHP-FPM配置
32
RUN echo "pm.max_children = 50" >> /usr/local/etc/php-fpm.d/www.conf \
33
    && echo "pm.start_servers = 10" >> /usr/local/etc/php-fpm.d/www.conf \
34
    && echo "pm.min_spare_servers = 5" >> /usr/local/etc/php-fpm.d/www.conf \
35
    && echo "pm.max_spare_servers = 20" >> /usr/local/etc/php-fpm.d/www.conf

4.4 Nginx 配置#

1
user nginx;
2
worker_processes auto;
3
error_log /var/log/nginx/error.log warn;
4
pid /var/run/nginx.pid;
5

6
events {
7
    worker_connections 2048;
8
    use epoll;
9
    multi_accept on;
10
}
11

12
http {
13
    include /etc/nginx/mime.types;
14
    default_type application/octet-stream;
15

16
    log_format main '$remote_addr - $remote_user [$time_local] "$request" '
17
                    '$status $body_bytes_sent "$http_referer" '
18
                    '"$http_user_agent" "$http_x_forwarded_for"';
19

20
    access_log /var/log/nginx/access.log main;
21

22
    sendfile on;
23
    tcp_nopush on;
24
    tcp_nodelay on;
25
    keepalive_timeout 65;
26
    types_hash_max_size 2048;
27
    client_max_body_size 20M;
28

29
    # Gzip压缩
30
    gzip on;
31
    gzip_vary on;
32
    gzip_min_length 1024;
33
    gzip_types text/plain text/css text/xml text/javascript
34
               application/x-javascript application/xml+rss application/json;
35

36
    server {
37
        listen 80;
38
        server_name localhost;
39
        root /var/www/html;
40
        index index.php index.html index.htm;
41

42
        location / {
43
            try_files $uri $uri/ /index.php?$query_string;
44
        }
45

46
        location ~ \.php$ {
47
            fastcgi_pass php:9000;
48
            fastcgi_index index.php;
49
            fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
50
            include fastcgi_params;
51

52
            # FastCGI优化
53
            fastcgi_buffer_size 128k;
54
            fastcgi_buffers 4 256k;
55
            fastcgi_busy_buffers_size 256k;
56
        }
57

58
        location ~ /\.ht {
59
            deny all;
60
        }
61

62
        # 静态文件缓存
63
        location ~* \.(jpg|jpeg|png|gif|ico|css|js)$ {
64
            expires 7d;
65
            add_header Cache-Control "public, immutable";
66
        }
67
    }
68
}

4.5 测试页面#

1
<?php
2
// 显示PHP信息
3
phpinfo();
4

5
// 测试MySQL连接
6
try {
7
    $pdo = new PDO(
8
        'mysql:host=mysql;dbname=lnmp',
9
        'lnmp',
10
        'lnmp123456'
11
    );
12
    echo "<h2>MySQL连接成功！</h2>";
13
    echo "<p>MySQL版本：" . $pdo->getAttribute(PDO::ATTR_SERVER_VERSION) . "</p>";
14
} catch (PDOException $e) {
15
    echo "<h2>MySQL连接失败！</h2>";
16
    echo "<p>错误信息：" . $e->getMessage() . "</p>";
17
}
18
?>

4.6 启动服务#

1
# 进入项目目录
2
cd lnmp
3

4
# 创建必要的目录
5
mkdir -p nginx/logs mysql/logs
6

7
# 启动服务
8
docker compose up -d
9

10
# 查看服务状态
11
docker compose ps
12

13
# 查看日志
14
docker compose logs -f

访问 http://localhost ，你应该能看到PHP信息页面和MySQL连接成功的提示。

生产环境建议
生产环境部署时，建议将敏感信息（如数据库密码）存放在.env文件中，并在.gitignore中排除该文件。同时启用HTTPS，配置防火墙规则，限制MySQL端口仅允许内部访问。

五、实战案例2：WordPress + MySQL 部署#

WordPress是最流行的内容管理系统之一。下面我们使用Docker Compose来部署一个WordPress网站。

5.1 项目结构#

1
wordpress/
2
├── docker-compose.yml
3
├── .env
4
└── .gitignore

5.2 docker-compose.yml 配置#

1
version: '3.8'
2

3
services:
4
  wordpress:
5
    image: wordpress:latest
6
    container_name: wordpress
7
    ports:
8
      - "80:80"
9
    volumes:
10
      - wordpress_data:/var/www/html
11
      - ./uploads.ini:/usr/local/etc/php/conf.d/uploads.ini:ro
12
    environment:
13
      WORDPRESS_DB_HOST: db:3306
14
      WORDPRESS_DB_NAME: ${MYSQL_DATABASE}
15
      WORDPRESS_DB_USER: ${MYSQL_USER}
16
      WORDPRESS_DB_PASSWORD: ${MYSQL_PASSWORD}
17
      WORDPRESS_TABLE_PREFIX: wp_
18
      WORDPRESS_DEBUG: ${WORDPRESS_DEBUG:-false}
19
    depends_on:
20
      db:
21
        condition: service_healthy
22
    networks:
23
      - wordpress-network
24
    restart: unless-stopped
25
    healthcheck:
26
      test: ["CMD", "curl", "-f", "http://localhost"]
27
      interval: 30s
28
      timeout: 10s
29
      retries: 3
30

31
  db:
32
    image: mysql:8.0
33
    container_name: wordpress-db
34
    volumes:
35
      - db_data:/var/lib/mysql
36
      - ./mysql-init:/docker-entrypoint-initdb.d:ro
37
    environment:
38
      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD}
39
      MYSQL_DATABASE: ${MYSQL_DATABASE}
40
      MYSQL_USER: ${MYSQL_USER}
41
      MYSQL_PASSWORD: ${MYSQL_PASSWORD}
42
      TZ: Asia/Shanghai
43
    networks:
44
      - wordpress-network
45
    restart: unless-stopped
46
    healthcheck:
47
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost", "-u", "root", "-p$${MYSQL_ROOT_PASSWORD}"]
48
      interval: 10s
49
      timeout: 5s
50
      retries: 5
51
      start_period: 30s
52
    command:
53
      - --default-authentication-plugin=mysql_native_password
54
      - --character-set-server=utf8mb4
55
      - --collation-server=utf8mb4_unicode_ci
56

57
  # 可选：添加Redis缓存
58
  redis:
59
    image: redis:alpine
60
    container_name: wordpress-redis
61
    networks:
62
      - wordpress-network
63
    restart: unless-stopped
64
    healthcheck:
65
      test: ["CMD", "redis-cli", "ping"]
66
      interval: 10s
67
      timeout: 3s
68
      retries: 3
69

70
networks:
71
  wordpress-network:
72
    driver: bridge
73

74
volumes:
75
  wordpress_data:
76
    driver: local
77
  db_data:
78
    driver: local

5.3 环境变量文件#

1
# MySQL配置
2
MYSQL_ROOT_PASSWORD=StrongRootPassword123!
3
MYSQL_DATABASE=wordpress
4
MYSQL_USER=wpuser
5
MYSQL_PASSWORD=WpUserPassword123!
6

7
# WordPress配置
8
WORDPRESS_DEBUG=false

5.4 PHP上传限制配置#

1
file_uploads = On
2
memory_limit = 256M
3
upload_max_filesize = 64M
4
post_max_size = 64M
5
max_execution_time = 300

5.5 .gitignore 配置#

1
.env
2
*.log
3
.DS_Store

5.6 启动服务#

1
# 进入项目目录
2
cd wordpress
3

4
# 启动服务
5
docker compose up -d
6

7
# 查看启动日志
8
docker compose logs -f
9

10
# 等待所有服务健康
11
docker compose ps

访问 http://localhost ，按照提示完成WordPress的安装。

数据备份建议
定期备份WordPress数据和MySQL数据库。可以使用以下命令：
Terminal window
1
# 备份WordPress文件
2
docker compose exec wordpress tar czf /tmp/wp-backup.tar.gz /var/www/html
3

4
# 备份MySQL数据库
5
docker compose exec db mysqldump -uroot -p$MYSQL_ROOT_PASSWORD wordpress > backup.sql

六、实战案例3：微服务架构示例#

下面我们使用Docker Compose来部署一个简单的微服务架构，包含前端、后端API、数据库和缓存服务。

6.1 项目结构#

1
microservices/
2
├── docker-compose.yml
3
├── docker-compose.prod.yml
4
├── .env
5
├── frontend/
6
│   ├── Dockerfile
7
│   └── ...
8
├── backend/
9
│   ├── Dockerfile
10
│   └── ...
11
└── nginx/
12
    └── nginx.conf

6.2 docker-compose.yml 配置#

1
version: '3.8'
2

3
services:
4
  # Nginx反向代理
5
  nginx:
6
    image: nginx:alpine
7
    container_name: ms-nginx
8
    ports:
9
      - "80:80"
10
      - "443:443"
11
    volumes:
12
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
13
      - ./nginx/ssl:/etc/nginx/ssl:ro
14
    depends_on:
15
      - frontend
16
      - backend
17
    networks:
18
      - frontend-network
19
    restart: unless-stopped
20

21
  # 前端服务
22
  frontend:
23
    build: ./frontend
24
    container_name: ms-frontend
25
    environment:
26
      - API_URL=http://nginx/api
27
      - NODE_ENV=production
28
    networks:
29
      - frontend-network
30
    restart: unless-stopped
31
    healthcheck:
32
      test: ["CMD", "curl", "-f", "http://localhost:3000"]
33
      interval: 30s
34
      timeout: 10s
35
      retries: 3
36

37
  # 后端API服务
38
  backend:
39
    build:
40
      context: ./backend
41
      args:
42
        NODE_ENV: production
43
    container_name: ms-backend
44
    environment:
45
      NODE_ENV: production
46
      DB_HOST: db
47
      DB_PORT: 5432
48
      DB_NAME: ${POSTGRES_DB}
49
      DB_USER: ${POSTGRES_USER}
50
      DB_PASSWORD: ${POSTGRES_PASSWORD}
51
      REDIS_HOST: redis
52
      REDIS_PORT: 6379
53
      JWT_SECRET: ${JWT_SECRET}
54
    depends_on:
55
      db:
56
        condition: service_healthy
57
      redis:
58
        condition: service_healthy
59
    networks:
60
      - backend-network
61
    restart: unless-stopped
62
    healthcheck:
63
      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
64
      interval: 30s
65
      timeout: 10s
66
      retries: 3
67
    deploy:
68
      resources:
69
        limits:
70
          cpus: '1'
71
          memory: 1G
72
        reservations:
73
          cpus: '0.5'
74
          memory: 512M
75

76
  # PostgreSQL数据库
77
  db:
78
    image: postgres:15-alpine
79
    container_name: ms-db
80
    volumes:
81
      - postgres_data:/var/lib/postgresql/data
82
      - ./db/init:/docker-entrypoint-initdb.d:ro
83
    environment:
84
      POSTGRES_DB: ${POSTGRES_DB}
85
      POSTGRES_USER: ${POSTGRES_USER}
86
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
87
      PGDATA: /var/lib/postgresql/data/pgdata
88
      TZ: Asia/Shanghai
89
    networks:
90
      - backend-network
91
    restart: unless-stopped
92
    healthcheck:
93
      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"]
94
      interval: 10s
95
      timeout: 5s
96
      retries: 5
97
      start_period: 10s
98
    shm_size: 256mb
99

100
  # Redis缓存
101
  redis:
102
    image: redis:alpine
103
    container_name: ms-redis
104
    command: redis-server --appendonly yes --requirepass ${REDIS_PASSWORD}
105
    volumes:
106
      - redis_data:/data
107
    networks:
108
      - backend-network
109
    restart: unless-stopped
110
    healthcheck:
111
      test: ["CMD", "redis-cli", "--raw", "incr", "ping"]
112
      interval: 10s
113
      timeout: 3s
114
      retries: 5
115

116
networks:
117
  frontend-network:
118
    driver: bridge
119
  backend-network:
120
    driver: bridge
121
    internal: true  # 内部网络，增强安全性
122

123
volumes:
124
  postgres_data:
125
    driver: local
126
  redis_data:
127
    driver: local

6.3 生产环境覆盖配置#

1
version: '3.8'
2

3
services:
4
  nginx:
5
    volumes:
6
      - ./nginx/nginx.prod.conf:/etc/nginx/nginx.conf:ro
7
    logging:
8
      driver: "json-file"
9
      options:
10
        max-size: "10m"
11
        max-file: "3"
12

13
  frontend:
14
    build:
15
      context: ./frontend
16
      dockerfile: Dockerfile.prod
17
    logging:
18
      driver: "json-file"
19
      options:
20
        max-size: "10m"
21
        max-file: "3"
22

23
  backend:
24
    build:
25
      context: ./backend
26
      dockerfile: Dockerfile.prod
27
    deploy:
28
      replicas: 3
29
      resources:
30
        limits:
31
          cpus: '2'
32
          memory: 2G
33
    logging:
34
      driver: "json-file"
35
      options:
36
        max-size: "10m"
37
        max-file: "3"
38

39
  db:
40
    volumes:
41
      - /data/postgres:/var/lib/postgresql/data
42
    deploy:
43
      resources:
44
        limits:
45
          cpus: '2'
46
          memory: 4G
47
    logging:
48
      driver: "json-file"
49
      options:
50
        max-size: "10m"
51
        max-file: "5"
52

53
  redis:
54
    deploy:
55
      resources:
56
        limits:
57
          cpus: '1'
58
          memory: 1G
59
    logging:
60
      driver: "json-file"
61
      options:
62
        max-size: "5m"
63
        max-file: "3"

6.4 环境变量文件#

1
# PostgreSQL配置
2
POSTGRES_DB=microservices
3
POSTGRES_USER=api
4
POSTGRES_PASSWORD=SecurePostgresPassword123!
5

6
# Redis配置
7
REDIS_PASSWORD=SecureRedisPassword123!
8

9
# JWT密钥
10
JWT_SECRET=YourSuperSecretJWTKey123456!

6.5 启动服务#

1
# 开发环境
2
cd microservices
3
docker compose up -d
4

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

8
# 查看服务状态
9
docker compose ps
10

11
# 查看日志
12
docker compose logs -f backend
13

14
# 扩展后端服务
15
docker compose up -d --scale backend=5

七、Docker Compose 高级技巧#

7.1 环境变量使用#

Docker Compose支持多种方式使用环境变量：

7.1.1 .env 文件#

Compose会自动加载项目目录下的.env文件中的环境变量。

1
# 镜像版本
2
TAG=v1.0.0
3
NODE_VERSION=18-alpine
4

5
# 数据库配置
6
DB_HOST=db
7
DB_PORT=5432
8
DB_PASSWORD=SecurePassword123!
9

10
# 应用配置
11
APP_PORT=3000
12
LOG_LEVEL=info

1
services:
2
  app:
3
    image: myapp:${TAG:-latest}
4
    build:
5
      context: .
6
      args:
7
        NODE_VERSION: ${NODE_VERSION}
8
    ports:
9
      - "${APP_PORT}:3000"
10
    environment:
11
      DB_HOST: ${DB_HOST}
12
      DB_PORT: ${DB_PORT}
13
      DB_PASSWORD: ${DB_PASSWORD}
14
      LOG_LEVEL: ${LOG_LEVEL:-warn}

默认值语法
使用${VAR:-default}语法可以设置默认值，如果环境变量未定义则使用默认值。这在处理可选配置时非常有用。

7.1.2 env_file 指令#

1
services:
2
  app:
3
    image: myapp
4
    env_file:
5
      - .env           # 基础配置
6
      - .env.local     # 本地覆盖
7
      - .env.secret    # 敏感信息（不提交到Git）

7.2 配置覆盖#

Docker Compose支持多个配置文件，允许你覆盖基础配置。这是实现多环境部署的最佳实践。

1
version: '3.8'
2

3
services:
4
  app:
5
    build:
6
      target: development
7
    volumes:
8
      - .:/app
9
      - /app/node_modules
10
    environment:
11
      NODE_ENV: development
12
      DEBUG: "app:*"
13
    command: npm run dev

1
# 开发环境（自动加载docker-compose.override.yml）
2
docker compose up -d
3

4
# 测试环境
5
docker compose -f docker-compose.yml -f docker-compose.test.yml up -d
6

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

10
# 查看合并后的配置
11
docker compose -f docker-compose.yml -f docker-compose.prod.yml config

7.3 健康检查详解#

健康检查可以确保容器内的应用正常运行，Compose会根据健康检查结果决定服务是否就绪。

1
services:
2
  # HTTP服务健康检查
3
  web:
4
    image: nginx
5
    healthcheck:
6
      test: ["CMD", "curl", "-f", "http://localhost/health"]
7
      interval: 30s        # 检查间隔
8
      timeout: 10s         # 超时时间
9
      retries: 3           # 失败重试次数
10
      start_period: 40s    # 启动等待时间
11

12
  # 数据库健康检查
13
  db:
14
    image: postgres:15
15
    healthcheck:
16
      test: ["CMD-SHELL", "pg_isready -U postgres"]
17
      interval: 10s
18
      timeout: 5s
19
      retries: 5
20

21
  # Redis健康检查
22
  redis:
23
    image: redis:alpine
24
    healthcheck:
25
      test: ["CMD", "redis-cli", "ping"]
26
      interval: 5s
27
      timeout: 3s
28
      retries: 3
29

30
  # 自定义脚本健康检查
31
  app:
32
    build: .
33
    healthcheck:
34
      test: ["CMD", "/app/healthcheck.sh"]
35
      interval: 30s
36
      timeout: 10s
37
      retries: 3

7.4 服务扩展策略#

1
# 扩展web服务到5个实例
2
docker compose up -d --scale web=5
3

4
# 同时扩展多个服务
5
docker compose up -d --scale web=5 --scale worker=10
6

7
# 动态调整规模
8
docker compose up -d --scale web=3  # 缩减到3个
9

10
# 查看扩展后的服务
11
docker compose ps

1
services:
2
  web:
3
    build: ./web
4
    # 不要设置container_name
5
    ports:
6
      - "8080-8089:80"  # 使用端口范围
7
    networks:
8
      - webnet
9
    deploy:
10
      replicas: 3
11
      resources:
12
        limits:
13
          cpus: '0.5'
14
          memory: 512M

7.5 配置文件验证和调试#

1
# 验证docker-compose.yml语法
2
docker compose config
3

4
# 查看服务列表
5
docker compose config --services
6

7
# 查看数据卷列表
8
docker compose config --volumes
9

10
# 显示合并后的完整配置
11
docker compose config --resolve-image-digests
12

13
# 静默模式（只在有错误时输出）
14
docker compose config --quiet
15

16
# 检查特定服务配置
17
docker compose config --services web

7.6 日志管理#

1
services:
2
  app:
3
    image: myapp
4
    logging:
5
      driver: "json-file"
6
      options:
7
        max-size: "10m"      # 单个日志文件最大大小
8
        max-file: "3"        # 保留的日志文件数量
9
        compress: "true"     # 压缩旧日志
10

11
  db:
12
    image: postgres
13
    logging:
14
      driver: "syslog"
15
      options:
16
        syslog-address: "tcp://192.168.0.42:123"
17
        tag: "{{.Name}}"

1
# 查看所有服务日志
2
docker compose logs
3

4
# 实时跟踪日志
5
docker compose logs -f
6

7
# 查看最后100行
8
docker compose logs --tail=100
9

10
# 显示时间戳
11
docker compose logs -t
12

13
# 只看指定服务
14
docker compose logs web db
15

16
# 从某个时间点开始
17
docker compose logs --since 2024-01-01T00:00:00
18

19
# 到某个时间点结束
20
docker compose logs --until 2024-01-02T00:00:00

八、生产环境部署最佳实践#

8.1 服务编排策略#

在生产环境中部署Docker Compose应用时，需要考虑服务的启动顺序、依赖关系和故障恢复。

1
services:
2
  # 负载均衡器
3
  lb:
4
    image: nginx:alpine
5
    depends_on:
6
      app:
7
        condition: service_healthy
8
    restart: always
9
    deploy:
10
      resources:
11
        limits:
12
          cpus: '0.5'
13
          memory: 256M
14

15
  # 应用服务
16
  app:
17
    build: ./app
18
    depends_on:
19
      db:
20
        condition: service_healthy
21
      redis:
22
        condition: service_started
23
    restart: unless-stopped
24
    healthcheck:
25
      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
26
      interval: 30s
27
      timeout: 10s
28
      retries: 3
29
      start_period: 60s
30

31
  # 数据库（带初始化等待）
32
  db:
33
    image: postgres:15
34
    restart: always
35
    healthcheck:
36
      test: ["CMD-SHELL", "pg_isready -U postgres"]
37
      interval: 10s
38
      timeout: 5s
39
      retries: 5
40
      start_period: 30s

启动顺序最佳实践

优先启动无依赖的基础服务（数据库、缓存）

使用健康检查确保服务真正可用

设置合理的start_period给服务充足的初始化时间

应用层实现连接重试机制作为额外保障

8.2 安全性配置#

1
services:
2
  app:
3
    image: myapp
4
    # 限制容器权限
5
    cap_drop:
6
      - ALL
7
    cap_add:
8
      - NET_BIND_SERVICE
9

10
    # 以非root用户运行
11
    user: "1000:1000"
12

13
    # 只读根文件系统
14
    read_only: true
15
    tmpfs:
16
      - /tmp
17
      - /var/run
18

19
    # 安全选项
20
    security_opt:
21
      - no-new-privileges:true
22

23
    # 限制系统调用
24
    sysctls:
25
      net.ipv4.ip_unprivileged_port_start: 0
26

27
    # 资源限制
28
    deploy:
29
      resources:
30
        limits:
31
          cpus: '2'
32
          memory: 2G
33
          pids: 100
34
        reservations:
35
          cpus: '1'
36
          memory: 1G
37

38
  # 数据库安全配置
39
  db:
40
    image: postgres:15
41
    environment:
42
      POSTGRES_PASSWORD_FILE: /run/secrets/db_password
43
    secrets:
44
      - db_password
45
    networks:
46
      backend:
47
        aliases:
48
          - database
49

50
secrets:
51
  db_password:
52
    file: ./secrets/db_password.txt
53

54
networks:
55
  backend:
56
    internal: true  # 内部网络，不对外暴露

8.3 监控和告警#

1
services:
2
  # Prometheus监控
3
  prometheus:
4
    image: prom/prometheus
5
    container_name: prometheus
6
    volumes:
7
      - ./prometheus.yml:/etc/prometheus/prometheus.yml:ro
8
      - prometheus_data:/prometheus
9
    command:
10
      - '--config.file=/etc/prometheus/prometheus.yml'
11
      - '--storage.tsdb.path=/prometheus'
12
      - '--storage.tsdb.retention.time=30d'
13
    ports:
14
      - "9090:9090"
15
    networks:
16
      - monitoring
17
    restart: unless-stopped
18

19
  # Grafana可视化
20
  grafana:
21
    image: grafana/grafana
22
    container_name: grafana
23
    volumes:
24
      - grafana_data:/var/lib/grafana
25
      - ./grafana/provisioning:/etc/grafana/provisioning:ro
26
    environment:
27
      GF_SECURITY_ADMIN_PASSWORD: ${GRAFANA_PASSWORD}
28
      GF_INSTALL_PLUGINS: grafana-clock-panel
29
    ports:
30
      - "3000:3000"
31
    networks:
32
      - monitoring
33
    restart: unless-stopped
34
    depends_on:
35
      - prometheus
36

37
  # Node Exporter（主机监控）
38
  node-exporter:
39
    image: prom/node-exporter
40
    container_name: node-exporter
41
    command:
42
      - '--path.rootfs=/host'
43
    volumes:
44
      - '/:/host:ro,rslave'
45
    networks:
46
      - monitoring
47
    restart: unless-stopped
48

49
  # cAdvisor（容器监控）
50
  cadvisor:
51
    image: gcr.io/cadvisor/cadvisor
52
    container_name: cadvisor
53
    volumes:
54
      - /:/rootfs:ro
55
      - /var/run:/var/run:ro
56
      - /sys:/sys:ro
57
      - /var/lib/docker/:/var/lib/docker:ro
58
    ports:
59
      - "8080:8080"
60
    networks:
61
      - monitoring
62
    restart: unless-stopped
63

64
volumes:
65
  prometheus_data:
66
  grafana_data:
67

68
networks:
69
  monitoring:
70
    driver: bridge

8.4 备份和恢复策略#

1
#!/bin/bash
2
# backup.sh - Docker Compose数据备份脚本
3

4
BACKUP_DIR="/backups"
5
DATE=$(date +%Y%m%d_%H%M%S)
6
PROJECT_NAME="myapp"
7

8
# 创建备份目录
9
mkdir -p ${BACKUP_DIR}/${DATE}
10

11
# 备份数据卷
12
echo "备份数据卷..."
13
docker run --rm \
14
  -v ${PROJECT_NAME}_postgres_data:/data:ro \
15
  -v ${BACKUP_DIR}/${DATE}:/backup \
16
  alpine tar czf /backup/postgres_data.tar.gz -C /data .
17

18
docker run --rm \
19
  -v ${PROJECT_NAME}_redis_data:/data:ro \
20
  -v ${BACKUP_DIR}/${DATE}:/backup \
21
  alpine tar czf /backup/redis_data.tar.gz -C /data .
22

23
# 备份PostgreSQL数据库
24
echo "备份PostgreSQL数据库..."
25
docker compose exec -T db pg_dumpall -U postgres | gzip > ${BACKUP_DIR}/${DATE}/db_dump.sql.gz
26

27
# 备份配置文件
28
echo "备份配置文件..."
29
tar czf ${BACKUP_DIR}/${DATE}/configs.tar.gz \
30
  docker-compose.yml \
31
  docker-compose.prod.yml \
32
  .env \
33
  nginx/
34

35
# 清理旧备份（保留最近7天）
36
find ${BACKUP_DIR} -type d -mtime +7 -exec rm -rf {} +
37

38
echo "备份完成: ${BACKUP_DIR}/${DATE}"

1
#!/bin/bash
2
# restore.sh - Docker Compose数据恢复脚本
3

4
BACKUP_DATE=$1
5
BACKUP_DIR="/backups/${BACKUP_DATE}"
6

7
if [ ! -d "${BACKUP_DIR}" ]; then
8
  echo "备份目录不存在: ${BACKUP_DIR}"
9
  exit 1
10
fi
11

12
# 停止服务
13
echo "停止服务..."
14
docker compose down
15

16
# 恢复数据卷
17
echo "恢复数据卷..."
18
docker run --rm \
19
  -v myapp_postgres_data:/data \
20
  -v ${BACKUP_DIR}:/backup \
21
  alpine tar xzf /backup/postgres_data.tar.gz -C /data
22

23
docker run --rm \
24
  -v myapp_redis_data:/data \
25
  -v ${BACKUP_DIR}:/backup \
26
  alpine tar xzf /backup/redis_data.tar.gz -C /data
27

28
# 恢复配置文件
29
echo "恢复配置文件..."
30
tar xzf ${BACKUP_DIR}/configs.tar.gz
31

32
# 启动服务
33
echo "启动服务..."
34
docker compose up -d
35

36
echo "恢复完成"

8.5 性能优化#

1
services:
2
  # Web服务优化
3
  web:
4
    image: nginx:alpine
5
    volumes:
6
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
7
      - static:/usr/share/nginx/html:ro
8
    deploy:
9
      resources:
10
        limits:
11
          cpus: '2'
12
          memory: 1G
13
        reservations:
14
          cpus: '1'
15
          memory: 512M
16
    # 启用内核参数优化
17
    sysctls:
18
      net.core.somaxconn: 1024
19
      net.ipv4.tcp_syncookies: 1
20

21
  # 应用服务优化
22
  app:
23
    build:
24
      context: ./app
25
      cache_from:
26
        - myregistry/myapp:latest
27
    environment:
28
      NODE_ENV: production
29
      NODE_OPTIONS: "--max-old-space-size=2048"
30
    # 使用tmpfs提升临时文件性能
31
    tmpfs:
32
      - /app/tmp:size=100M
33
      - /app/cache:size=500M
34
    # CPU亲和性
35
    cpuset: "0-3"
36

37
  # 数据库性能优化
38
  db:
39
    image: postgres:15
40
    command:
41
      - postgres
42
      - -c max_connections=200
43
      - -c shared_buffers=256MB
44
      - -c effective_cache_size=1GB
45
      - -c maintenance_work_mem=64MB
46
      - -c checkpoint_completion_target=0.9
47
      - -c wal_buffers=16MB
48
      - -c default_statistics_target=100
49
    shm_size: 512mb
50
    volumes:
51
      - postgres_data:/var/lib/postgresql/data
52
      - type: tmpfs
53
        target: /dev/shm
54
        tmpfs:
55
          size: 512M
56

57
  # Redis优化
58
  redis:
59
    image: redis:alpine
60
    command: >
61
      redis-server
62
      --maxmemory 512mb
63
      --maxmemory-policy allkeys-lru
64
      --save ""
65
      --appendonly yes
66
      --appendfsync everysec
67
    volumes:
68
      - redis_data:/data

性能调优建议

资源限制：合理设置CPU和内存限制，避免单个容器占用过多资源

tmpfs使用：将临时文件和缓存放在内存文件系统中

网络优化：调整内核参数提升网络吞吐

数据库调优：根据实际负载调整数据库参数

镜像缓存：使用cache_from加速构建过程

九、故障排查和调试#

9.1 常见问题诊断#

1
# 查看容器状态
2
docker compose ps -a
3

4
# 查看容器资源使用
5
docker compose stats
6

7
# 查看详细的容器信息
8
docker compose inspect web
9

10
# 查看服务事件
11
docker compose events
12

13
# 查看网络信息
14
docker network ls
15
docker network inspect myapp_default
16

17
# 查看数据卷
18
docker volume ls
19
docker volume inspect myapp_postgres_data
20

21
# 进入容器调试
22
docker compose exec web sh
23
docker compose exec -u root web bash
24

25
# 查看容器进程
26
docker compose top
27

28
# 查看端口映射
29
docker compose port web 80

9.2 日志分析#

1
# 查看错误日志
2
docker compose logs | grep -i error
3

4
# 分析慢查询
5
docker compose logs db | grep "duration:"
6

7
# 统计错误频率
8
docker compose logs --since 1h | grep -c "ERROR"
9

10
# 导出日志到文件
11
docker compose logs --no-color > app.log
12

13
# 实时过滤特定服务日志
14
docker compose logs -f web | grep "status=500"
15

16
# 查看启动失败的容器日志
17
docker compose logs $(docker compose ps -q --filter "status=exited")

9.3 性能分析#

1
# 查看容器资源实时使用
2
docker compose stats
3

4
# 查看容器进程
5
docker compose top web
6

7
# 进入容器执行性能分析
8
docker compose exec web top
9
docker compose exec web htop
10
docker compose exec web iotop
11

12
# 查看网络连接
13
docker compose exec web netstat -tunlp
14

15
# 数据库性能分析
16
docker compose exec db psql -U postgres -c "SELECT * FROM pg_stat_activity;"
17

18
# 查看容器磁盘使用
19
docker compose exec web df -h

十、常见问题与解决方案#

10.1 端口冲突#

问题：启动时提示端口被占用

1
Error: Bind for 0.0.0.0:80 failed: port is already allocated

解决方案：

1
services:
2
  web:
3
    image: nginx
4
    ports:
5
      - "8080:80"  # 将主机8080端口映射到容器80端口

或者查找并停止占用端口的进程：

1
# Linux/Mac
2
sudo lsof -i :80
3
sudo kill -9 <PID>
4

5
# Windows
6
netstat -ano | findstr :80
7
taskkill /PID <PID> /F

10.2 服务启动顺序问题#

问题：应用启动时数据库还未就绪

解决方案：使用健康检查和重试机制

1
services:
2
  app:
3
    build: ./app
4
    depends_on:
5
      db:
6
        condition: service_healthy
7
    restart: on-failure
8
    environment:
9
      DB_RETRY_ATTEMPTS: 10
10
      DB_RETRY_INTERVAL: 5
11

12
  db:
13
    image: postgres:15
14
    healthcheck:
15
      test: ["CMD-SHELL", "pg_isready -U postgres"]
16
      interval: 10s
17
      timeout: 5s
18
      retries: 5
19
      start_period: 30s

应用层实现重试（Node.js示例）：

1
const { Client } = require('pg');
2

3
async function connectWithRetry(maxRetries = 10, interval = 5000) {
4
  for (let i = 0; i < maxRetries; i++) {
5
    try {
6
      const client = new Client({
7
        host: process.env.DB_HOST,
8
        database: process.env.DB_NAME,
9
        user: process.env.DB_USER,
10
        password: process.env.DB_PASSWORD,
11
      });
12
      await client.connect();
13
      console.log('Database connected successfully');
14
      return client;
15
    } catch (error) {
16
      console.log(`Connection attempt ${i + 1} failed: ${error.message}`);
17
      if (i < maxRetries - 1) {
18
        await new Promise(resolve => setTimeout(resolve, interval));
19
      }
20
    }
21
  }
22
  throw new Error('Failed to connect to database after retries');
23
}

10.3 数据持久化问题#

问题：容器删除后数据丢失

解决方案：正确使用命名卷

1
services:
2
  db:
3
    image: mysql:8.0
4
    volumes:
5
      # 正确：使用命名卷
6
      - mysql_data:/var/lib/mysql
7
      # 错误：直接使用容器路径
8
      # - /var/lib/mysql
9

10
volumes:
11
  mysql_data:
12
    driver: local
13
    # 可选：指定宿主机路径
14
    driver_opts:
15
      type: none
16
      o: bind
17
      device: /data/mysql

数据卷注意事项

命名卷在docker compose down -v时才会被删除

匿名卷会在容器删除时一同删除

主机路径挂载受宿主机文件权限影响

生产环境建议使用命名卷并定期备份

10.4 网络连接问题#

问题：服务间无法互相访问

解决方案：

1
services:
2
  web:
3
    image: nginx
4
    networks:
5
      - frontend  # 确保服务在同一网络中
6

7
  app:
8
    image: myapp
9
    networks:
10
      - frontend
11
      - backend
12

13
  db:
14
    image: postgres
15
    networks:
16
      - backend
17

18
networks:
19
  frontend:
20
    driver: bridge
21
  backend:
22
    driver: bridge

1
# 查看网络配置
2
docker network inspect myapp_frontend
3

4
# 测试服务间连通性
5
docker compose exec web ping app
6
docker compose exec app nc -zv db 5432
7

8
# 查看DNS解析
9
docker compose exec web nslookup db

10.5 镜像构建缓存问题#

问题：代码修改后镜像未更新

解决方案：

1
# 清除构建缓存并重新构建
2
docker compose build --no-cache
3

4
# 删除所有镜像重新构建
5
docker compose down --rmi all
6
docker compose up -d --build
7

8
# 清理Docker系统缓存
9
docker system prune -a

十一、CI/CD集成#

11.1 GitLab CI配置#

1
stages:
2
  - build
3
  - test
4
  - deploy
5

6
variables:
7
  DOCKER_DRIVER: overlay2
8
  DOCKER_TLS_CERTDIR: "/certs"
9

10
before_script:
11
  - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
12

13
build:
14
  stage: build
15
  script:
16
    - docker compose build
17
    - docker compose push
18
  only:
19
    - main
20
    - develop
21

22
test:
23
  stage: test
24
  script:
25
    - docker compose up -d
26
    - docker compose exec -T app npm test
27
    - docker compose down -v
28
  only:
29
    - main
30
    - develop
31

32
deploy_staging:
33
  stage: deploy
34
  script:
35
    - scp docker-compose.yml $STAGING_SERVER:/app/
36
    - ssh $STAGING_SERVER "cd /app && docker compose pull && docker compose up -d"
37
  only:
38
    - develop
39
  environment:
40
    name: staging
41

42
deploy_production:
43
  stage: deploy
44
  script:
45
    - scp docker-compose.yml docker-compose.prod.yml $PROD_SERVER:/app/
46
    - ssh $PROD_SERVER "cd /app && docker compose -f docker-compose.yml -f docker-compose.prod.yml pull"
47
    - ssh $PROD_SERVER "cd /app && docker compose -f docker-compose.yml -f docker-compose.prod.yml up -d"
48
  only:
49
    - main
50
  environment:
51
    name: production
52
  when: manual

11.2 GitHub Actions配置#

1
name: Deploy to Production
2

3
on:
4
  push:
5
    branches: [main]
6
  pull_request:
7
    branches: [main]
8

9
jobs:
10
  build-and-test:
11
    runs-on: ubuntu-latest
12

13
    steps:
14
      - uses: actions/checkout@v3
15

16
      - name: Set up Docker Buildx
17
        uses: docker/setup-buildx-action@v2
18

19
      - name: Login to Docker Hub
20
        uses: docker/login-action@v2
21
        with:
22
          username: ${{ secrets.DOCKER_USERNAME }}
23
          password: ${{ secrets.DOCKER_PASSWORD }}
24

25
      - name: Build images
26
        run: docker compose build
27

28
      - name: Start services
29
        run: docker compose up -d
30

31
      - name: Run tests
32
        run: docker compose exec -T app npm test
33

34
      - name: Stop services
35
        run: docker compose down -v
36

37
  deploy:
38
    needs: build-and-test
39
    runs-on: ubuntu-latest
40
    if: github.ref == 'refs/heads/main'
41

42
    steps:
43
      - uses: actions/checkout@v3
44

45
      - name: Deploy to production
46
        uses: appleboy/ssh-action@master
47
        with:
48
          host: ${{ secrets.PROD_HOST }}
49
          username: ${{ secrets.PROD_USER }}
50
          key: ${{ secrets.PROD_SSH_KEY }}
51
          script: |
52
            cd /app
53
            git pull origin main
54
            docker compose -f docker-compose.yml -f docker-compose.prod.yml pull
55
            docker compose -f docker-compose.yml -f docker-compose.prod.yml up -d
56
            docker system prune -f

十二、总结#

Docker Compose是多容器应用部署的强大工具，它通过声明式的YAML配置文件，让我们能够轻松定义和管理整个应用栈。本文从基础概念入手，详细解析了Docker Compose的核心语法和常用命令，并通过三个完整的实战案例展示了其在实际项目中的应用。

通过本文的学习，你应该已经掌握了：

✅ 基础知识：Docker Compose的工作原理、安装方法和基本概念 ✅ 核心语法：docker-compose.yml文件的完整配置项和使用技巧 ✅ 实战能力：LNMP、WordPress和微服务架构的完整部署方案 ✅ 高级技巧：环境变量管理、配置覆盖、健康检查和服务扩展 ✅ 生产实践：安全配置、性能优化、监控告警和备份恢复策略 ✅ 问题解决：常见故障的诊断方法和解决方案 ✅ CI/CD集成：自动化部署流水线配置

在实际工作中，Docker Compose主要用于单主机的开发和测试环境，以及小规模的生产环境部署。对于大规模分布式系统，建议使用Kubernetes等更强大的容器编排平台。但无论如何，Docker Compose都是容器化技术学习和应用的重要一步，它的设计理念和最佳实践对于理解整个容器生态系统都有重要意义。

下一步学习建议

深入学习Docker网络：理解bridge、host、overlay等网络模式

掌握Docker Swarm：学习Docker原生的集群编排工具

学习Kubernetes：向大规模容器编排平台进阶

研究服务网格：了解Istio、Linkerd等微服务治理方案

实践DevOps：将容器化集成到完整的CI/CD流水线中

docker

compose

Waiting for api.github.com...

00K

Waiting...