Docker Compose 多容器管理_docker-compose build单个容器-技术文章-醋醋百科网

一、Docker 的 “成长烦恼”：多容器管理困境

在使用 Docker 的过程中，我们常常会遇到这样的场景：

一个简单的 Web 应用，可能就需要数据库容器、应用服务器容器、缓存容器等多个容器协同工作。假设我们要部署一个基于 Python Flask 框架的 Web 应用，搭配 MySQL 数据库和 Redis 缓存。手动启动这些容器时，我们需要依次执行多个docker run命令。

启动 MySQL 容器时，要设置好容器名称、端口映射、环境变量（如数据库密码）等参数，启动 Redis 容器也类似，要指定端口映射等，而启动 Flask 应用容器时，不仅要指定端口映射，还要确保它能正确连接到 MySQL 和 Redis 容器，这就需要设置相应的环境变量。

这还只是一个简单的示例，如果项目规模更大，容器数量增多，依赖关系变得复杂，管理这些容器的难度将呈指数级上升。比如，容器的启动顺序至关重要，如果 MySQL 容器还未完全启动并初始化好，Flask 应用容器就尝试连接，很可能会导致连接失败，应用无法正常运行。而且，当需要停止、重启或者更新这些容器时，逐个操作也非常繁琐，容易出错。在实际的微服务架构项目中，可能会涉及数十个甚至上百个容器，手动管理这些容器简直就是一场噩梦，这也正是我们需要更高效解决方案的原因。

二、Docker Compose：多容器管理的救星

Docker Compose 正是解决上述多容器管理难题的利器。它是一个用于定义和运行多容器 Docker 应用程序的工具，允许我们通过一个 YAML 文件，集中配置应用程序所需的所有服务、网络和卷。简单来说，有了 Docker Compose，我们就可以把之前那些繁琐的docker run命令，整合到一个清晰易读的配置文件中，然后通过简单的命令，一键启动、停止或管理整个应用的所有容器。

以刚才的 Flask 应用为例，使用 Docker Compose 后，我们只需创建一个docker-compose.yml文件，内容如下：

version: '3'
services:
  flask:
    image: my_flask_image:latest
    ports:
      - "5000:5000"
    environment:
      - MYSQL_HOST=mysql
      - MYSQL_PASSWORD=root
      - REDIS_HOST=redis
    depends_on:
      - mysql
      - redis
  mysql:
    image: mysql:latest
    ports:
      - "3306:3306"
    environment:
      - MYSQL_ROOT_PASSWORD=root
  redis:
    image: redis:latest
    ports:
      - "6379:6379"

在这个文件中，version指定了 Compose 文件的版本；services部分定义了三个服务，分别是flask、mysql和redis。每个服务都有对应的镜像、端口映射和环境变量配置。depends_on字段则定义了服务之间的依赖关系，确保mysql和redis容器先启动，再启动flask容器。这样，我们只需要在包含该文件的目录下执行docker-compose up -d命令，就可以一次性启动所有容器，大大简化了多容器应用的管理流程。

三、开启 Docker Compose 之旅：安装与准备

在开始使用 Docker Compose 之前，我们首先需要将它安装到我们的系统中。安装过程会因操作系统的不同而略有差异，下面我们以Linux 系统上的安装步骤为例。在安装之前，请务必确保你的系统中已经安装了 Docker ，因为 Docker Compose 依赖于 Docker 引擎来运行容器。

Linux 系统安装

安装 Docker Compose：安装 Docker Compose 可以使用以下命令下载最新版本的二进制文件：

sudo curl -L "https://github.com/docker/compose/releases/download/2.12.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

请根据实际情况替换版本号（这里是 2.12.2 ）。下载完成后，赋予文件可执行权限：

sudo chmod +x /usr/local/bin/docker-compose

验证安装：执行docker compose version命令，若显示版本信息，则说明 Docker Compose 安装成功。

完成安装后，我们就可以开始使用 Docker Compose 来管理我们的多容器应用了。

四、深入探秘：Docker Compose 核心概念

在了解了 Docker Compose 的基本作用和安装方法后，接下来我们深入探究一下它的核心概念，包括服务、网络和卷，这些概念是理解和使用 Docker Compose 的关键。

（一）服务（Services）：容器的 “角色设定”

服务是 Docker Compose 中定义容器行为的基本组件，你可以把它看作是应用程序的一个组件实例，比如一个 Web 服务、数据库服务或者缓存服务等。每个服务都基于一个 Docker 镜像运行，并且可以配置各种参数，如端口映射、环境变量、依赖关系等。在之前提到的 Flask 应用的docker-compose.yml文件中，flask、mysql和redis都是服务的定义。

以一个更复杂的电商应用为例，它可能包含前端服务、后端 API 服务、数据库服务、缓存服务等多个服务。其中，前端服务可以这样定义：

services:
  frontend:
    image: my_frontend_image:latest
    ports:
      - "80:80"
    depends_on:
      - backend

这里，frontend服务使用my_frontend_image:latest镜像，将容器的 80 端口映射到主机的 80 端口，并且依赖于backend服务。而backend服务可能会依赖数据库服务来存储数据，这样通过depends_on字段，就可以清晰地定义服务之间的依赖关系，确保容器按照正确的顺序启动。

（二）网络（Networks）：容器间的 “通信桥梁”

网络在 Docker Compose 中用于实现容器之间的通信。当我们使用 Docker Compose 启动多个容器时，它会自动为这些容器创建一个默认网络，在这个默认网络中，容器之间可以通过服务名直接通信。例如，在之前的 Flask 应用中，flask容器可以通过mysql这个服务名来连接到 MySQL 数据库容器，而不需要知道 MySQL 容器的具体 IP 地址。

除了默认网络，我们还可以自定义网络，以满足更复杂的网络需求。比如，在一个微服务架构中，我们可能希望将前端服务和后端服务划分到不同的网络中，提高安全性和隔离性。可以这样定义自定义网络：

networks:
  frontend_network:
  backend_network:
services:
  frontend:
    image: my_frontend_image:latest
    ports:
      - "80:80"
    networks:
      - frontend_network
    depends_on:
      - backend
  backend:
    image: my_backend_image:latest
    networks:
      - backend_network
      - frontend_network
    depends_on:
      - db
  db:
    image: mysql:latest
    networks:
      - backend_network

在这个配置中，我们定义了frontend_network和backend_network两个自定义网络。frontend服务只加入frontend_network网络，db服务只加入backend_network网络，而backend服务同时加入了这两个网络，这样既保证了frontend和backend之间的通信，又实现了一定程度的网络隔离。

（三）卷（Volumes）：数据的 “保险箱”

卷是 Docker Compose 中用于持久化数据和在容器之间共享数据的重要机制。在容器化应用中，容器的生命周期通常是短暂的，如果不使用卷，容器中的数据在容器停止或删除时就会丢失。比如，对于一个数据库服务，我们需要将数据存储在卷中，以确保数据的持久化。

在 Compose 文件中定义和使用卷也很简单。还是以 MySQL 数据库服务为例：

volumes:
  db_data:
services:
  db:
    image: mysql:latest
    volumes:
      - db_data:/var/lib/mysql
    environment:
      - MYSQL_ROOT_PASSWORD=root

这里，我们首先在顶级volumes字段中定义了一个名为db_data的卷。然后在db服务中，通过volumes字段将这个卷挂载到容器内的/var/lib/mysql目录，这个目录是 MySQL 存储数据的默认位置。这样，MySQL 数据库的数据就会存储在db_data卷中，即使db容器被删除重建，数据也不会丢失。此外，卷还可以在多个容器之间共享数据，比如一个 Web 应用容器和一个文件处理容器可能共享同一个卷来实现数据的传递。

五、实战演练：Docker Compose 基本操作

在了解了 Docker Compose 的核心概念后，接下来我们通过实际操作来进一步熟悉它。下面我们将以一个简单的 Python Flask 应用搭配 MySQL 数据库的项目为例，详细介绍如何使用 Docker Compose 进行多容器应用的部署和管理。

（一）编写 docker - compose.yml 文件：构建应用蓝图

首先，我们需要编写docker-compose.yml文件，这个文件就像是我们多容器应用的蓝图，定义了各个服务的配置和它们之间的关系。假设我们的项目目录结构如下：

my_project/
├── app/
│   ├── app.py
│   └── requirements.txt
├── docker-compose.yml

在app.py中，我们有一个简单的 Flask 应用，它连接到 MySQL 数据库并进行一些基本的数据库操作：

from flask import Flask
import mysql.connector
app = Flask(__name__)
mydb = mysql.connector.connect(
    host="mysql",
    user="root",
    password="root",
    database="test"
)
@app.route('/')
def hello_world():
    return 'Hello, Docker Compose!'
if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

requirements.txt文件列出了应用所需的依赖包：

Flask
mysql-connector-python

接下来，我们编写docker-compose.yml文件：

version: '3'
services:
  app:
    build:
      context: app
      dockerfile: Dockerfile
    ports:
      - "5000:5000"
    depends_on:
      - mysql
  mysql:
    image: mysql:8.0
    ports:
      - "3306:3306"
    environment:
      - MYSQL_ROOT_PASSWORD=root
      - MYSQL_DATABASE=test

在这个docker-compose.yml文件中：

version指定了 Compose 文件的版本，这里使用3版本，它支持许多新特性和改进。

services部分定义了两个服务，app和mysql。

app服务：

build指定了构建镜像的上下文目录app和 Dockerfile 文件名（默认为Dockerfile ）。这意味着 Compose 会在app目录下查找Dockerfile并构建镜像。

ports将容器的 5000 端口映射到主机的 5000 端口，这样我们就可以通过http://localhost:5000访问 Flask 应用。

depends_on表明app服务依赖于mysql服务，Compose 会确保mysql服务先启动，再启动app服务。

mysql服务：

image指定使用mysql:8.0镜像。

ports将容器的 3306 端口映射到主机的 3306 端口，以便我们可以从主机访问 MySQL 数据库。

environment设置了两个环境变量，MYSQL_ROOT_PASSWORD用于设置 MySQL 的 root 用户密码，MYSQL_DATABASE用于创建一个名为test的数据库。

（二）常用命令：轻松掌控容器世界

编写好docker-compose.yml文件后，我们就可以使用 Docker Compose 的常用命令来管理我们的多容器应用了。

1启动容器：docker compose up -d

在项目目录下执行docker-compose up命令，它会读取docker-compose.yml文件，构建镜像（如果需要），并启动所有定义的服务。如果希望在后台运行容器，可以使用docker compose up -d命令，例如：

docker compose up -d

执行该命令后，你会看到类似以下的输出，表明容器已经成功启动：

Creating network "my_project_default" with the default driver
Building app
Step 1/3 : FROM python:3.9-slim
 ---> 90229156d874
Step 2/3 : COPY. /app
 ---> Using cache
 ---> 9c2e75c1c654
Step 3/3 : WORKDIR /app && pip install -r requirements.txt
 ---> Using cache
 ---> 3a8c1c17a94d
Successfully built 3a8c1c17a94d
Successfully tagged my_project_app:latest
Creating my_project_mysql_1 ... done
Creating my_project_app_1    ... done

2停止容器：docker compose down

当我们需要停止正在运行的容器时，可以使用docker compose down命令，它会停止所有容器，并删除容器、网络等资源。如果想要同时删除数据卷，可以加上-v参数，不过要注意，这会导致数据丢失，使用时需谨慎。例如：

docker compose down

3查看容器状态：docker compose ps

使用docker-compose ps命令可以查看当前正在运行的容器状态，包括容器名称、命令、状态和端口映射等信息。执行该命令后，输出如下：

Name                  Command               State           Ports
-------------------------------------------------------------------
my_project_app_1      python app.py           Up      0.0.0.0:5000->5000/tcp
my_project_mysql_1    docker-entrypoint.sh mysqld Up      0.0.0.0:3306->3306/tcp

4查看日志：docker-compose logs

用于查看容器的日志输出，这在调试应用时非常有用。如果想要实时查看日志，可以加上-f参数，类似tail -f的效果。例如，查看app服务的日志：

docker-compose logs -f app

5构建镜像：docker compose build

如果我们修改了应用代码或Dockerfile，需要重新构建镜像，可以使用docker compose build命令。例如：

docker compose build

6进入容器：有时我们需要进入容器内部执行一些命令，可以使用docker compose exec命令。例如，进入mysql容器的 bash 终端：

docker compose exec mysql bash

7重启容器：当我们对容器的配置进行了修改，或者需要重新启动容器来应用一些更改时，可以使用docker compose restart命令。例如，重启所有容器：

docker compose restart

8暂停和恢复容器：docker compose pause

用于暂停正在运行的容器，例如，暂停app服务的容器：

docker compose pause app

9然后恢复：docker compose unpause

用于恢复暂停的容器。

docker compose unpause app

六、进阶技能：Docker Compose 高级用法

在掌握了 Docker Compose 的基本操作后，我们进一步探索一些高级用法，这些技巧能让我们更灵活、高效地管理多容器应用。

（一）环境变量与配置文件：灵活定制应用

在实际开发中，我们常常需要根据不同的环境（如开发、测试、生产）对应用进行不同的配置。Docker Compose 允许我们使用.env 文件或环境变量来配置 Compose 文件，实现灵活的环境配置。

假设我们有一个 Flask 应用，在开发环境中，我们希望使用本地的测试数据库，而在生产环境中，使用远程的正式数据库。我们可以在项目目录下创建一个.env 文件，内容如下：

DB_HOST=localhost
DB_PORT=3306
DB_USER=root
DB_PASSWORD=root
DB_NAME=test

然后在docker-compose.yml文件中，通过environment字段引用这些环境变量：

version: '3'
services:
  app:
    build:
      context: app
      dockerfile: Dockerfile
    ports:
      - "5000:5000"
    environment:
      - DB_HOST
      - DB_PORT
      - DB_USER
      - DB_PASSWORD
      - DB_NAME
    depends_on:
      - mysql
  mysql:
    image: mysql:8.0
    ports:
      - "3306:3306"
    environment:
      - MYSQL_ROOT_PASSWORD=${DB_PASSWORD}
      - MYSQL_DATABASE=${DB_NAME}

这样，在不同的环境中，我们只需要修改.env 文件中的配置，而无需修改docker-compose.yml文件。如果我们想临时覆盖.env 文件中的某个变量，可以在启动命令中通过-e参数指定，例如：

DB_PASSWORD=new_password docker-compose up -d

这种方式在部署到不同环境时非常方便，也便于管理敏感信息，避免将密码等信息硬编码在 Compose 文件中。

（二）扩展与复用配置：代码的 “高效魔法”

随着项目的发展，我们可能会发现不同的服务之间有一些重复的配置，例如相同的环境变量、日志配置等。这时，我们可以使用 YAML 的锚点（anchor）和别名（alias）来复用配置，减少重复代码 。

假设我们有一个基础的服务配置，包含一些通用的环境变量和日志配置：

version: '3'
services:
  base: &base
    image: alpine
    environment:
      - ENV=production
    logging:
      driver: json-file
      options:
        max-size: "10m"
        max-file: "3"
  web:
    <<: *base
    command: python app.py
    ports:
      - "5000:5000"
  worker:
    <<: *base
    command: python worker.py

在这个例子中，我们定义了一个名为base的锚点，它包含了通用的配置。然后，web和worker服务通过<<: *base语法引用了base的配置，并且可以根据自身需求添加额外的配置，如command和ports 。这样，如果我们需要修改基础配置，只需要在base锚点处修改一次，所有引用它的服务都会自动更新。这种方式特别适用于微服务架构中，多个服务有相似配置的场景，大大提高了配置文件的维护性和可扩展性。

（三）健康检查与依赖管理：保障服务稳定

在多容器应用中，确保服务按顺序启动并且在运行过程中保持稳定非常重要。Docker Compose 提供了健康检查（healthcheck）和依赖管理（depends_on）机制来帮助我们实现这一目标。

健康检查（healthcheck）

健康检查允许我们定义一个命令来检查容器内服务的健康状态。例如，对于一个 Web 服务，我们可以使用curl命令来检查它是否能正常响应请求。在docker-compose.yml文件中，可以这样配置：

version: '3'
services:
  web:
    image: nginx:latest
    ports:
      - "80:80"
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 30s

在这个配置中：

test指定了健康检查的命令，这里使用curl -f http://localhost来检查 Web 服务是否能正常返回响应。

interval表示健康检查的时间间隔，每 30 秒检查一次。

timeout定义了健康检查命令的超时时间，10 秒内没有响应则视为失败。

retries表示连续失败多少次后将容器标记为不健康，这里是 3 次。

start_period指定了容器启动后的初始化时间，在这段时间内的健康检查失败不计入重试次数。

通过健康检查，我们可以及时发现服务的异常状态，避免将请求发送到不健康的容器，提高应用的稳定性。

依赖管理（depends_on）

depends_on用于定义服务之间的依赖关系，确保依赖的服务先启动。例如，一个 Web 服务依赖于数据库服务，我们可以这样配置：

version: '3'
services:
  web:
    image: my_web_image:latest
    ports:
      - "80:80"
    depends_on:
      - db
  db:
    image: postgres:latest
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=password

在这个例子中，web服务依赖于db服务，Docker Compose 会确保在启动web服务之前，db服务已经启动。不过需要注意的是，depends_on只能保证服务的启动顺序，不能确保被依赖的服务已经完全就绪。为了确保服务在可用时才被其他服务访问，我们通常会结合健康检查一起使用。例如：

version: '3'
services:
  web:
    image: my_web_image:latest
    ports:
      - "80:80"
    depends_on:
      db:
        condition: service_healthy
  db:
    image: postgres:latest
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=password
    healthcheck:
      test: ["CMD", "pg_isready", "-U", "user"]
      interval: 10s
      timeout: 5s
      retries: 5

这里，web服务依赖于db服务的健康状态，只有当db服务的健康检查通过后，web服务才会启动。这样可以有效地避免因依赖服务未就绪而导致的应用错误，保障多容器应用的稳定运行。

七、最佳实践：Docker Compose 使用小贴士

在使用 Docker Compose 的过程中，遵循一些最佳实践可以帮助我们更高效地管理多容器应用，提高开发和部署的效率。

（一）使用版本控制管理 Compose 文件

将docker-compose.yml文件纳入版本控制系统（如 Git）是一个非常好的习惯。这样，我们可以方便地追踪文件的修改历史，在出现问题时能够快速回滚到之前的版本。

例如，当我们对服务的配置进行了调整，或者添加了新的服务，如果发现新配置导致应用出现问题，通过版本控制系统，我们可以轻松查看修改记录，找到问题所在并恢复到之前正常的配置。而且，在团队协作开发中，版本控制可以确保团队成员使用的是一致的配置文件，避免因配置不一致而导致的问题。

（二）存储敏感信息

正如前面提到的，不要将敏感信息（如数据库密码、API 密钥等）直接写在docker-compose.yml文件中。建议使用.env 文件或环境变量来存储这些敏感信息。这样不仅提高了安全性，也方便在不同环境中进行配置切换。

例如，在开发环境中，我们可以使用一个简单的测试密码，而在生产环境中，通过设置不同的环境变量来使用正式的强密码。同时，记得将.env 文件添加到.gitignore 文件中，防止敏感信息被意外提交到版本控制系统中。

（三）区分生产和开发环境 Compose 文件

为生产环境和开发环境使用不同的docker-compose.yml文件是一个明智的选择。在开发环境中，我们可能更注重开发的便捷性和快速迭代，例如使用一些开发工具、开启详细的日志输出等。而在生产环境中，则更关注性能、安全性和稳定性。比如，在开发环境的 Compose 文件中，我们可以配置容器以非守护进程模式运行，方便查看日志进行调试：

version: '3'
services:
  app:
    build:
      context: app
      dockerfile: Dockerfile
    ports:
      - "5000:5000"
    depends_on:
      - mysql
    command: python app.py
  mysql:
    image: mysql:8.0
    ports:
      - "3306:3306"
    environment:
      - MYSQL_ROOT_PASSWORD=root
      - MYSQL_DATABASE=test

而在生产环境的 Compose 文件中，我们可以优化容器的资源配置，开启健康检查等：

version: '3'
services:
  app:
    build:
      context: app
      dockerfile: Dockerfile
    ports:
      - "5000:5000"
    depends_on:
      - mysql
    deploy:
      replicas: 3
      resources:
        limits:
          cpus: '0.50'
          memory: 50M
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:5000"]
      interval: 30s
      timeout: 10s
      retries: 3
  mysql:
    image: mysql:8.0
    ports:
      - "3306:3306"
    environment:
      - MYSQL_ROOT_PASSWORD=root
      - MYSQL_DATABASE=test
    volumes:
      - db_data:/var/lib/mysql
volumes:
  db_data:

通过区分不同环境的 Compose 文件，我们可以更好地满足不同环境的需求，提高应用的整体质量。

（四）使用.dockerignore 文件

在构建镜像时，使用.dockerignore 文件可以排除不需要的文件和目录，减少构建上下文的大小，从而加快镜像构建速度。例如，我们通常不需要将node_modules目录、日志文件等包含在镜像中，可以在.dockerignore 文件中添加如下内容：

node_modules
logs
.DS_Store

这样，在执行docker-compose build命令时，Docker 就不会将这些文件和目录添加到构建上下文中，提高了构建效率。

（五）定期更新基础镜像和依赖

随着时间的推移，基础镜像和应用依赖可能会出现安全漏洞或功能更新。定期更新基础镜像和依赖是保障应用安全和稳定性的重要措施。

例如，我们可以定期执行docker pull命令，拉取最新的基础镜像，然后更新docker-compose.yml文件中镜像的版本号。对于应用依赖，如 Python 项目中的requirements.txt文件，我们可以使用工具（如pip-tools ）来更新依赖版本，并重新构建镜像。在更新过程中，务必进行充分的测试，确保应用在新版本的基础镜像和依赖下能够正常运行。

八、总结：Docker Compose 的强大力量

通过本文的介绍，我们深入了解了 Docker Compose 在多容器应用管理中的重要作用和强大功能。从解决多容器管理的困境，到掌握其核心概念、基本操作和高级用法，再到遵循最佳实践，每一步都让我们更加得心应手地使用 Docker Compose。

在实际项目中，无论是开发、测试还是生产环境，Docker Compose 都能为我们提供高效、便捷的多容器管理解决方案。它简化了部署流程，确保了环境的一致性，让我们能够更专注于应用的开发和优化。

醋醋百科网

Good Luck To You!

Docker Compose 多容器管理_docker-compose build单个容器