Docker-Compose进行容器编排的简单使用

曾经终败给现在 2023-10-15 16:47 151阅读 0赞

## 一，前言 ##

众所周知，Docker作为一种轻量级的虚拟化技术，可以使得应用程序和其依赖项被打包在一个容器中，从而实现快速部署和运行。

然而，在真实的企业级应用中，应用程序规模的扩大，一个服务往往需要和很多个其它的服务进行关联，单个服务也有可能有多个容器实例。如果需要发布，很可能会需要人员手动管理这些容器的配置和启动顺序，或对每一个容器进行打包和启动的操作，非常繁琐，容易出错。

为了解决这个问题，Docker社区开发了docker-compose工具。它使用YAML文件定义应用程序的架构和依赖关系，并自动启动、连接和协调多个Docker容器，从而简化了Docker应用程序的部署和运行。

## 二，Docker-Compose介绍 ##

Docker Compose是Docker官方提供的一个命令行工具，用于定义和运行多个Docker容器的应用程序。它能够在 Docker 节点上，以单引擎模式(Single-Engine Mode)进行多容器应用的部署和管理。它通过YAML文件来配置应用程序的服务，。

Docker Compose 并不是通过脚本和各种冗长的 docker 命令来将应用组件组织起来，而是通过一个声明式的配置文件描述整个应用，从而使用一条命令完成部署，并支持在单个主机上或者多个主机上进行部署。应用部署成功后，还可以通过一系列简单的命令实现对其完整声明周期的管理。另外配置文件还可以置于版本控制系统中进行存储和管理。

使用Docker Compose，可以轻松地管理应用程序的多个服务，例如数据库、缓存、Web服务器等。同时，还可以通过Docker Compose来定义容器之间的关系和依赖关系，以及如何进行容器之间的通信，帮助开发人员和运维人员更轻松地管理和部署多个Docker容器。

Docker-Compose有2个重要的概念：

*  项目（Project）：由一组关联的应用容器组成的一个完整业务单元，在 docker-compose.yml 文件中定义。

> 在Docker Compose文件中，每个服务都可以被定义为**项目**中的一个组件。通过使用Docker Compose，可以将多个服务组合在一起，以便于测试、部署和管理整个应用程序。

*  服务（Service）：一个应用的容器，实际上可以包括若干运行相同镜像的容器实例。

> **服务**是由一个或多个容器组成的应用程序组件。每个服务通常代表应用程序中的一个独立部分，例如数据库、Web服务器或后台处理程序。每个服务由一个独立的镜像定义，并在Docker Compose文件中声明了服务依赖、网络设置、环境变量等配置信息。

## 三，Docker-Compose安装 ##

Linux 上可以从 Github 上下载它的二进制包来使用，最新发行的版本地址：[https://github.com/docker/compose/releases][https_github.com_docker_compose_releases]。

运行以下命令以下载 Docker Compose 的当前稳定版本：

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

不过gitHub上下载可能会出现不稳定的情况，网上也给出了其他高速下载方式：

curl -L https://get.daocloud.io/docker/compose/releases/download/v2.4.1/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose

但是笔者亲自下的时候文件并不完整，因此最后还是靠github上的地址下载完成。

[root@localhost opt]# curl -L "https://github.com/docker/compose/releases/download/v2.21.0/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
      % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                     Dload  Upload   Total   Spent    Left  Speed
      0     0    0     0    0     0      0      0 --:--:--  0:00:02 --:--:--     0
    100 56.7M  100 56.7M    0     0   435k      0  0:02:13  0:02:13 --:--:--  315k

如果对python熟悉的小伙伴也可以用python进行下载，这里不做详述。

下载完成后在所在包会产生一个docker-compose的二进制文件：

[root@localhost ~]# cd /usr/local
    [root@localhost local]# ls
    bin  etc  games  include  lib  lib64  libexec  sbin  share  src
    [root@localhost local]# cd bin
    [root@localhost bin]# ls
    docker-compose

然后给这个文件一些可执行的权限：

[root@localhost bin]# chmod +x /usr/local/bin/docker-compose

最后检查docker-compose下载的版本情况即可：

[root@localhost bin]# docker-compose -v
    Docker Compose version v2.21.0

如果正确显示当前安装的版本信息，即证明安装成功。

如果想删除docker-compose也很简单，因为它主要依赖于下载的docker-compose文件，因此直接删除该文件，重启一下系统即可：

[root@localhost bin]#rm -rf /usr/local/bin/docker-compose
    [root@localhost bin]#reboot

## 四，Docker-Compose常用命令使用介绍 ##

在Linux系统中安装完docker-compose后可以通过**docker-compose --help**查看其命令参数的使用方法：

[root@localhost ~]# docker-compose --help
    Define and run multi-container applications with Docker.
    
    Usage:
      docker-compose [-f <arg>...] [--profile <name>...] [options] [--] [COMMAND] [ARGS...]
      docker-compose -h|--help
    
    Options:
      -f, --file FILE             Specify an alternate compose file
                                  (default: docker-compose.yml)
      -p, --project-name NAME     Specify an alternate project name
                                  (default: directory name)
      --profile NAME              Specify a profile to enable
      -c, --context NAME          Specify a context name
      --verbose                   Show more output
      --log-level LEVEL           Set log level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
      --ansi (never|always|auto)  Control when to print ANSI control characters
      --no-ansi                   Do not print ANSI control characters (DEPRECATED)
      -v, --version               Print version and exit
      -H, --host HOST             Daemon socket to connect to
    
      --tls                       Use TLS; implied by --tlsverify
      --tlscacert CA_PATH         Trust certs signed only by this CA
      --tlscert CLIENT_CERT_PATH  Path to TLS certificate file
      --tlskey TLS_KEY_PATH       Path to TLS key file
      --tlsverify                 Use TLS and verify the remote
      --skip-hostname-check       Don't check the daemon's hostname against the
                                  name specified in the client certificate
      --project-directory PATH    Specify an alternate working directory
                                  (default: the path of the Compose file)
      --compatibility             If set, Compose will attempt to convert keys
                                  in v3 files to their non-Swarm equivalent (DEPRECATED)
      --env-file PATH             Specify an alternate environment file
    
    Commands:
      build              Build or rebuild services
      config             Validate and view the Compose file
      create             Create services
      down               Stop and remove resources
      events             Receive real time events from containers
      exec               Execute a command in a running container
      help               Get help on a command
      images             List images
      kill               Kill containers
      logs               View output from containers
      pause              Pause services
      port               Print the public port for a port binding
      ps                 List containers
      pull               Pull service images
      push               Push service images
      restart            Restart services
      rm                 Remove stopped containers
      run                Run a one-off command
      scale              Set number of containers for a service
      start              Start services
      stop               Stop services
      top                Display the running processes
      unpause            Unpause services
      up                 Create and start containers
      version            Show version information and quit

这里笔者仅对常用的一些命令进行基础的使用说明，如下：

1.  启动容器：`docker-compose up`
    
     *  通过该命令可以启动 Docker Compose 中定义的所有服务。
     *  如果在命令后面加上 `-d` 参数，可以在后台运行服务。
2.  运行指定的yml配置文件：`docker-compose -f /opt/my_compose.yml up`
    
     *  通过-f可以指定目标目录中自定义配置的\*.yml文件运行，并且可以批量通过-f指定。
3.  启动指定服务：`docker-compose up <service>`
    
     *  通过指定服务名称的方式，可以只启动某个特定的服务，而不是所有服务。
4.  构建和启动容器：`docker-compose up --build`
    
     *  该命令会重新构建镜像，并启动容器。适用于在修改了 Dockerfile 或构建上下文时进行重新构建。
5.  停止容器：`docker-compose down`
    
     *  通过该命令可以停止并移除 Docker Compose 中定义的所有服务。
     *  该命令会移除相关的容器、网络和数据卷。
6.  停止指定服务：`docker-compose stop <service>`
    
     *  通过指定服务名称的方式，可以停止某个特定的服务。
7.  重启容器：`docker-compose restart <service>`
    
     *  通过指定服务名称的方式，可以重启某个特定的服务。
8.  查看日志：`docker-compose logs`
    
     *  通过该命令可以查看 Docker Compose 中所有服务的日志。
     *  如果只想查看某个特定服务的日志，可以通过 `docker-compose logs <service>` 命令指定。
9.  查看运行状态：`docker-compose ps`
    
     *  通过该命令可以查看 Docker Compose 中定义的所有服务的运行状态。
10. 执行命令：`docker-compose run <service> <command>`
    
     *  通过该命令可以在指定服务中执行特定的命令。
     *  例如，`docker-compose run webserver nginx -v` 将在 `webserver` 服务中执行 `nginx -v` 命令。
11. 清除容器和网络：`docker-compose rm`
    
     *  通过该命令可以清除已停止的容器和网络。

这些是 Docker Compose 的一些常见使用命令，可以帮助我们管理和操作多个容器。有了这些命令，你可以方便地启动、停止、重启和管理多个容器，并查看日志和运行状态。

## 五，yml配置文件简单说明 ##

在docker-compose中通常使用YAML 文件来定义多服务的应用。比如：

version: "3.7"
    services:
      web:
        build: .
        depends_on:
          - db
          - redis
      redis:
        image: redis
      db:
        image: mysql

另外，由于YAML 是 JSON 的一个子集，因此也可以使用JSON来定义配置文件。比如：

{
      "version": "3",
      "services": {
        "web": {
          "image": "nginx:latest",
          "ports": ["8080:80"],
          "volumes": ["./webapp:/usr/share/nginx/html"],
          "restart": "always"
        }
      }
    }

docker-compose 默认使用文件名 docker-compose.yml。上面命令介绍也提到过，也可以使用 -f 参数指定具体文件。

在使用docker-compose命令时，可以使用"-f"参数来指定其他文件名，例如：

docker-compose -f service1-compose.yml up

这将使用名为"service1-compose.yml"的文件来运行docker-compose命令。如果想使用多个文件，则可以使用多个"-f"参数，如下所示：

docker-compose -f file1.yml -f file2.yml up

这将同时使用"file1.yml"和"file2.yml"来运行docker-compose命令。

### yml文件格式介绍 ###

熟悉java开发的小伙伴如果常配置application.yml文件，应该很清楚yml的文件格式，而在docker-compose配置文件中，一共有4个固定的1级文件key：

*  version 是必须指定的，而且总是位于文件的第一行。它定义了 Compose 文件格式(主要是 API)的版本。但是version 并非定义 Docker Compose 或 Docker 引擎的版本号。
 *  services 用于定义不同的应用服务。Docker Compose 会将每个服务部署在各自的容器中。
 *  networks 用于指引 Docker 创建新的网络。默认情况下，Docker Compose 会创建 bridge 网络。 这是一种单主机网络，只能够实现同一主机上容器的连接。当然，也可以使用 driver 属性来指定不同的网络类型。

services:
      some-service:
        networks:
          some-network:
            aliases:
             - alias1
          other-network:
            aliases:
             - alias2
    networks:
      some-network:
        # Use a custom driver
        driver: custom-driver-1
      other-network:
        # Use a custom driver which takes special options
        driver: custom-driver-2

*  volumes 用于指引 Docker 来创建新的卷。

这个指令在docker中也是很常见的一个，而在Docker Compose中也同样如此。它可以使用单个命令将容器化的应用程序部署到多个主机上。在Docker Compose的配置文件中，可以使用volumes关键字来指定容器与主机之间的共享文件夹。

volumes可以用来定义和管理数据卷。可以使用绝对路径，相对路径或命名卷来指定要挂载的文件或目录的路径。

例如，可以使用以下配置来定义一个名为mydata的数据卷：

services:
      web:
        image: nginx:latest
        volumes:
          - mydata:/var/www/html

此时将创建一个名为mydata的卷，并将其挂载到web容器的/var/www/html目录中。

也可以将主机文件系统上的目录挂载到Docker容器中。例如，可以使用以下配置来将主机上的/home/user/myapp目录挂载到web容器的/var/www/html目录中：

services:
      web:
        image: nginx:latest
        volumes:
          - /home/user/myapp:/var/www/html

这样，在主机文件系统上对/home/user/myapp目录的更改会反映在web容器中的/var/www/html目录中。使用volumes可以轻松地与容器共享数据，这对于许多应用程序都是必需的。

### 其他指令参考 ###

**build-构建镜像路径**

指定为构建镜像上下文路径。例如 customer 服务，指定为从上下文路径 ./dir/Dockerfile 所构建的镜像：

version: "3.7"
    services:
      customer:
        build: ./dir

或者作为具有在上下文指定的路径的对象，以及可选的 Dockerfile 和 args：

version: "3.7"
    services:
      customer:
        build:
          context: ./dir
          dockerfile: Dockerfile-alternate
          args:
            buildno: 1
          labels:
            - "com.yy.description=Accounting customer"
            - "com.yy.department=Finance"
            - "com.yy.label-with-empty-value"
          target: prod

*  context：上下文路径。
 *  dockerfile：指定构建镜像的 Dockerfile 文件名。
 *  args：添加构建参数，这是只能在构建过程中访问的环境变量。
 *  labels：设置构建镜像的标签。
 *  target：多层构建，可以指定构建哪一层。

**container\_name-自定义容器名称**

指定自定义容器名称，而不是生成的默认名称。

container_name: my_redis

**depends\_on-设置依赖关系**

在docker-compose中，depends\_on是一个关键字，用于定义服务之间的依赖关系。该字段定义的服务将在其他服务启动之前启动。在设定容器的依赖关系后，使用如下命令时：

*  docker-compose up ：以依赖性顺序启动服务。在以下示例中，先启动 db 和 redis ，才会启动 web。
 *  docker-compose up SERVICE ：自动包含 SERVICE 的依赖项。在以下示例中，docker-compose up web 还将创建并启动 db 和 redis。
 *  docker-compose stop ：按依赖关系顺序停止服务。在以下示例中，web 在 db 和 redis 之前停止。

version: "3.7"
    services:
      web:
        build: .
        depends_on:
          - db
          - redis
      redis:
        image: redis
      db:
        image: mysql

depends\_on的使用场景通常是在多个服务之间需要一定的顺序或依赖关系时。例如，在本例中，如果web服务尝试连接到尚未启动的数据库或redis，将会失败。因此，web服务需要在这两个服务启动后才能成功启动。

需要注意的是，尽管depends\_on可以确保服务按照所需的顺序启动，但它不能保证服务准备好接受连接或请求，web 服务不会等待 redis db 完全启动 之后才启动。

**env\_file-从文件添加环境变量**

在生产环境中，可能需要在许多不同的地方配置环境变量，例如：服务器，Jenkins构建，Docker Compose等。使用 `env_file` 指令可以将这些环境变量统一管理，从而方便维护。

`env_file`是Docker Compose配置文件中的一个指令，可以用于从外部文件中读取环境变量并传递给Docker容器。具体使用方式如下：

1.  在 `docker-compose.yml` 配置文件中指定 `env_file` 参数，并指定要读取的环境文件路径：
    
        services:
          myapp:
            image: myapp:latest
            env_file:
              - ./env/myapp.env
2.  在指定路径下创建一个文件（例如`myapp.env`），将要使用的环境变量写入文件中，格式为 `KEY=VALUE`：
    
        DB_HOST=localhost
        DB_PORT=3306
        DB_USER=root
        DB_PASSWORD=123456
3.  现在Docker容器启动时会从 `myapp.env` 文件中读取这些环境变量，并将它们传递给容器中的应用程序。

此外，它还可以使应用程序更加可移植，因为我们可以将环境变量文件与应用程序一起打包，而无需担心环境设置是否正确。

**environment-添加环境变量**

docker-compose配置文件中的environment指令用于设置容器的环境变量。其使用方式为在yml文件中定义一个键值对，其中键表示环境变量的名称，值表示环境变量的值。例如：

version: '3.7'
    services:
      web:
        image: r&management:v1
        environment:
          - APP_NAME=myapp
          - APP_ENV=production
          - JAR_NAME=management

这里的web服务的环境变量APP\_NAME的值为myapp，APP\_ENV的值为production，JAR\_NAME为我们后端运行的jar包名称。JAR\_NAME 是一种命名约定，用于将容器中的环境变量与容器内运行的 Java 应用程序中的变量相对应。

假设容器中运行的 Java 应用程序需要知道当前运行的 JAR 包的名称，可以通过读取环境变量 JAR\_NAME 来获取该名称。在 Dockerfile 中，可以通过设置 ENV JAR\_NAME=$\{JAR\_NAME\} 来将环境变量 JAR\_NAME 添加到镜像中。那么在 docker-compose.yml 文件中，可以通过设置 environment: JAR\_NAME=$\{JAR\_NAME\} 来将环境变量 JAR\_NAME 添加到容器中。

这样，在容器运行时，Java 应用程序就可以通过读取 JAR\_NAME 环境变量来获取当前运行的 JAR 包的名称，从而进行相关操作，比如打印日志、获取配置信息等。

除此以外，environment还有其他一些常见参数供配置：

1.  MYSQL\_ROOT\_PASSWORD：设置MySQL的root用户的密码；
2.  POSTGRES\_PASSWORD：设置PostgreSQL的密码；
3.  REDIS\_PASSWORD：设置Redis的密码；
4.  TZ：设置容器的时区；
5.  LANG：设置容器的语言环境；
6.  NODE\_ENV：设置Node.js的运行环境（如production、development等）；
7.  JAVA\_OPTS：设置Java应用程序的启动参数；
8.  SPRING\_PROFILES\_ACTIVE：设置Spring Boot应用程序的配置文件（如dev、prod等）；
9.  APP\_ENV：设置应用程序的运行环境（如local、uat、prod等）；
10. LOG\_LEVEL：设置应用程序的日志级别（如debug、info、warn等）等

环境变量可以用于配置容器在运行时的一些参数或选项。使用环境变量可以使容器的配置更加灵活和适应不同的场景。例如，使用环境变量可以配置数据库连接等敏感信息，而不用直接在容器配置中明文设置这些信息，增加了安全性。另外，使用环境变量也方便容器的迁移和部署。

**image-指定容器运行的镜像**

以下格式都可以：

image: redis
    image: ubuntu:14.04
    image: tutum/influxdb
    image: example-registry.com:4000/postgresql
    image: a4bc65fd # 镜像id

**logging-服务的日志记录配置**

用于配置容器的日志记录，可以定义容器日志的驱动程序、选项和特定目标的日志记录。其中driver可以指定服务容器的日志记录驱动程序，默认值为json-file。有以下三个选项

driver: "json-file"
    driver: "syslog"
    driver: "none"

仅在 json-file 驱动程序下，可以使用以下参数，限制日志得数量和大小。

logging:
      driver: json-file
      options:
        max-size: "200k" # 单个文件大小为200k
        max-file: "10" # 最多10个文件

当达到文件限制上限，会自动删除旧得文件。

syslog 驱动程序下，可以使用 syslog-address 指定日志接收地址。

logging:
      driver: syslog
      options:
        syslog-address: "tcp://192.168.10.142:80"

**network\_mode-设置网络模式**

可以定义一个新的网络或将容器连接到现有网络。

网络模式指定容器如何与主机和其他容器进行通信，它可以是以下值之一：

1.  bridge（默认）：使用Docker的默认网络模式，在容器内部创建一个虚拟接口，并且通过Docker守护程序自动为容器分配一个IP地址。如果在同一网段上有其他容器，可以使用容器名称进行通信。
2.  host：容器与主机共享网络栈，这意味着容器将获得主机的IP地址，可以直接访问主机的端口，但是容器与主机之间的隔离性将减少。
3.  none：容器不使用任何网络，这意味着容器不能通过网络与其他容器或主机通信。
4.  container：<name or id>：共享另一个容器的网络栈，容器将使用指定容器的网络命名空间，这意味着它们共享相同的IP地址和网络接口。

通过使用network\_mode关键字，可以为容器定义自定义网络设置，这允许更精细的网络配置和控制，以满足特定应用程序的需要。

network_mode: "bridge"
    network_mode: "host"
    network_mode: "none"
    network_mode: "service:[service name]"
    network_mode: "container:[container name/id]"

**aliases-服务别称**

同一网络上的其他容器可以使用服务名称或此别名来连接到对应容器的服务。

**restart-服务重启**

*  no：是默认的重启策略，在任何情况下都不会重启容器。
 *  always：容器总是重新启动。
 *  on-failure：在容器非正常退出时（退出状态非0），才会重启容器。
 *  unless-stopped：在容器退出时总是重启容器，但是不考虑在Docker守护进程启动时就已经停止了的容器

restart: "no"
    restart: always
    restart: on-failure
    restart: unless-stopped

注：swarm 集群模式，请改用 restart\_policy。

**expose-暴露端口**

用于指定容器的一个或多个端口，以便其他容器或主机可以访问该容器内部的应用程序。但不映射到宿主机，只被连接的服务访问。

仅可以指定内部端口为参数：

expose:
     - "3000"
     - "8000"

端口号可以是一个具体的数字，也可以是一个区间或者多个端口号组成的列表。我们可以在一个docker-compose.yml文件中定义多个服务，其中一个服务暴露出端口，其他服务可以通过网络访问该服务提供的服务。expose指令对于容器之间的通信很有用，可以让不同的服务能够相互通信，从而构建出更加复杂和灵活的应用程序。

**cap\_add，cap\_drop-增删主机内核**

添加或删除容器拥有的宿主机的内核功能。

cap_add:
      - ALL # 开启全部权限
    
    cap_drop:
      - SYS_PTRACE # 关闭 ptrace权限

**cgroup\_parent-指定容器父组**

为容器指定父 cgroup 组，意味着将继承该组的资源限制。

我们可以使用`cgroup_parent`命令来指定使用的cgroup父级。该命令用于在容器内使用特定的cgroup层次结构，以帮助对容器进行限制和管理。

使用方式如下所示：

version: '3.7'
    services:
      myservice:
        image: myimage:latest
        cgroup_parent: /my/cgroup/parent

此时`myservice`服务将使用`/my/cgroup/parent`作为其cgroup父级。

请注意，使用此命令需要在宿主机上安装使用cgroup层次结构的工具，例如systemd、cgroupfs或cgroup-tools。如果您希望在Docker Compose中使用cgroup父级，请确保在宿主机上正确安装所需的工具。

**command-覆盖容器启动**

覆盖容器启动的默认命令。

在docker-compose.yml文件中可以使用`command`属性来指定容器启动时要运行的命令。具体使用方式如下：

version: '3'
    services:
      myservice:
        image: myimage
        command: ["/bin/sh", "-c", "echo Hello, world!"]

上面的配置文件中，`myservice`服务的容器启动后会执行`echo Hello, world!`命令。可以使用`command`属性来指定任何需要在容器启动时运行的命令。它还支持从YAML文件定义的变量中使用命令。

version: '3'
    services:
      myservice:
        image: myimage
        environment:
          - MESSAGE=Hello, world!
        command: ["/bin/sh", "-c", "echo $MESSAGE"]

以上配置文件中，`myservice`服务的容器启动后会输出`Hello, world!`。在定义的环境变量`MESSAGE`中指定了要输出的消息。

如果要在`command`命令中使用环境变量，可以使用`$$`来转义：

version: '3'
    services:
      myservice:
        image: myimage
        environment:
          - MESSAGE=Hello, world!
        command: ["/bin/sh", "-c", "echo $$MESSAGE"]

以上配置文件中，`myservice`服务的容器启动后会输出`Hello, world!`。在`command`命令中使用`$$`来转义了环境变量`MESSAGE`。

**deploy-指定配置**

指定与服务的部署和运行有关的配置。只在 swarm 模式下才会有用。

version: "3.7"
    services:
      redis:
        image: redis:alpine
        deploy:
          mode：replicated
          replicas: 6
          endpoint_mode: dnsrr
          labels: 
            description: "This redis service label"
          resources:
            limits:
              cpus: '0.50'
              memory: 50M
            reservations:
              cpus: '0.25'
              memory: 20M
          restart_policy:
            condition: on-failure
            delay: 5s
            max_attempts: 3
            window: 120s

可以选参数：

**endpoint\_mode**：访问集群服务的方式。

endpoint_mode: vip 
    # Docker 集群服务一个对外的虚拟 ip。所有的请求都会通过这个虚拟 ip 到达集群服务内部的机器。
    endpoint_mode: dnsrr
    # DNS 轮询（DNSRR）。所有的请求会自动轮询获取到集群 ip 列表中的一个 ip 地址。

**labels**：在服务上设置标签。可以用容器上的 labels（跟 deploy 同级的配置） 覆盖 deploy 下的 labels。

**mode**：指定服务提供的模式。

*  **replicated**：复制服务，复制指定服务到集群的机器上。
 *  **global**：全局服务，服务将部署至集群的每个节点。
 *  图解：下图中黄色的方块是 replicated 模式的运行情况，灰色方块是 global 模式的运行情况。
    
    ![b54ca9a069c050ef52979c61c62ec61c.png][]

**replicas：mode** 为 replicated 时，需要使用此参数配置具体运行的节点数量。

**resources**：配置服务器资源使用的限制，例如上例子，配置 redis 集群运行需要的 cpu 的百分比 和 内存的占用。避免占用资源过高出现异常。

**restart\_policy**：配置如何在退出容器时重新启动容器。

*  condition：可选 none，on-failure 或者 any（默认值：any）。
 *  delay：设置多久之后重启（默认值：0）。
 *  max\_attempts：尝试重新启动容器的次数，超出次数，则不再尝试（默认值：一直重试）。
 *  window：设置容器重启超时时间（默认值：0）。

**rollback\_config**：配置在更新失败的情况下应如何回滚服务。

*  parallelism：一次要回滚的容器数。如果设置为0，则所有容器将同时回滚。
 *  delay：每个容器组回滚之间等待的时间（默认为0s）。
 *  failure\_action：如果回滚失败，该怎么办。其中一个 continue 或者 pause（默认pause）。
 *  monitor：每个容器更新后，持续观察是否失败了的时间 (ns|us|ms|s|m|h)（默认为0s）。
 *  max\_failure\_ratio：在回滚期间可以容忍的故障率（默认为0）。
 *  order：回滚期间的操作顺序。其中一个 stop-first（串行回滚），或者 start-first（并行回滚）（默认 stop-first ）。

**update\_config**：配置应如何更新服务，对于配置滚动更新很有用。

*  parallelism：一次更新的容器数。
 *  delay：在更新一组容器之间等待的时间。
 *  failure\_action：如果更新失败，该怎么办。其中一个 continue，rollback 或者pause （默认：pause）。
 *  monitor：每个容器更新后，持续观察是否失败了的时间 (ns|us|ms|s|m|h)（默认为0s）。
 *  max\_failure\_ratio：在更新过程中可以容忍的故障率。
 *  order：回滚期间的操作顺序。其中一个 stop-first（串行回滚），或者 start-first（并行回滚）（默认stop-first）。

**注**：仅支持 V3.4 及更高版本。

**devices-指定设备映射列表**

Docker Compose的yml配置文件中devices指令用于将宿主机设备映射到Docker容器中，以便容器中的应用程序可以使用宿主机设备。设备可以是任何类型的设备，包括串口、USB设备、摄像头等。

以下是一个使用devices指令的例子：

version: "3.7"
    services:
      app:
        image: myapp
        devices:
          - /dev/ttyUSB0:/dev/ttyUSB0

这里将/dev/ttyUSB0设备映射到容器中的/dev/ttyUSB0路径。这使得容器中运行的应用程序可以使用宿主机上的/dev/ttyUSB0设备。

一般情况下devices指令主要应用于：

1.  在容器中运行需要访问宿主机设备的应用程序，例如串口通信应用程序、打印机驱动程序等。
2.  在容器中运行需要访问宿主机摄像头的应用程序，例如视频采集应用程序、监控应用程序等。

需要注意的是：使用devices指令会使容器对宿主机的设备具有访问权限，因此需要特别小心使用，以免造成安全隐患。

**dns-自定义 DNS 服务器**

可以是单个值或列表的多个值。

dns: 8.8.8.8
    
    dns:
      - 8.8.8.8
      - 9.9.9.9

**dns\_search-自定义 DNS 搜索域**

可以是单个值或列表。

dns_search:
      - dc1.aliyun.com
      - dc2.aliyun.com

####  ####

**extra\_hosts-添加主机名映射**

类似 docker client --add-host。

extra_hosts:
     - "somehost:162.242.195.82"
     - "otherhost:50.31.209.229"

以上会在此服务的内部容器中 /etc/hosts 创建一个具有 ip 地址和主机名的映射关系：

162.242.195.82  somehost
    50.31.209.229   otherhost

**healthcheck-健康检测**

用于检测 docker 服务是否健康运行。

healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost"] # 设置检测程序
      interval: 30s # 设置检测间隔
      timeout: 10s # 设置检测超时时间
      retries: 3 # 设置重试次数
      start_period: 40s # 启动后，多少秒开始启动检测程序

**secrets-存储敏感数据**

例如密码：

version: "3.1"
    services:
    
    mysql:
      image: mysql
      environment:
        MYSQL_ROOT_PASSWORD_FILE: /run/secrets/my_secret
      secrets:
        - my_secret
    
    secrets:
      my_secret:
        file: ./my_secret.txt

**security\_opt-修改容器默认的 schema 标签**

security-opt：
      - label:user:USER   # 设置容器的用户标签
      - label:role:ROLE   # 设置容器的角色标签
      - label:type:TYPE   # 设置容器的安全策略标签
      - label:level:LEVEL  # 设置容器的安全等级标签

**stop\_grace\_period-设置容器停止前的等待时间**

它通常与 stop\_timeout 配置项一起使用，用于确保容器在停止之前有足够的时间完成它们的工作。

stop\_grace\_period 的默认值为 10 秒。如果需要更长的时间来停止容器，可以在 compose 文件中指定一个不同的值。例如：

services:
      myservice:
        image: myimage
        stop_grace_period: 30s
        stop_timeout: 60s

在上述示例中，myservice 服务的容器将在停止之前等待 30 秒。如果容器在 60 秒内仍然未停止，则强制停止容器。

请注意，stop\_grace\_period 和 stop\_timeout 的值应该相互配合，以确保容器能够正常停止，但不会持续进行无限期等待。

**sysctls-设置容器中的内核参数**

可以使用数组或字典格式。

sysctls:
      net.core.somaxconn: 1024
      net.ipv4.tcp_syncookies: 0
    
    sysctls:
      - net.core.somaxconn=1024
      - net.ipv4.tcp_syncookies=0

**tmpfs-在容器内安装一个临时文件系统**

`tmpfs`选项主要是来为容器的某些目录或文件系统添加一个临时文件系统。这个临时文件系统会被放置在主机的内存中，直到容器被终止。

下面是一个使用`tmpfs`选项的示例：

version: '3.7'
    services:
      myservice:
        image: someimage
        tmpfs:
        - /tmp

这个配置会为`myservice`容器的`/tmp`目录添加一个临时文件系统。这个临时文件系统将会被放置在主机的内存中，并且在容器被终止时被清除。

当使用`tmpfs`选项时，可以使用以下属性：

*  `size`: 用来限制tmpfs文件系统的大小，如果不指定则默认会占用系统内存的一半；
 *  `mode`: 定义tmpfs文件系统的权限模式。

注意，使用`tmpfs`选项时，容器必须运行在特权模式下，否则它将无法创建临时文件系统。

`tmpfs`选项在以下场景下特别有用：

*  临时文件：如缓存、日志等；
 *  敏感数据：如密码、密钥等，使用临时文件系统可以防止数据被写入磁盘；
 *  高性能应用：使用临时文件系统可以避免磁盘I/O的性能瓶颈。

`tmpfs`选项是Docker Compose中一个强大和灵活的工具，可以为容器提供可靠的临时文件系统和更好的性能。

**ulimits-设置容器内部进程的资源限制的参数**

ulimits主要有以下几个参数：

*  nofile：表示每个进程能够打开的文件句柄的最大数量。
 *  nproc：表示进程数量的最大值。
 *  memlock：表示每个进程能够锁住的内存的最大数量。
 *  cpu：表示CPU时间使用的限制。

在docker-compose.yml文件中，ulimits的配置方式如下：

services:
      myservice:
        image: myimage:latest
        ulimits:
          nofile:
            soft: 65535
            hard: 65535

上述配置表示设置容器内部进程的nofile参数的软限制和硬限制都为65535。

注意：ulimits只能在Linux主机上使用，因为Windows和macOS不支持对进程资源的限制。

其他指令就不一一列举了，有需要可自行查找用法~

## 六，Docker-Compose在项目部署中的实际应用 ##

当有了docker-compose后，部署相对复杂的项目时就不用一个个镜像拉取，运行了，非常节约时间，只要配置一个docker-compose的yml文件，在其中配置需要运行的服务信息即可：

version: "3.6"
    services:
      #后端服务start
      goods-start:
        #定义容器名
        container_name: goods-start
        restart: always
        #使用的镜像
        image: goods-start
        hostname: goods-start
        #定义网络模式
        network_mode: "host"
        #配置环境
        environment:
        #运行时区
          - TZ=Asia/Shanghai
          - JAR_NAME=goods-start #指定的jar包名称
          - SPRING_PROFILES_ACTIVE=editionlocal #项目maven环境
          - MYSQL_USERNAME=root
          - MYSQL_PASSWD=123456
          - JAVA_OPTS=-server -Xms4112m -Xmx4112m -XX:+UnlockExperimentalVMOptions -XX:+UseCGroupMemoryLimitForHeap -XX:PermSize=512m -XX:MaxPermSize=512m #java运行配置
       #容器卷挂载
        volumes:
          - /opt/start:/usr/local
        deploy:
          resources:
            limits:
              memory: 4G
            reservations:
              memory: 512M   
      #后端服务customer
      goods-customer:
        container_name: goods-customer
        restart: always
        image: goods-customer:v1
        network_mode: "host"
        environment:
          - TZ=Asia/Shanghai
          - JAR_NAME=goods-customer
          - SPRING_PROFILES_ACTIVE=editionlocal
          - MYSQL_USERNAME=root
          - MYSQL_PASSWD=123456
          - JAVA_OPTS=-server -Xms4112m -Xmx4112m -XX:+UnlockExperimentalVMOptions -XX:+UseCGroupMemoryLimitForHeap -XX:PermSize=512m -XX:MaxPermSize=512m
        volumes:
          - /opt/customer:/usr/local
        deploy:
          resources:
            limits:
              memory: 2G
            reservations:
              memory: 512M 
      #后端服务easy-design 
      easy-design:
        container_name: easy-design
        restart: always
        image: easy-design:v1
        network_mode: "host"
        environment:
          - TZ=Asia/Shanghai
          - JAR_NAME=easy-design
          - SPRING_PROFILES_ACTIVE=editionlocal
          - MYSQL_USERNAME=root
          - MYSQL_PASSWD=123456
        volumes:
          - /opt/easy-design:/usr/local
      #nginx服务
      nginx:
        container_name: nginx
        restart: always
        image: nginx
        network_mode: "host"
        volumes:
          - /opt/nginx/conf.d:/etc/nginx/conf.d
          - /opt/nginx/html:/usr/share/nginx/html
      mysql:
        container_name: mysql
        restart: always
        image: mysql
        hostname: mysql
        network_mode: "host"
        environment:
          - TZ=Asia/Shanghai
          - MYSQL_ROOT_PASSWORD=123456
          - MYSQL_USER=root
          - MYSQL_PASSWORD=123456
          - MYSQL_DATABASE=goods_center
        volumes:
          - /opt/mysql/data:/var/lib/mysql
          - /opt/mysql/my.cnf:/etc/mysql/my.cnf
      #redis服务
      redis:
        container_name: redis
        restart: always  
        image: redis
        network_mode: "host"
        command: redis-server --requirepass 123456

这里以笔者部署的一个简单项目为例，后端需要事先准备已通过dockerfile打包的镜像，其他nginx、mysql、redis等服务在docker-compose配置镜像时就会自行下载并根据配置信息运行。这样配置完成后直接用docker-compose运行即可启动所有服务：

[root@localhost ~]# docker-compose -f /opt/docker-compose.yml up -d
    Creating nginx             ... done
    Creating mysql             ... done
    Creating easy-design       ... done
    Creating start             ... done
    Creating redis             ... done
    Creating customer          ... done

如果需要暂停使用部署服务也可以一条命令控制所有服务：

[root@localhost ~]# docker-compose -f /opt/docker-compose.yml down
    Stopping customer         ... done
    Stopping redis            ... done
    Stopping easy-design      ... done
    Stopping mysql            ... done
    Stopping start            ... done
    Stopping nginx            ... done
    Removing customer         ... done
    Removing redis            ... done
    Removing easy-design      ... done
    Removing mysql            ... done
    Removing start            ... done
    Removing nginx            ... done

## 七，总结 ##

不难看出，相对于单独使用Docker，Docker Compose有以下几个明显优点：

1.  简化部署: Docker Compose可以一次性启动多个容器，并按照一定的顺序和方式组织这些容器之间的关系，从而方便了整个应用的部署。常见的例子包括LAMP（Linux + Apache + MySQL + PHP）和MEAN（MongoDB + Express + AngularJS + Node.js）等。
2.  简化配置: Docker Compose通过一个YAML文件，集中定义容器的各项配置信息，比如容器的镜像、端口映射、环境变量、数据卷、域名等，从而简化了手动配置的过程。
3.  增强互操作性: Docker Compose不仅支持Docker容器，也能够集成其他容器技术，例如Kubernetes，使得容器集群的管理更加方便。
4.  提高可维护性: Docker Compose可以通过docker-compose命令管理容器的启动、停止、重启和查看日志等操作，从而提高了容器集群的可维护性。

综上所述，Docker Compose提供了一个更加高效、可靠和易于部署的容器集群解决方案，相对于单独使用Docker更加灵活和实用。

[https_github.com_docker_compose_releases]: https://github.com/docker/compose/releases
[b54ca9a069c050ef52979c61c62ec61c.png]: https://img-blog.csdnimg.cn/img_convert/b54ca9a069c050ef52979c61c62ec61c.png