一文搞懂Docker Compose

什么是Docker Compose

Docker Compose 是 Docker 的一个编排管理工具，它答应你利用一个 YAML 文件来设置应用程序的服务。通过这个文件，你可以定义多个容器如何通过网络相互毗连，以及如何设置它们的环境变量、卷挂载、端口映射等。这使得在单个主机上运行复杂的多容器应用程序变得非常简朴和直观。
Docker Compose主要解决了docker run指令以及docker build后需要手动运行docker run的问题。
Docker Compose主要概念

• 服务（Services）：在 Docker Compose 文件中，一个服务通常指的是一个容器。你可以定义多个服务，每个服务都运行一个或多个容器实例。例如，你的应用程序大概包含一个 Web 服务和一个数据库服务。
  
• 网络（Networks）：Docker Compose 可以创建和管理 Docker 网络，以便服务之间可以相互通信。默认情况下，Docker Compose 会为每个服务创建一个网络，但你也可以定义跨多个服务的自定义网络。
  
• 卷（Volumes）：卷是 Docker 中用于持久化数据的一种机制。在 Docker Compose 中，你可以定义卷，并将卷挂载到容器内的特定路径上，如许即使容器被删除，数据也不会丢失。
  
• 环境变量（Environment Variables）：你可以为服务定义环境变量，这些变量可以在容器内部被读取和利用。这对于设置应用程序的设置非常有用。
  
• 依靠（Dependencies）：你可以在 Docker Compose 文件中定义服务的依靠关系，确保在启动服务时按照正确的顺序举行。例如，你大概希望先启动数据库服务，然后再启动依靠于数据库的服务。
  

安装Docker Compose

Docker Compose项目地址：https://github.com/docker/compose
安装环境信息
IP系统规格10.0.0.10Ubuntu22.042c4g安装前置准备：需要安装Docker
安装步骤：

1. # 下载Docker Compose
2. [root@lb ~]# wget https://github.com/docker/compose/releases/download/v2.35.0/docker-compose-linux-x86_64
3. [root@lb ~]# ll docker-compose-linux-x86_64
4. -rw-r--r-- 1 root root 73664588 Apr 19 14:42 docker-compose-linux-x86_64
6. # 移动至/usr/bin/docker-compose
7. [root@lb ~]# mv docker-compose-linux-x86_64 /usr/bin/docker-compose
9. # 授予权限
10. [root@lb ~]# chmod +x /usr/bin/docker-compose
11. [root@lb ~]# ll /usr/bin/docker-compose
12. -rwxr-xr-x 1 root root 73664588 Apr 19 14:42 /usr/bin/docker-compose*
14. # 检查
15. [root@lb ~]# docker-compose version
16. Docker Compose version v2.35.0

复制代码

Docker Compose常用命令

Docker Compose的命令非常多，下面列举几个常用的，后文遇到新的命令继续讲解
容器相干

• docker-compose up -d：相当于docker run -d，创建并背景运行容器
  
• docker-compose ps：检察容器运行情况，只有-q选项
  
• docker-compose down：删除容器，删除全部容器的全部内容（网络、数据卷）
  
• docker-compose start：启动容器
  
• docker-compose stop：容器关闭
  
• docker-compose restart：重启容器
  
• docker-compose top：检察容器进程信息
  
• docker-compose logs：检察容器日志
  
• docker-compose rm：删除容器
  
• docker-compose exec：进入容器
  

镜像相干

• docker-compose pull：拉取服务的镜像
  
• docker-compose push：推送服务的镜像
  
• docker-compose build：构建服务镜像
  

Docker Compose文件中常用指令

官网文章：https://docs.docker.com/reference/compose-file/services/
Docker Compose文件是一个yaml文件，且运行docker-compose命令时，所在的目次下必须有一个docker-compose.yaml大概compose.yaml文件。
services

Compose 文件必须将services设置为顶级元素，services指定运行容器的相干信息，可以明白成docker run指令的集合
示例：

1. # docker-compose文件
2. [root@lb ~/services]# cat docker-compose.yaml
3. services:
4.   # 服务名称
5.   web:
6.     image: nginx:latest
7.     ports:
8.       - "8080:80"
10. # 运行容器
11. [root@lb ~/services]# docker-compose up -d
12. [+] Running 1/1
13. ✔ Container services-web-1  Started
15. # 查看运行的容器
16. [root@lb ~/services]# docker-compose ps
17. NAME             IMAGE          COMMAND                  SERVICE   CREATED              STATUS              PORTS
18. services-web-1   nginx:latest   "/docker-entrypoint.…"   web       About a minute ago   Up About a minute   0.0.0.0:8080->80/tcp, [::]:8080->80/tcp

复制代码

image

指定容器运行时的基础镜像
ports

指定容器运行时的端口号，可以写多个
container_name

指定容器的名字，没有container_name标签时，会以services-[services_name]-[services_num]为容器名称
示例：

1. [root@lb ~/container_name]# cat docker-compose.yaml
2. services:
3.   web:
4.     image: nginx:latest
5.     # 指定容器名称
6.     container_name: nginx_1
7.     ports:
8.       - "8081:80"
9.           
10. [root@lb ~/container_name]# docker-compose up -d
11. [+] Running 2/2
12. ✔ Network container_name_default  Created                                                                                                                                                                0.1s
13. ✔ Container nginx_1               Started                                                                                                                                                                0.2s
14. [root@lb ~/container_name]# docker-compose ps -a
15. NAME      IMAGE          COMMAND                  SERVICE   CREATED         STATUS         PORTS
16. nginx_1   nginx:latest   "/docker-entrypoint.…"   web       5 seconds ago   Up 5 seconds   0.0.0.0:8081->80/tcp, [::]:8081->80/tcp

复制代码

build

运行Dockerfile，构建镜像利用，有几个子标签
context

指定Dockerfile所在的目次
dockerfile

指定Dockerfile的文件名，同docker build -f指令，该指令可以不写，默认是Dockerfile
示例：

1. [root@lb ~/build]# cat compose.yaml
2. services:
3.   zrlog:
4.     container_name: zrlog
5.     # build指令使用
6.     build:
7.       context: ./zrlog
8.       dockerfile: Dockerfile
9.     ports:
10.       - "8082:8080"
11.           
12. # 构建镜像
13. [root@lb ~/build]# docker-compose build
14. Compose can now delegate builds to bake for better performance.
15. To do so, set COMPOSE_BAKE=true.
16. [+] Building 6.5s (9/9) FINISHED                                                                                                                                                                docker:default
17. => [zrlog internal] load build definition from Dockerfile                                                                                                                                                0.0s
18. => => transferring dockerfile: 409B                                                                                                                                                                      0.0s
19. => [zrlog internal] load metadata for docker.io/library/tomcat:9.0.87-jdk8-corretto                                                                                                                      6.3s
20. => [zrlog internal] load .dockerignore                                                                                                                                                                   0.0s
21. => => transferring context: 2B                                                                                                                                                                           0.0s
22. => [zrlog internal] load build context                                                                                                                                                                   0.1s
23. => => transferring context: 10.80MB                                                                                                                                                                      0.1s
24. => [zrlog 1/3] FROM docker.io/library/tomcat:9.0.87-jdk8-corretto@sha256:6928733a4f4c15d61c45a14b0197fe9a160f49f6f13b1b0b06310561cb320ef0                             
25. => => writing image sha256:0d6bbaa1db8bf9d30e976c17f2991aca20e6b6e070be646b85240e1ec0ffdc71                                                                                                              0.0s
26. => => naming to docker.io/library/build-zrlog                                                                                                                                                            0.0s
27. => [zrlog] resolving provenance for metadata file                                                                                                                                                        0.0s
28. [+] Building 1/1
29. ✔ zrlog  Built                                                                                                                                                                                           0.0s
30. # 启动镜像
31. [root@lb ~/build]# docker-compose up -d
32. [+] Running 2/2
33. ✔ Network build_default    Created                                                                                                                                                                       0.1s
34. ✔ Container build-zrlog-1  Started                              
36. [root@lb ~/build]# docker-compose ps
37. NAME      IMAGE         COMMAND             SERVICE   CREATED              STATUS                        PORTS
38. zrlog     build-zrlog   "catalina.sh run"   zrlog     About a minute ago   Up About a minute (healthy)   0.0.0.0:8082->8080/tcp, [::]:8082->8080/tcp

复制代码

environment

docker run -e选项，指定容器运行后的环境变量
示例：

1. [root@lb ~/environment]# cat compose.yaml
2. services:
3.   db:
4.     image: mysql:5.7
5.     container_name: mysql_db
6.     ports:
7.       - "3306:3306"
8.     environment:
9.       # 指定MySQL root的密码
10.       - "MYSQL_ROOT_PASSWORD=root123"
11.       # 指定创建一个zrlog的数据库
12.       - "MYSQL_DATABASE=zrlog"
13. # 运行
14. [root@lb ~/environment]# docker-compose up -d
15. [+] Running 2/2
16. ✔ Network environment_default  Created                                                                                                                                                                   0.1s
17. ✔ Container mysql_db           Started                                                                       
19. # check
20. [root@lb ~/environment]# docker-compose ps -a
21. NAME       IMAGE       COMMAND                  SERVICE   CREATED          STATUS          PORTS
22. mysql_db   mysql:5.7   "docker-entrypoint.s…"   db        14 seconds ago   Up 14 seconds   0.0.0.0:3306->3306/tcp, [::]:3306->3306/tcp, 33060/tcp

复制代码

restart

指定容器的重启方式，和docker run --restart选项同等
重启方式：

• always：主动重启
  
• unless-stopped：只在容器关闭，制止的时候重启
  
• on-failure：只在失败的时候重启
  

示例：

1. services:
2.   db:
3.     # 指定重启策略
4.     restart: always
5.     image: mysql:5.7
6.     container_name: mysql_db
7.     ports:
8.       - "3306:3306"
9.     environment:
10.       # 指定MySQL root的密码
11.       - "MYSQL_ROOT_PASSWORD=root123"
12.       # 指定创建一个zrlog的数据库
13.       - "MYSQL_DATABASE=zrlog"

复制代码

volumes

官网文章：https://docs.docker.com/reference/compose-file/volumes/
volumes指令在Compose文件中有两个作用，作为顶级元素时，volume会创建一个数据卷，作为子级元素时，会为容器挂载数据卷。
示例：

1. [root@lb ~/volumes]# cat compose.yaml
2. services:
3.   db:
4.     # 指定重启策略
5.     restart: always
6.     image: mysql:5.7
7.     container_name: mysql_db_1
8.     ports:
9.       - "3307:3306"
10.     environment:
11.       # 指定MySQL root的密码
12.       - "MYSQL_ROOT_PASSWORD=root123"
13.       # 指定创建一个zrlog的数据库
14.       - "MYSQL_DATABASE=zrlog"
15.     volumes:
16.       - mysql_data:/var/lib/mysql
17.           
18. # 创建mysql_data的数据卷
19. volumes:
20.   mysql_data:
21. # 启动容器  
22. [root@lb ~/volumes]# docker-compose up -d
23. [+] Running 1/1
24. ✔ Container mysql_db_1  Started                                                                             # 检查                                                                                             0.3s
25. [root@lb ~/volumes]# docker-compose ps -a
26. NAME         IMAGE       COMMAND                  SERVICE   CREATED         STATUS         PORTS
27. mysql_db_1   mysql:5.7   "docker-entrypoint.s…"   db        4 seconds ago   Up 4 seconds   33060/tcp, 0.0.0.0:3307->3306/tcp, [::]:3307->3306/tcp
29. # 检查数据卷
30. [root@lb ~/volumes]# docker inspect mysql_data
31. [
32.     {
33.         "CreatedAt": "2025-04-12T15:42:17+08:00",
34.         "Driver": "local",
35.         "Labels": null,
36.         "Mountpoint": "/var/lib/docker/volumes/mysql_data/_data",
37.         "Name": "mysql_data",
38.         "Options": null,
39.         "Scope": "local"
40.     }
41. ]

复制代码

当需要挂载到本机宿主机时，仅利用次级元素的volumes即可

示例：

1. services:
2.   web:
3.     image: nginx:latest
4.     volumes:
5.       - ./html:/usr/share/nginx/html

复制代码

可以利用外部存储卷

示例：

1. services:
2.   web:
3.     image: nginx:latest
4.     volumes:
5.       - web_data:/usr/share/nginx/html
6. volumes:
7.   web_data:
8.   #external指定此卷已存在于平台上，并且其生命周期由应用程序之外的生命周期管理。如果卷不存在，Compose 将不会创建该卷并返回错误。
9.     external: true

复制代码

healthcheck

healthcheck用于定义服务的健康检查机制。通过健康检查，可以确保容器在启动后能够正常运行，并且在容器不可用时主动重启或重新调度.
其子元素有：

• test：定义健康检查的命令。可以是一个命令或一个脚本。
  
• interval：两次健康检查之间的间隔时间（默认单位为秒）。
  
• timeout：单次健康检查的超时时间。
  
• retries：健康检查失败后重试的次数。
  
• start_period：容器启动后开始健康检查的延迟时间。
  示例：
  

1. services:
2.   web:
3.     image: nginx:latest
4.     ports:
5.       - "80:80"
6.     healthcheck:
7.       test: ["CMD", "curl", "-f", "http://localhost"]
8.       interval: 30s
9.       timeout: 10s
10.       retries: 3
11.       start_period: 5s

复制代码

depends_on

depends_on用于控制服务之间的启动顺序。它确保在启动某个服务之前，其依靠的服务已经启动。例如web服务依靠数据库服务，需要数据库服务先启动时可以利用depends_on。
虽然depends_on确保了服务的启动顺序，但它不会等待服务完全启动后再启动依靠的服务，例如，数据库服务大概还在初始化过程中，而web服务已经启动了，这大概会导致web应用程序无法毗连到数据库服务，这个时候需要利用healthcheck
depends_on只会影响容器的启动顺序，不会影响容器的制止顺序
示例：

1. services:
2.   web:
3.     image: nginx:latest
4.     ports:
5.       - "80:80"
6.     # 指定依赖db服务
7.     depends_on:
8.       db:
9.         condition: service_healthy
10.   db:
11.     image: mysql:latest
12.     environment:
13.       - "MYSQL_ROOT_PASSWORD=root123"
14.     # 健康检查
15.     healthcheck:
16.       test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
17.       interval: 10s
18.       timeout: 5s
19.       retries: 5

复制代码

links(在Docker Compose版本3以上已被废弃)

links 是一个用于定义服务之间网络毗连的指令。它答应一个服务访问另一个服务的容器，并通过服务名称举行通信。虽然 links 在 Docker Compose 的早期版本中非经常用，但在 Docker Compose 版本 3 及以上中，links 已被废弃，推荐利用默认的网络功能来实现服务之间的通信。
links的作用：

• 创建网络毗连：links 用于在服务之间创建网络毗连，答应一个服务访问另一个服务的容器。
  
• 环境变量和 /etc/hosts：当利用 links 时，Docker 会主动设置环境变量和 /etc/hosts 条目，使得服务之间可以通过服务名称举行通信。
  

示例：

1. [root@lb ~/links]# cat compose.yaml
2. services:
3.   web1:
4.     container_name: nginx1
5.     image: nginx:latest
6.     links:
7.       - web2:nginx
8.     ports:
9.       - "81:80"
10.   web2:
11.     container_name: nginx2
12.     image: nginx:latest
13.     ports:
14.       - "82:80"
16. # 运行容器
17. [root@lb ~/links]# docker-compose up -d
18. [+] Running 3/3
19. ✔ Network links_default  Created                                                                                                                                                                         0.1s
20. ✔ Container nginx2       Started                                                                                                                                                                         0.4s
21. ✔ Container nginx1       Started                                                                                                                                                                         0.6s
22. # 检查
23. [root@lb ~/links]# docker-compose ps -a
24. NAME      IMAGE          COMMAND                  SERVICE   CREATED          STATUS          PORTS
25. nginx1    nginx:latest   "/docker-entrypoint.…"   web1      13 seconds ago   Up 11 seconds   0.0.0.0:81->80/tcp, [::]:81->80/tcp
26. nginx2    nginx:latest   "/docker-entrypoint.…"   web2      13 seconds ago   Up 12 seconds   0.0.0.0:82->80/tcp, [::]:82->80/tcp
29. ###### 测试，进入nginx1的容器内部
30. [root@lb ~/links]# docker exec -it nginx1 bash
31. # 查看hosts解析
32. root@12b2517e712e:/# cat /etc/hosts
33. 127.0.0.1       localhost
34. ...
35. # web2的hosts解析
36. 172.24.0.3      12b2517e712e
38. root@12b2517e712e:/# curl
39. curl: try 'curl --help' or 'curl --manual' for more information
40. root@12b2517e712e:/# curl http://nginx
41. <!DOCTYPE html>
42. <html>
43. # 网页内容
44. </body>
45. </html>

复制代码

在 Docker Compose 版本 3 及以上中，推荐利用默认网络功能来实现服务之间的通信。
示例：

1. services:
2.   web1:
3.     container_name: nginx1
4.     image: nginx:latest
5.     ports:
6.       - "81:80"
7.   web2:
8.     container_name: nginx2
9.     image: nginx:latest
10.     ports:
11.       - "82:80"

复制代码

在这个示例中，web1和web2默认毗连到同一个网络中，web1可以通过web2服务名称直接访问web2服务
networks

networks用于定义和管理服务之间的网络通信，通过networks可以创建自定义网络，将服务毗连到这些网络中，从而实现灵活的网络布局。
在 Docker Compose 中，如果没有显式定义网络，Docker Compose 会主动为每个项目创建一个默认网络，并将全部服务毗连到该网络。默认网络是桥接网络（bridge network），服务之间可以通过服务名称直接通信。
也可以自定义网络，并将服务毗连到这些网络中，自定义网络可以是桥接网络（bridge）、主机网络（host）或覆盖网（overlay）。
示例：

1. services:
2.   web:
3.     image: nginx:latest
4.     ports:
5.       - "80:80"
6.     networks:
7.       - my_network
8.   db:
9.     image: mysql:latest
10.     environment:
11.       MYSQL_ROOT_PASSWORD: my-secret-pw
12.     networks:
13.       - my_network
15. networks:
16.   my_network:
17.     driver: bridge

复制代码

deploy

deploy 设置项用于定义服务在部署时的行为，包罗资源限制、副本数目、更新策略、重启策略等
这里以资源限制为例

1. services:
2.   web:
3.     image: nginx:latest
4.     ports:
5.       - "80:80"
6.     deploy:
7.       resources:
8.         limits:
9.           cpus: '0.5'  # 限制 CPU 使用量为 0.5 个核心
10.           memory: 50M  # 限制内存使用量为 50MB
11.         reservations:
12.           cpus: '0.2'  # 保留 0.2 个核心
13.           memory: 20M  # 保留 20MB 内存

复制代码

limits：定义容器可以利用的最大资源量。

• cpus：浮点数，表示 CPU 核心数。例如，0.5 表示限制为 0.5 个核心。
  
• memory：字符串，表示内存限制，单位可以是 B（字节）、K（千字节）、M（兆字节）、G（吉字节）。
  

reservations：定义容器启动时保留的资源量。

• cpus：浮点数，表示 CPU 核心数。
  
• memory：字符串，表示内存巨细。
  

Docker Compose变量文件

Compose变量文件是在compose.yaml同级目次中创建.env文件，在.env文件中写入key=value的形式，然后在compose.yaml文件中以${key}的形式举行利用
示例：

1. [root@lb ~/var]# ll
2. total 16
3. ## .env是变量文件
4. -rw-r--r--  1 root root    8 Apr 19 21:25 .env
5. -rw-r--r--  1 root root   73 Apr 19 21:26 compose.yaml
6. [root@lb ~/var]# cat .env
7. PORT=83
8. [root@lb ~/var]# cat compose.yaml
9. services:
10.   web:
11.     image: nginx:latest
12.     ports:
13.       ## ${PORT}取值
14.       - "${PORT}:80"
15. [root@lb ~/var]# docker-compose up -d
16. [+] Running 2/2
17. ✔ Network var_default  Created                                                                                                                                                                           0.1s
18. ✔ Container var-web-1  Started                                                                                                                                                                           0.4s
19. [root@lb ~/var]# docker-compose ps
20. NAME        IMAGE          COMMAND                  SERVICE   CREATED         STATUS         PORTS
21. var-web-1   nginx:latest   "/docker-entrypoint.…"   web       7 seconds ago   Up 6 seconds   0.0.0.0:83->80/tcp, [::]:83->80/tcp

复制代码

利用多个compose文件

当我们具有多个compose文件时，我们应该怎么运行呢？
方式一：利用-f选项举行合并构建

当有多个 Docker Compose 文件时，可以利用 docker-compose 命令的 -f选项来指定多个 Compose 文件，并一起构建和管理服务。这种方式答应你将设置拆分到多个文件中，然后组合利用它们。
例如我们有以下两个compose文件:
docker-compose.yaml

1. services:
2.   web:
3.     image: nginx:latest
4.     ports:
5.       - "80:80"

复制代码

docker-compose.admin.yaml

1. version: '3.8'
2. services:
3.   web:
4.     environment:
5.       - NGINX_ENV=prod
6.   db:
7.     image: mysql:latest
8.     environment:
9.       MYSQL_ROOT_PASSWORD: my-secret-pw

复制代码

我们可以利用下面的命令来举行构建

1. docker-compose -f docker-compose.yml -f docker-compose.override.yml up -d

复制代码

文件合并规则：
Docker Compose 会按顺序加载指定的文件，并将它们的内容合并。合并规则如下：

• 服务（Services）：如果多个文件中定义了相同的服务，后者的设置会覆盖前者的设置。
  
• 网络（Networks）：如果多个文件中定义了相同的网络，后者的设置会覆盖前者的设置。
  
• 卷（Volumes）：如果多个文件中定义了相同的卷，后者的设置会覆盖前者的设置。
  

我们可以利用利用可以利用 docker-compose config 命令检察合并后的设置。这个命令会输出终极的设置内容，帮助你确认设置是否正确。

1. docker-compose -f docker-compose.yml -f docker-compose.override.yml config

复制代码

方式二：利用include元向来引用别的的compose文件

include 指令可以在主 Compose 文件中引用其他 Compose 文件，从而实现设置的模块化和重用。被引用的文件可以定义服务、网络、卷等，主文件会将这些内容合并到终极的设置中。
示例：

1. include:
2.   - my-compose-include.yaml
3. services:
4.   serviceA:
5.     build: .
6.     depends_on:
7.       - serviceB

复制代码

也支持从远程URL加载Compose文件

1. include:
2.   - https://example.com/services/web.yml
3.   - https://example.com/services/db.yml
4. services:
5.   serviceA:
6.     build: .
7.     depends_on:
8.       - serviceB

复制代码

文件合并规则

• Docker Compose 会按顺序加载 include 中指定的文件，并将它们的内容合并到主文件中。合并规则如下：
  
• 服务（Services）：如果多个文件中定义了相同的服务，后者的设置会覆盖前者的设置。
  
• 网络（Networks）：如果多个文件中定义了相同的网络，后者的设置会覆盖前者的设置。
  
• 卷（Volumes）：如果多个文件中定义了相同的卷，后者的设置会覆盖前者的设置。
  

留意事项

• 文件顺序：include 中文件的加载顺序很重要，后加载的文件会覆盖前加载的文件中的设置。
  
• 本地优先：如果本地和远程文件有相同的路径或 URL，Docker Compose 会优先利用本地文件。
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。