Docker Compose 在启动 Y 之前等待容器 X

终于找到了一个 docker-compose 方法的解决方案。由于 docker-compose 文件格式 2.1，您可以定义 healthchecks。

我在 example project 中做到了，您至少需要安装 docker 1.12.0+。我还需要 extend the rabbitmq-management Dockerfile，因为官方镜像上没有安装 curl。

现在我测试一下rabbitmq-container的管理页面是否可用。如果 curl 以 exitcode 0 结束，则将启动容器应用程序（python pika）并将消息发布到 hello 队列。它现在正在工作（输出）。

码头工人撰写（2.1版）：

version: '2.1'

services:
  app:
    build: app/.
    depends_on:
      rabbit:
        condition: service_healthy
    links: 
        - rabbit

  rabbit:
    build: rabbitmq/.
    ports: 
        - "15672:15672"
        - "5672:5672"
    healthcheck:
        test: ["CMD", "curl", "-f", "http://localhost:15672"]
        interval: 30s
        timeout: 10s
        retries: 5

输出：

rabbit_1  | =INFO REPORT==== 25-Jan-2017::14:44:21 ===
rabbit_1  | closing AMQP connection <0.718.0> (172.18.0.3:36590 -> 172.18.0.2:5672)
app_1     |  [x] Sent 'Hello World!'
healthcheckcompose_app_1 exited with code 0

Dockerfile（rabbitmq + curl）：

FROM rabbitmq:3-management
RUN apt-get update
RUN apt-get install -y curl 
EXPOSE 4369 5671 5672 25672 15671 15672

版本 3 不再支持 depends_on 的条件形式。 所以我从depends_on 转移到restart on-failure。现在我的应用程序容器将重新启动 2-3 次，直到它开始工作，但它仍然是一个 docker-compose 功能，不会覆盖入口点。

码头工人撰写（版本 3）：

version: "3"

services:

  rabbitmq: # login guest:guest
    image: rabbitmq:management
    ports:
    - "4369:4369"
    - "5671:5671"
    - "5672:5672"
    - "25672:25672"
    - "15671:15671"
    - "15672:15672"
    healthcheck:
        test: ["CMD", "curl", "-f", "http://localhost:15672"]
        interval: 30s
        timeout: 10s
        retries: 5

  app:
    build: ./app/
    environment:
      - HOSTNAMERABBIT=rabbitmq
    restart: on-failure
    depends_on:
      - rabbitmq
    links: 
        - rabbitmq

---

最近他们添加了 depends_on feature。

编辑：

从撰写版本 2.1+ 到版本 3，您可以将 depends_on 与 healthcheck 结合使用来实现此目的：

From the docs：

version: '2.1'
services:
  web:
    build: .
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_started
  redis:
    image: redis
  db:
    image: redis
    healthcheck:
      test: "exit 0"

2.1版之前

您仍然可以使用 depends_on，但它只会影响服务启动的顺序 - 如果它们在依赖服务启动之前准备就绪，则不会。

它似乎至少需要 1.6.0 版本。

用法看起来像这样：

version: '2'
services:
  web:
    build: .
    depends_on:
      - db
      - redis
  redis:
    image: redis
  db:
    image: postgres 

从文档：

表达服务之间的依赖关系，有两个作用：docker-compose up 会按照依赖顺序启动服务。在以下示例中，db 和 redis 将在 web 之前启动。 docker-compose up SERVICE 将自动包含 SERVICE 的依赖项。在下面的例子中，docker-compose up web 也会创建并启动 db 和 redis。

注意：据我了解，尽管这确实设置了装载容器的顺序。它不保证容器内的服务已经实际加载。

例如，您的 postgres 容器可能已启动。但是 postgres 服务本身可能仍在容器内初始化。

---

在本机上，这是不可能的。另请参阅此feature request。

到目前为止，您需要在容器 CMD 中执行此操作，以等待所有必需的服务都在那里。

在 Dockerfile 的 CMD 中，您可以参考您自己的启动脚本，该脚本包含启动您的容器服务。在开始之前，您需要等待一个依赖项，例如：

Dockerfile

FROM python:2-onbuild
RUN ["pip", "install", "pika"]
ADD start.sh /start.sh
CMD ["/start.sh"]

启动.sh

#!/bin/bash
while ! nc -z rabbitmq 5672; do sleep 3; done
python rabbit.py

您可能还需要在 Dockerfile 中安装 netcat。我不知道 python 映像上预装了什么。

有一些工具可以提供易于使用的等待逻辑，用于简单的 tcp 端口检查：

等待它

码头化

对于更复杂的等待：

goss - 解释博客

---

使用 restart: unless-stopped 或 restart: always 可以解决这个问题。

如果worker container 在rabbitMQ 未准备好时停止，它将重新启动，直到它准备好。

---

您也可以将其添加到命令选项中，例如。

command: bash -c "sleep 5; start.sh"

https://github.com/docker/compose/issues/374#issuecomment-156546513

等待一个端口你也可以使用这样的东西

command: bash -c "while ! curl -s rabbitmq:5672 > /dev/null; do echo waiting for xxx; sleep 3; done; start.sh"

要增加等待时间，您可以再破解一点：

command: bash -c "for i in {1..100} ; do if ! curl -s rabbitmq:5672 > /dev/null ; then echo waiting on rabbitmq for $i seconds; sleep $i; fi; done; start.sh"

---

restart: on-failure 为我做了诀窍..见下文

---
version: '2.1'
services:
  consumer:
    image: golang:alpine
    volumes:
      - ./:/go/src/srv-consumer
    working_dir: /go/src/srv-consumer
    environment:
      AMQP_DSN: "amqp://guest:guest@rabbitmq:5672"
    command: go run cmd/main.go
    links:
          - rabbitmq
    restart: on-failure

  rabbitmq:
    image: rabbitmq:3.7-management-alpine
    ports:
      - "15672:15672"
      - "5672:5672"

---

对于容器开始订购使用

depends_on:

等待前一个容器启动使用脚本

entrypoint: ./wait-for-it.sh db:5432

本文将帮助您https://docs.docker.com/compose/startup-order/

---

尝试了许多不同的方法，但喜欢这种简单性：https://github.com/ufoscout/docker-compose-wait

您可以在 docker compose 文件中使用 ENV vars 来提交应该“等待”的服务主机列表（带有端口），如下所示：WAIT_HOSTS: postgres:5432, mysql:3306, mongo:27017。

因此，假设您有以下 docker-compose.yml 文件（从 repo README 复制/过去）：

version: "3"

services:

  mongo:
    image: mongo:3.4
    hostname: mongo
    ports:
      - "27017:27017"

  postgres:
    image: "postgres:9.4"
    hostname: postgres
    ports:
      - "5432:5432"

  mysql:
    image: "mysql:5.7"
    hostname: mysql
    ports:
      - "3306:3306"

  mySuperApp:
    image: "mySuperApp:latest"
    hostname: mySuperApp
    environment:
      WAIT_HOSTS: postgres:5432, mysql:3306, mongo:27017

接下来，为了让服务等待，您需要将以下两行添加到您的 Dockerfiles（到应该等待其他服务启动的服务的 Dockerfile 中）：

ADD https://github.com/ufoscout/docker-compose-wait/releases/download/2.5.0/wait /wait
RUN chmod +x /wait

此类示例 Dockerfile 的完整示例（同样来自项目 repo README）：

FROM alpine

## Add your application to the docker image
ADD MySuperApp.sh /MySuperApp.sh

## Add the wait script to the image
ADD https://github.com/ufoscout/docker-compose-wait/releases/download/2.5.0/wait /wait
RUN chmod +x /wait

## Launch the wait tool and then your application
CMD /wait && /MySuperApp.sh

有关可能使用的其他详细信息，请参阅 README

---

如果您只想启动服务，则另一个服务已成功完成（例如迁移、数据填充等），docker-compose 版本 1.29 附带 build in functionality for this - service_completed_successfully。

depends_on:
  <service-name>:
    condition: service_completed_successfully

根据specification：

service_completed_successfully - 指定依赖项在启动依赖服务之前运行成功完成

---

您还可以通过使用 netcat（使用 docker-wait 脚本）设置一个等待服务启动的端点来解决此问题。我喜欢这种方法，因为您的 docker-compose.yml 中仍然有一个干净的 command 部分，并且您不需要将 docker 特定代码添加到您的应用程序中：

version: '2'
services:
  db:
    image: postgres
  django:
    build: .
    command: python manage.py runserver 0.0.0.0:8000
    entrypoint: ./docker-entrypoint.sh db 5432
    volumes:
      - .:/code
    ports:
      - "8000:8000"
    depends_on:
      - db

然后您的 docker-entrypoint.sh：

#!/bin/sh

postgres_host=$1
postgres_port=$2
shift 2
cmd="$@"

# wait for the postgres docker to be running
while ! nc $postgres_host $postgres_port; do
  >&2 echo "Postgres is unavailable - sleeping"
  sleep 1
done

>&2 echo "Postgres is up - executing command"

# run the command
exec $cmd

如今，官方 docker documentation 中记录了这一点。

PS：如果这不可用，您应该在您的 docker 实例中安装 netcat。为此，请将其添加到您的 Docker 文件中：

RUN apt-get update && apt-get install netcat-openbsd -y 

---

有一个名为“docker-wait”的即用型实用程序可用于等待。

---

根据这篇博文https://8thlight.com/blog/dariusz-pasciak/2016/10/17/docker-compose-wait-for-dependencies.html

我配置了我的 docker-compose.yml，如下所示：

version: "3.1"

services:
  rabbitmq:
    image: rabbitmq:3.7.2-management-alpine
    restart: always
    environment:
      RABBITMQ_HIPE_COMPILE: 1
      RABBITMQ_MANAGEMENT: 1
      RABBITMQ_VM_MEMORY_HIGH_WATERMARK: 0.2
      RABBITMQ_DEFAULT_USER: "rabbitmq"
      RABBITMQ_DEFAULT_PASS: "rabbitmq"
    ports:
      - "15672:15672"
      - "5672:5672"
    volumes:
      - data:/var/lib/rabbitmq:rw

  start_dependencies:
    image: alpine:latest
    links:
      - rabbitmq
    command: >
      /bin/sh -c "
        echo Waiting for rabbitmq service start...;
        while ! nc -z rabbitmq 5672;
        do
          sleep 1;
        done;
        echo Connected!;
      "

volumes:
  data: {}

然后我运行=>：

docker-compose up start_dependencies

rabbitmq 服务将以守护程序模式启动，start_dependencies 将完成工作。

---

在 Docker Compose 文件的版本 3 中，您可以使用 RESTART。

例如：

码头工人-compose.yml

worker:
    build: myapp/.
    volumes:
    - myapp/.:/usr/src/app:ro
    restart: on-failure
    depends_on:
    - rabbitmq
rabbitmq:
    image: rabbitmq:3-management

请注意，我使用 depends_on 而不是 links，因为后者在版本 3 中已被弃用。

即使它有效，它也可能不是理想的解决方案，因为每次失败时都要重新启动 docker 容器。

也看看RESTART_POLICY。它可以让您微调重启策略。

当您 use Compose in production 时，使用重启策略实际上是最佳实践：

指定重启策略，如重启：总是避免停机

---

不推荐用于严肃的部署，但这里本质上是一个“等待 x 秒”命令。

对于 docker-compose 版本 3.4 和 start_period instruction has been added to healthcheck。这意味着我们可以执行以下操作：

docker-compose.yml：

version: "3.4"
services:
  # your server docker container
  zmq_server:
    build:
      context: ./server_router_router
      dockerfile: Dockerfile

  # container that has to wait
  zmq_client:
    build:
      context: ./client_dealer/
      dockerfile: Dockerfile
    depends_on:
      - zmq_server
    healthcheck:
      test: "sh status.sh"
      start_period: 5s

status.sh：

#!/bin/sh

exit 0

这里发生的是 healthcheck 在 5 秒后被调用。这将调用 status.sh 脚本，该脚本始终返回“没问题”。我们只是让 zmq_client 容器在启动前等待 5 秒！

注意：拥有 version: "3.4" 很重要。如果 .4 不存在，docker-compose 会抱怨。

---

我目前也有这样的要求，即在其他服务启动之前等待一些服务启动并运行。另请阅读此处和其他一些地方的建议。但它们中的大多数都要求必须对 docker-compose.yml 进行一些更改。所以我开始研究一个我认为是围绕 docker-compose 本身的编排层的解决方案，最后我想出了一个我称之为 docker-compose-profile 的 shell 脚本。即使服务没有直接向主机公开任何端口，它也可以等待与某个容器的 tcp 连接。我使用的技巧是在堆栈中启动另一个 docker 容器，然后我可以（通常）从那里连接到每个服务（只要没有应用其他网络配置）。还有等待方法来注意某个日志消息。可以将服务组合在一起以在一个步骤中启动，然后再触发另一个步骤启动。您还可以排除某些服务而不列出所有其他要启动的服务（例如可用服务的集合减去一些排除的服务）。这种配置可以捆绑到配置文件中。有一个名为 dcp.yml 的 yaml 配置文件（目前）必须放在 docker-compose.yml 文件旁边。

对于您的问题，这看起来像：

command:
  aliases:
    upd:
      command: "up -d"
      description: |
        Create and start container. Detach afterword.

profiles:
  default:
    description: |
      Wait for rabbitmq before starting worker.
    command: upd
    steps:
      - label: only-rabbitmq
        only: [ rabbitmq ]
        wait:
          - 5@tcp://rabbitmq:5432
      - label: all-others

您现在可以通过调用来启动您的堆栈

dcp -p default upd

甚至简单地通过

dcp

因为只有一个默认配置文件可以运行 up -d。

有一个小问题。我当前的版本（尚）不支持您实际需要的特殊等待条件。所以没有测试向rabbit发送消息。

我已经在考虑另一种等待方法来在主机上或作为 docker 容器运行某个命令。比我们可以通过类似的东西扩展该工具

...
        wait:
          - service: rabbitmq
            method: container
            timeout: 5
            image: python-test-rabbit
...

有一个名为 python-test-rabbit 的 docker 映像来进行检查。

这样做的好处是不再需要将等待的部分带给您的工人。它将被隔离并留在编排层内。

可能有人觉得这很有用。任何建议都非常受欢迎。

您可以在 https://gitlab.com/michapoe/docker-compose-profile 找到此工具

---

一种替代解决方案是使用容器编排解决方案，如 Kubernetes。 Kubernetes 支持在其他容器启动之前运行完成的 init 容器。您可以在此处找到使用 SQL Server 2017 Linux 容器的示例，其中 API 容器使用 init 容器来初始化数据库

https://www.handsonarchitect.com/2018/08/understand-kubernetes-object-init.html

---

以下是 main 容器在开始响应 ping 时等待 worker 的示例：

version: '3'
services:
  main:
    image: bash
    depends_on:
     - worker
    command: bash -c "sleep 2 && until ping -qc1 worker; do sleep 1; done &>/dev/null"
    networks:
      intra:
        ipv4_address: 172.10.0.254
  worker:
    image: bash
    hostname: test01
    command: bash -c "ip route && sleep 10"
    networks:
      intra:
        ipv4_address: 172.10.0.11
networks:
  intra:
    driver: bridge
    ipam:
      config:
      - subnet: 172.10.0.0/24

但是，正确的方法是使用 healthcheck (>=2.1)。

---

在尝试了几种方法之后，IMO 最简单和最优雅的选择是使用带有 -wait 标志的 jwilder/dockerize 实用程序图像（@Henrik Sachse 提到但他没有展示具体示例）。这是一个简单的示例，我需要在启动我的应用程序之前准备好 RabbitMQ：

version: "3.8"
services:
  # Start RabbitMQ.
  rabbit:
    image: rabbitmq

  # Wait for RabbitMQ to be joinable.
  check-rabbit-started: 
    image: jwilder/dockerize:0.6.1
    depends_on:
      - rabbit
    command: 'dockerize -wait=tcp://rabbit:5672'
  
  # Only start myapp once RabbitMQ is joinable.
  myapp:
    image: myapp:latest
    depends_on:
      - check-rabbit-started

---

我猜码头工人真的希望我们使用我们自己的图像中的代码等待服务。我仍然想在 docker-compose.yml 中配置要等待的服务。如果您愿意使用入口点脚本，这是一种方法。

使用您选择的图像中包含的等待工具，将此循环添加到您的入口点脚本。我正在使用 https://github.com/vishnubob/wait-for-it/。如果您不传递任何服务，则循环不执行任何操作。

for service in "$@"; do
    echo "$0: wait for service $service"
    if ! wait-for-it "$service"; then
        echo "$0: failed on service $service"
        exit 1
    fi
done

使用此条目为 docker-compose.yml 中的容器传递所需的服务：

    command: ["my-data-svc:5000"]

这依赖于 docker 命令作为参数传递给入口点脚本的行为。您可能会提出一个令人信服的论点，即我在这里滥用了 docker 命令的意图。我不会死在那座山上，它对我有用。

---

我只有 2 个撰写文件，然后开始第一个和第二个。我的脚本如下所示：

#!/bin/bash
#before i build my docker files
#when done i start my build docker-compose
docker-compose -f docker-compose.build.yaml up
#now i start other docker-compose which needs the image of the first
docker-compose -f docker-compose.prod.yml up

---