【云原生|Docker】13-Docker-compose详解-Toy模板网

这篇具有很好参考价值的文章主要介绍了【云原生|Docker】13-Docker-compose详解。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

【云原生Docker】13-Docker-compose详解

前言

前面我们在说Dokcer Harbor企业级仓库管理的时候，我们使用的就是docker-compose来启动相应的容器的，Docker-compose作为一款单机编排工具在工作中使用的还是非常多的；这一章我们将一起探讨下docker-compose的使用。

docker-compose简介

Docker Compose是一个定义和运行多容器应用的单机编排工具。通过Docker Compose你可以使用一个单一的YAML文件来配置多个应用服务，通过一条命令，就可以将所有配置的服务全部启动起来。

使用Docker Compose的三个步骤：

使用Dockerfile定义环境，这样可以确保其在任意地方运行
使用docker-compose.yml文件定义服务，这样它们就可以在独立环境中一起运行
运行docker-compose up使用docker-compose启动所有应用

Docker Compose可以管理应用的整个生命周期：

启动、停止、重建服务
查看服务的运行状态
流式输出服务日志
对服务执行一次性命令

docker-compose安装

下载地址：

docker-comose官方下载：https://github.com/docker/compose/releases

选择适应的版本：

[root@xhz ~]#wget https://github.com/docker/compose/releases/download/v2.17.1/docker-compose-linux-x86_64  -O  /usr/local/bin/docker-compose
[root@xhz ~]#
[root@xhz ~]#chmod u+x  /usr/local/bin/docker-compose

docker-compose就是一个二进制的可执行文件，添加权限之后可直接使用docker-compse的相关命令

查看docker-compose的相关版本

[root@xhz ~]# docker-compose version
Docker Compose version v2.17.1
[root@xhz ~]#

docker-compose基本示例

本示例将通过构建一个自定义的nginx容器，将nginx容器的80端口映射到本地的80，同时也创建一个httpd的容器，将httpd的80端口映射到本地的8080，当访问本地的80端口（即nginx容器）的时候，将被反向代理到httpd容器中，（本示例只是单纯的演示，无实际用途）

创建docker-compose的基本目录

[root@xhz ~]#mkdir composetest
[root@xhz ~]#cd composetest
[root@xhz ~]# tree compose_test/
compose_test/
├── docker-compose.yml
├── Dockerfile
└── file
    ├── default.conf
    └── index.html

1 directory, 4 files
[root@xhz ~]#

创建一个Dockerfile，用于自定义nginx

[root@xhz compose_test]# cat Dockerfile
FROM nginx:latest
ADD file/default.conf  /etc/nginx/conf.d
ADD file/index.html  /usr/share/nginx/html/
ARG name
EXPOSE 80/tcp
CMD ["nginx", "-g", "daemon off;"]
[root@xhz compose_test]#

file/default.conf 定义nginx的配置文件

通过docker-compose.yml文件定义服务

[root@xhz compose_test]# cat docker-compose.yml
version: '3'
services:
  web:
    container_name: nginx_proxy
    build:
      context: /root/compose_test
      dockerfile: Dockerfile
    ports:
     - "80:80"
    depends_on:
      - httpd
    volumes:
      - /etc/localtime:/etc/localtime
      - /data/xhz:/usr/share/nginx/html/xhz

  httpd:
    image: httpd
    container_name: apache2_test
    ports:
      - "8080:80"
    volumes:
      - /etc/localtime:/etc/localtime
[root@xhz compose_test]#
[root@xhz compose_test]#

这里定义了两个服务：nginx和httpd

nginx服务使用当前目录的Dockerfile进行构建，并且映射nginx服务的80端口到宿主机80端口。

httpd服务使用的是公共的httpd镜像，并且映射httpd服务的80端口到宿主机8080端口。

在这个示例中，Nginx 将请求代理到名为 httpd 的 Docker 容器上，该容器监听端口 80。请注意，proxy_pass 指令的参数应该是 Docker Compose 文件中服务名称，而不是容器 ID 或 IP 地址。

通过docker-compose构建服务

[root@xhz compose_test]# docker-compose up
[+] Building 0.2s (8/8) FINISHED
 => [internal] load build definition from Dockerfile                                                                      0.0s
 => => transferring dockerfile: 260B                                                                                      0.0s
 => [internal] load .dockerignore                                                                                         0.0s
 => => transferring context: 2B                                                                                           0.0s
 => [internal] load metadata for docker.io/library/nginx:latest                                                           0.0s
 => CACHED [1/3] FROM docker.io/library/nginx:latest                                                                      0.0s
 => [internal] load build context                                                                                         0.0s
 => => transferring context: 493B                                                                                         0.0s
 => [2/3] ADD file/default.conf  /etc/nginx/conf.d                                                                        0.1s
 => [3/3] ADD file/index.html  /usr/share/nginx/html/                                                                     0.0s
 => exporting to image                                                                                                    0.0s
 => => exporting layers                                                                                                   0.0s
 => => writing image sha256:db1f287bb4f108f7322d05ae6b78a379e9536ee62bacc48a9555264b5d7c0561                              0.0s
 => => naming to docker.io/library/compose_test-web                                                                       0.0s
[+] Running 2/2
 ✔ Container apache2_test  Started                                                                                        0.5s
 ✔ Container nginx_proxy   Started                                                                                        0.9s
[root@xhz compose_test]#

访问服务

此时可以通过80端口访问到http容器

[root@xhz compose_test]# curl http://127.0.0.1
<html><body><h1>It works!</h1></body></html>
[root@xhz compose_test]#
[root@xhz compose_test]#
[root@xhz compose_test]# curl http://127.0.0.1:8080
<html><body><h1>It works!</h1></body></html>
[root@xhz compose_test]#

Docker Compose常用命令说明

后台启动

在上面的一个简单示例中，我们已经使用了docker-compose up来启动一个docker-compose.yml文件定义的服务。我们刚刚通过docker-compose up虽然启动了服务，当是docker-compose指令却在前台执行，如果需要将其放入后台运行，可以使用-d参数：
docker-compose up -d

–scale参数实现服务的扩缩容

docker-compose up -d --scale nginx=2
需要说明的是，如果使用自动扩容，则nginx服务不能做端口映射，否则会出现端口冲突的情况

-f选项指定compose文件

docker-compose -f test-compose.yml up -d

build镜像构建

默认情况下，我们写好了Dockerfile，第一次通过docker-compose启动的时候，会自动完成构建，但如果随后Dockerfile发生了改动，再次通过docker-compose来启动实现更新的话，docker-compose不会再次自动构建镜像，而是复用第一次生成的镜像，如果希望镜像能够被重新构建，需要单独执行docker-compose build

其他参数

参数	说明
docker-compose up	启动应用程序的服务，可以使用 `-d` 参数在后台运行服务。
docker-compose down	停止应用程序的服务，可以使用 `--volumes` 参数删除容器相关的数据卷。
docker-compose start	启动应用程序的服务;
docker-compose stop	停止应用程序的服务;
docker-compose restart	重启应用程序的服务;
docker-compose pause	暂停应用程序的服务。
docker-compose unpause	恢复应用程序的服务。
docker-compose ps	列出应用程序的服务及其状态。
docker-compose rm	通过这种方式也能删除指定服务，但不会删除网络和volumes
docker-compose kill	强制杀死一个服务
docker-compose logs	用于查看日志

Docker Compose文件详解

通过之前的示例，其实我们可以看到，所有服务的管理，都是依靠docker-compose.yml文件来实现的。那么我们接下来就详细说一说docker-compose.yml文件中的常用指令。

compose文件使用yml格式，docker规定了一些指令，使用它们可以去设置对应的东西，主要分为了四个区域：

version：用于指定当前docker-compose.yml语法遵循哪个版本

services：服务，在它下面可以定义应用需要的一些服务，每个服务都有自己的名字、使用的镜像、挂载的数据卷、所属的网络、依赖哪些其他服务等等。

networks：应用的网络，在它下面可以定义应用的名字、使用的网络类型等。

volumes：数据卷，在它下面可以定义数据卷，然后挂载到不同的服务下去使用。

version

用于指定当前compose文件语法遵循哪个版本，下面这张表是不同的Compose文件版本兼容的Docker版本：

【云原生|Docker】13-Docker-compose详解

service

我们上面所说的所有服务的定义都是定义在services区域中，接下来，我们学习下services下常用的配置项:

image

标明image的ID或名称，这个image ID可以是本地也可以是远程的，如果本地不存在，compose会尝试pull下来

image: ubuntu
image: hub.dz11.com/library/tomcat:8

build

该参数指定Dockerfile文件的路径，compose会通过Dockerfile构建并生成镜像，然后使用该镜像

context：构建上下文，可以是一个包含 Dockerfile 文件的目录，也可以是一个包含 Dockerfile 文件的 Git 仓库地址；

dockerfile：指定 Dockerfile 文件的名称，默认为 Dockerfile；

args：传递构建参数给 Dockerfile，可以在 Dockerfile 中使用 ${key} 的形式引用这些参数。

version: "3.9"
services:
  webapp:
    build:
      context: .
      dockerfile: Dockerfile-alternate
      args:
        buildno: 1

command

重写默认的命令，或者说指定启动容器的命令;

services:
  <service_name>:
    command:  ["nginx", "-g", "daemon off;"]

links

links 关键字用于定义容器间的链接关系。通过在 docker-compose.yml 文件中使用 links 关键字，可以告诉 Docker Compose 启动一个服务时需要链接到其他服务

需要注意的是，links 关键字已经被废弃，推荐使用 networks 关键字来定义服务之间的连接，或者使用 depends_on 来定义服务之间的依赖关系。

services:
  app:
    links:
      - db:mysql
    
#上述示例中，app 是服务的名称，links 指定了要链接到 db 服务，并将其别名设置为 mysql。

external_links

external_links 关键字用于定义容器与外部服务的链接关系。通过在 docker-compose.yml 文件中使用 external_links 关键字，可以告诉 Docker Compose 启动一个服务时需要链接到外部的服务。

需要注意的是，external_links 关键字已经被废弃，推荐使用 networks 关键字来定义服务之间的连接，或者使用 depends_on 来定义服务之间的依赖关系。

services:
  app:
    external_links:
      - db:mysql
      
#需要注意的是，external_links 关键字已经被废弃，推荐使用 networks 关键字来定义服务之间的连接，或者使用 depends_on 来定义服务之间的依赖关系。

ports

ports 关键字用于将容器中的端口映射到主机上。通过在 docker-compose.yml 文件中使用 ports 关键字，可以定义容器内部的端口号，并将其映射到主机上的端口号。

services:
  app:
    ports:
      - "8080:80"
##上述示例中，app 是服务的名称，ports 指定了将容器内部的 80 端口映射到主机上的 8080 端口。

services:
  app:
    ports:
      - "80"
## 上述示例中，app 是服务的名称，ports 指定了将容器内部的 80 端口映射到主机上的随机端口。

services:
  app:
    ports:
      - "8080:80"
      - "8443:443"
## 上述示例中，app 是服务的名称，ports 指定了将容器内部的 80 端口映射到主机上的 8080 端口，以及将容器内部的 443 端口映射到主机上的 8443 端口。

expose

xpose 关键字用于暴露容器内部的端口，但不将其映射到主机上。通过在 docker-compose.yml 文件中使用 expose 关键字，可以告诉 Docker Compose 暴露容器内部的端口，以便其他容器可以访问该端口。

services:
  app:
    expose:
      - 80

##上述示例中，app 是服务的名称，expose 指定了将容器内部的 80 端口暴露出来，以便其他容器可以访问该端口。

## 需要注意的是，expose 关键字只是用来声明容器内部的端口，不会将其映射到主机上。如果要将容器内部的端口映射到主机上，可以使用 ports 关键字。

environment

environment 关键字用于设置容器中的环境变量。通过在 docker-compose.yml 文件中使用 environment 关键字，可以告诉 Docker Compose 在容器中设置指定的环境变量。

services:
  db:
    environment:
      - MYSQL_ROOT_PASSWORD=secret
      - MYSQL_DATABASE=mydb
      - MYSQL_USER=user
      - MYSQL_PASSWORD=password
## 上述示例中，db 是服务的名称，environment 指定了在容器中设置 MYSQL_ROOT_PASSWORD、MYSQL_DATABASE、MYSQL_USER 和 MYSQL_PASSWORD 四个环境变量。

如果要引用其他服务的环境变量，可以使用以下格式:文章来源地址https://www.toymoban.com/news/detail-416066.html

services:
  app:
    environment:
      - DB_HOST=${db_HOST}
  db:
    environment:
      - HOST=db
## 上述示例中，app 服务的环境变量 DB_HOST 引用了 db 服务的环境变量 HOST。

env_file

nv_file 关键字用于从文件中加载环境变量。通过在 docker-compose.yml 文件中使用 env_file 关键字，可以告诉 Docker Compose 从指定的文件中加载环境变量。

services:
  app:
    env_file:
      - ./env/app.env

#上述示例中，app 是服务的名称，env_file 指定了从 ./env/app.env 文件中加载环境变量。
需要注意的是，每行文件中的环境变量应该以 key=value 的形式进行定义，例如：

DB_HOST=db
DB_USER=user
DB_PASSWORD=password

可以使用多个 .env 文件来设置环境变量，这些文件会在指定的顺序中进行加载。如果有多个文件中定义了相同的环境变量，则后加载的文件中的定义会覆盖前面的定义。

depends_on

epends_on 关键字用于定义服务之间的依赖关系。通过在 docker-compose.yml 文件中使用 depends_on 关键字，可以告诉 Docker Compose 在启动服务时应该先启动哪些服务。

services:
  app:
    depends_on:
      - db
上述示例中，app 是服务的名称，depends_on 指定了该服务依赖 db 服务，即在启动 app 服务之前，需要先启动 db 服务。

需要注意的是，depends_on 关键字只是指定了服务之间的启动顺序，并不能保证依赖的服务已经完全启动。

deploy

deploy 关键字用于定义在 Docker Swarm 环境下部署服务时的相关配置。通过在 docker-compose.yml 文件中使用 deploy 关键字，可以告诉 Docker Swarm 在部署服务时应该如何配置。

需要注意的是，deploy 关键字只在 Docker Swarm 环境下生效，如果在普通的 Docker 环境下使用，会被忽略。

services:
  app:
    deploy:
      mode: replicated
      replicas: 3
      placement:
        constraints: [node.role == worker]
      resources:
        limits:
          cpus: '0.5'
          memory: 512M
      restart_policy:
        condition: on-failure
      update_config:
        parallelism: 2
        delay: 10s
      rollback_config:
        parallelism: 1
        delay: 0s
上述示例中，app 是服务的名称，deploy 指定了部署模式为 replicated，副本数为 3，部署位置为 worker 节点，资源限制为 0.5 CPU 和 512MB 内存，重启策略为在失败时重启，更新配置为同时更新 2 个节点，延迟 10 秒，回滚配置为同时回滚 1 个节点，无延迟。

healthcheck

healthcheck 关键字用于定义服务的健康检查。通过在 docker-compose.yml 文件中使用 healthcheck 关键字，可以告诉 Docker Compose 如何检查服务的健康状态，并在服务不健康时进行相应的处理。

services:
  app:
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
      interval: 30s
      timeout: 10s
      retries: 3
上述示例中，app 是服务的名称，healthcheck 指定了检查命令为使用 curl 访问 http://localhost:8080/health，检查间隔时间为 30 秒，超时时间为 10 秒，重试次数为 3 次。

需要注意的是，healthcheck 关键字只是定义了服务的健康检查方式，不会自动修复服务的不健康状态。如果服务不健康，需要手动进行相应的处理，例如重启服务、替换服务等。可以通过restart关键字设置restart自动重启

network_mode

network_mode 关键字用于指定服务的网络模式。通过在 docker-compose.yml 文件中使用 network_mode 关键字，可以告诉 Docker Compose 该服务应该使用哪种网络模式与其他服务通信。

网络模式可以是以下几种：

bridge：使用 Docker 默认的桥接网络模式。

host：使用主机网络模式，即与主机共享网络栈。

none：不使用网络。

<network_name>：使用指定的网络名称。

如果使用自定义的网络连接，则需要通过networks关键字来创建自定义的网络

services:
  app:
    network_mode: bridge
上述示例中，app 是服务的名称，network_mode 指定了使用 Docker 默认的桥接网络模式。

需要注意的是，如果指定了 network_mode 关键字，那么该服务将不会自动加入到 Docker Compose 创建的默认网络中，需要手动将该服务加入到指定的网络中。

除了 network_mode 关键字外，还可以使用 networks 关键字来指定服务使用的网络

dns

dns 关键字用于指定服务使用的 DNS 服务器。通过在 docker-compose.yml 文件中使用 dns 关键字，可以告诉 Docker Compose 该服务应该使用哪个 DNS 服务器进行域名解析。

services:
  app:
    dns:
      - 8.8.8.8
      - 8.8.4.4
上述示例中，app 是服务的名称，dns 指定了使用 Google 的 DNS 服务器进行域名解析。

需要注意的是，如果使用自定义的 DNS 服务器，需要确保该服务器能够正常解析所需的域名。

restart

restart 关键字用于指定容器的重启策略。通过在 docker-compose.yml 文件中使用 restart 关键字，可以告诉 Docker Compose 容器在崩溃或退出时应该如何重启。

重启策略，可以是以下几种：

no：不重启容器。

always：容器总是重启。

on-failure：只有在容器非正常退出时才重启，例如退出代码不为 0。

unless-stopped：除非手动停止容器，否则总是重启容器。

services:
  app:
    image: my_image
    restart: always
上述示例中，app 服务使用镜像 my_image，并指定了重启策略为总是重启。

需要注意的是，如果使用 on-failure 策略，可以使用 restart 关键字的 max-retries 参数指定容器重启的最大次数，例如：

services:
  app:
    image: my_image
    restart:
      on-failure
      max-retries: 3
上述示例中，app 服务使用镜像 my_image，并指定了重启策略为只有在容器非正常退出时才重启，最多重启 3 次。

networks

networks 关键字用于定义网络。通过在 docker-compose.yml 文件中使用 networks 关键字，可以告诉 Docker Compose 创建一个或多个自定义网络，以便服务之间进行通信。

网络的配置包括以下参数：

driver：网络的驱动程序，默认为 bridge。

ipam：IP 地址管理器，用于管理网络中的 IP 地址。

external：是否使用外部网络，如果为 true，则使用外部网络，不创建新的网络。

networks:
  my_network:
    driver: bridge
    ipam:
      driver: default
      config:
        - subnet: "172.28.0.0/16"
上述示例中，定义了名为 my_network 的网络，使用默认的桥接驱动程序，使用默认的 IP 地址管理器，并指定了一个 IP 地址子网。

需要注意的是，如果服务需要使用自定义网络，需要在 services 关键字中为服务指定所需的网络，例如：

services:
  app:
    image: my_image
    networks:
      - my_network
上述示例中，app 服务使用镜像 my_image，并加入到 my_network 网络中。

volumes

olumes 关键字用于定义数据卷。通过在 docker-compose.yml 文件中使用 volumes 关键字，可以告诉 Docker Compose 创建一个或多个数据卷，以便在容器之间共享数据。

数据卷的配置包括以下参数：

driver：数据卷的驱动程序，默认为 local。

driver_opts：驱动程序的选项。

external：是否使用外部数据卷，如果为 true，则使用外部数据卷，不创建新的数据卷。

volumes:
  my_volume:
    driver: local
    driver_opts:
      type: "nfs"
      o: "addr=192.168.1.100,nolock,soft,rw"
      device: ":/path/to/volume"
上述示例中，定义了名为 my_volume 的数据卷，使用 local 驱动程序，并指定了驱动程序选项，使用 nfs 文件系统类型，并指定了远程 NFS 服务器的 IP 地址和共享路径。

需要注意的是，如果服务需要使用数据卷，需要在 services 关键字中为服务指定所需的数据卷，例如：

services:
  app:
    image: my_image
    volumes:
      - my_volume:/path/to/mount
上述示例中，app 服务使用镜像 my_image，并挂载名为 my_volume 的数据卷到容器中的 /path/to/mount 目录。

Dokcer-compose案例实践示例

部署harbor

[root@xhz harbor]# cat docker-compose.yml
version: '2.3'
services:
  log:
    image: goharbor/harbor-log:v1.10.17
    container_name: harbor-log
    restart: always
    dns_search: .
    cap_drop:
      - ALL
    cap_add:
      - CHOWN
      - DAC_OVERRIDE
      - SETGID
      - SETUID
    volumes:
      - /var/log/harbor/:/var/log/docker/:z
      - type: bind
        source: ./common/config/log/logrotate.conf
        target: /etc/logrotate.d/logrotate.conf
      - type: bind
        source: ./common/config/log/rsyslog_docker.conf
        target: /etc/rsyslog.d/rsyslog_docker.conf
    ports:
      - 127.0.0.1:1514:10514
    networks:
      - harbor
  registry:
    image: goharbor/registry-photon:v1.10.17
    container_name: registry
    restart: always
    cap_drop:
      - ALL
    cap_add:
      - CHOWN
      - SETGID
      - SETUID
    volumes:
      - /data/registry:/storage:z
      - ./common/config/registry/:/etc/registry/:z
      - type: bind
        source: /data/secret/registry/root.crt
        target: /etc/registry/root.crt
    networks:
      - harbor
    dns_search: .
    depends_on:
      - log
    logging:
      driver: "syslog"
      options:
        syslog-address: "tcp://127.0.0.1:1514"
        tag: "registry"
  registryctl:
    image: goharbor/harbor-registryctl:v1.10.17
    container_name: registryctl
    env_file:
      - ./common/config/registryctl/env
    restart: always
    cap_drop:
      - ALL
    cap_add:
      - CHOWN
      - SETGID
      - SETUID
    volumes:
      - /data/registry:/storage:z
      - ./common/config/registry/:/etc/registry/:z
      - type: bind
        source: ./common/config/registryctl/config.yml
        target: /etc/registryctl/config.yml
    networks:
      - harbor
    dns_search: .
    depends_on:
      - log
    logging:
      driver: "syslog"
      options:
        syslog-address: "tcp://127.0.0.1:1514"
        tag: "registryctl"
  postgresql:
    image: goharbor/harbor-db:v1.10.17
    container_name: harbor-db
    restart: always
    cap_drop:
      - ALL
    cap_add:
      - CHOWN
      - DAC_OVERRIDE
      - SETGID
      - SETUID
    volumes:
      - /data/database:/var/lib/postgresql/data:z
    networks:
      harbor:
    dns_search: .
    env_file:
      - ./common/config/db/env
    depends_on:
      - log
    logging:
      driver: "syslog"
      options:
        syslog-address: "tcp://127.0.0.1:1514"
        tag: "postgresql"
  core:
    image: goharbor/harbor-core:v1.10.17
    container_name: harbor-core
    env_file:
      - ./common/config/core/env
    restart: always
    cap_drop:
      - ALL
    cap_add:
      - SETGID
      - SETUID
    volumes:
      - /data/ca_download/:/etc/core/ca/:z
      - /data/psc/:/etc/core/token/:z
      - /data/:/data/:z
      - ./common/config/core/certificates/:/etc/core/certificates/:z
      - type: bind
        source: ./common/config/core/app.conf
        target: /etc/core/app.conf
      - type: bind
        source: /data/secret/core/private_key.pem
        target: /etc/core/private_key.pem
      - type: bind
        source: /data/secret/keys/secretkey
        target: /etc/core/key
    networks:
      harbor:
    dns_search: .
    depends_on:
      - log
      - registry
      - redis
      - postgresql
    logging:
      driver: "syslog"
      options:
        syslog-address: "tcp://127.0.0.1:1514"
        tag: "core"
  portal:
    image: goharbor/harbor-portal:v1.10.17
    container_name: harbor-portal
    restart: always
    cap_drop:
      - ALL
    cap_add:
      - CHOWN
      - SETGID
      - SETUID
      - NET_BIND_SERVICE
    networks:
      - harbor
    dns_search: .
    depends_on:
      - log
    logging:
      driver: "syslog"
      options:
        syslog-address: "tcp://127.0.0.1:1514"
        tag: "portal"

  jobservice:
    image: goharbor/harbor-jobservice:v1.10.17
    container_name: harbor-jobservice
    env_file:
      - ./common/config/jobservice/env
    restart: always
    cap_drop:
      - ALL
    cap_add:
      - CHOWN
      - SETGID
      - SETUID
    volumes:
      - /data/job_logs:/var/log/jobs:z
      - type: bind
        source: ./common/config/jobservice/config.yml
        target: /etc/jobservice/config.yml
    networks:
      - harbor
    dns_search: .
    depends_on:
      - core
    logging:
      driver: "syslog"
      options:
        syslog-address: "tcp://127.0.0.1:1514"
        tag: "jobservice"
  redis:
    image: goharbor/redis-photon:v1.10.17
    container_name: redis
    restart: always
    cap_drop:
      - ALL
    cap_add:
      - CHOWN
      - SETGID
      - SETUID
    volumes:
      - /data/redis:/var/lib/redis
    networks:
      harbor:
    dns_search: .
    depends_on:
      - log
    logging:
      driver: "syslog"
      options:
        syslog-address: "tcp://127.0.0.1:1514"
        tag: "redis"
  proxy:
    image: goharbor/nginx-photon:v1.10.17
    container_name: nginx
    restart: always
    cap_drop:
      - ALL
      cap_add:
        - CHOWN
        - SETGID
        - SETUID
      - NET_BIND_SERVICE
    volumes:
      - ./common/config/nginx:/etc/nginx:z
      - /data/secret/cert:/etc/cert:z
    networks:
      - harbor
    dns_search: .
    ports:
      - 80:8080
      - 443:8443
    depends_on:
      - registry
      - core
      - portal
      - log
    logging:
      driver: "syslog"
      options:
        syslog-address: "tcp://127.0.0.1:1514"
        tag: "proxy"
networks:
  harbor:
    external: false
[root@xhz harbor]#

到了这里，关于【云原生|Docker】13-Docker-compose详解的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！