Kompilacja dokowania zaczekaj na kontener X przed uruchomieniem Y

Korzystam z rabbitmq i prostej próbki pytona stąd wraz z docker-compose. Mój problem polega na tym, że muszę poczekać, aż Rabbitmq się w pełni uruchomi. Z tego, co szukałem do tej pory, nie wiem, jak czekać z kontenerem x (w moim przypadku robotnikiem), aż zostanie uruchomiony y (rabbitmq).

Znalazłem ten post na blogu, na którym sprawdza, czy drugi host jest online. Znalazłem również to polecenie dokera :

czekać

Zastosowanie: docker czekać CONTAINER [CONTAINER ...]

Blokuj, aż kontener się zatrzyma, a następnie wydrukuj kod wyjścia.

Oczekiwanie na zatrzymanie kontenera może nie jest tym, czego szukam, ale jeśli tak, to czy można użyć tego polecenia w oknie docker-compose.yml? Jak dotąd moim rozwiązaniem jest poczekanie kilku sekund i sprawdzenie portu, ale czy to jest sposób na osiągnięcie tego ?. Jeśli nie czekam, pojawia się błąd.

docker-compose.yml

worker:
    build: myapp/.
    volumes:
    - myapp/.:/usr/src/app:ro

    links:
    - rabbitmq
rabbitmq:
    image: rabbitmq:3-management

przykładowa python hello (rabbit.py):

import pika
import time

import socket

pingcounter = 0
isreachable = False
while isreachable is False and pingcounter < 5:
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    try:
        s.connect(('rabbitmq', 5672))
        isreachable = True
    except socket.error as e:
        time.sleep(2)
        pingcounter += 1
    s.close()

if isreachable:
    connection = pika.BlockingConnection(pika.ConnectionParameters(
            host="rabbitmq"))
    channel = connection.channel()

    channel.queue_declare(queue='hello')

    channel.basic_publish(exchange='',
                          routing_key='hello',
                          body='Hello World!')
    print (" [x] Sent 'Hello World!'")
    connection.close()

Plik Docker dla pracownika:

FROM python:2-onbuild
RUN ["pip", "install", "pika"]

CMD ["python","rabbit.py"]

Aktualizacja lis 2015 :

Możliwym rozwiązaniem może być skrypt powłoki lub oczekiwanie w twoim programie. Ale po zobaczeniu tego problemu szukam polecenia lub funkcji docker / docker-compose.

Wspominają o rozwiązaniu służącym do kontroli stanu zdrowia, które może być najlepszym rozwiązaniem. Otwarte połączenie TCP nie oznacza, że ​​usługa jest gotowa lub może pozostać gotowa. Ponadto muszę zmienić punkt wejścia w pliku dokera.

Mam więc nadzieję na odpowiedź z komendami docker-komponuj na pokładzie, co, mam nadzieję, będzie miało miejsce, jeśli zakończą ten problem.

Aktualizacja z marca 2016 r

Jest to propozycja dla zapewnienia wbudowany sposobem określenia, czy dany pojemnik jest „żywy”. Więc docker-compose może z niego skorzystać w najbliższej przyszłości.

Aktualizacja z czerwca 2016 r

Wygląda na to, że kontrola zdrowia zostanie zintegrowana z dokerem w wersji 1.12.0

Aktualizacja ze stycznia 2017 r

Znalazłem rozwiązanie komponowania dokera patrz: Docker Compose poczekaj na kontener X przed uruchomieniem Y

Wreszcie znalazłem rozwiązanie z metodą dokowania-komponowania. Ponieważ format pliku dokowania-komponuj 2.1, możesz zdefiniować kontrole kondycji .

Zrobiłem to w przykładowym projekcie, w którym musisz zainstalować przynajmniej dokera 1.12.0+. Musiałem także rozszerzyć plik Dockerfile do zarządzania królikami , ponieważ curl nie jest zainstalowany na oficjalnym obrazie.

Teraz sprawdzam, czy strona zarządzania kontenera rabbitmq jest dostępna. Jeśli curl zakończy się kodem wyjścia 0, aplikacja kontenera (python pika) zostanie uruchomiona i opublikuje komunikat w kolejce hello. Teraz działa (wyjście).

docker-compose (wersja 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

wynik:

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

Wersja 3 nie obsługuje już formy warunku depend_on . Więc przeniosłem się z depend_on, aby zrestartować po awarii. Teraz mój kontener aplikacji uruchomi się ponownie 2-3 razy, aż będzie działał, ale nadal jest funkcją komponowania dokera bez nadpisywania punktu wejścia.

docker-compose (wersja 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

Natywnie nie jest to jeszcze możliwe. Zobacz także to żądanie funkcji .

Do tej pory musisz to zrobić w swoich kontenerach, CMDaby poczekać, aż pojawią się wszystkie wymagane usługi.

W Dockerfiles CMDmożesz odwołać się do własnego skryptu startowego, który otacza uruchamianie usługi kontenera. Zanim go uruchomisz, zaczekaj na zależną, taką jak:

Plik Docker

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

start.sh

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

Prawdopodobnie musisz również zainstalować netcat Dockerfile. Nie wiem, co jest wstępnie zainstalowane na obrazie Pythona.

Istnieje kilka narzędzi, które zapewniają łatwą w użyciu logikę oczekiwania na proste kontrole portów TCP:

• czekaj na to
• dokować

Na bardziej złożone oczekiwania:

• goss - blog wyjaśniający

Za pomocą restart: unless-stoppedlub restart: alwaysmoże rozwiązać ten problem.

Jeśli pracownik containerzatrzyma się, gdy rabbitMQ nie będzie gotowy, zostanie zrestartowany, aż będzie.

Całkiem niedawno dodali tę depends_onfunkcję .

Edytować:

Począwszy od komponowania wersji 2.1+, możesz tego użyć depends_onw połączeniu z healthcheck:

Z dokumentów :

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"

Przed wersją 2.1

Nadal możesz używać depends_on, ale wpływa to tylko na kolejność uruchamiania usług - nie jeśli są one gotowe przed uruchomieniem usługi zależnej.

Wydaje się, że wymaga co najmniej wersji 1.6.0.

Użycie wyglądałoby mniej więcej tak:

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

Z dokumentów:

Wyraźna zależność między usługami, która ma dwa efekty:

• dokowanie-komponowanie uruchomi usługi w kolejności zależności. W poniższym przykładzie db i redis zostaną uruchomione przed uruchomieniem sieci.
• dokowanie-skomponuj SERVICE automatycznie uwzględni zależności SERVICE. W poniższym przykładzie web-docker-compose up również utworzy i uruchomi db i redis.

Uwaga: jak rozumiem, chociaż ustawia to kolejność ładowania kontenerów. Nie gwarantuje to, że usługa wewnątrz kontenera rzeczywiście się załadowała.

Na przykład postgres pojemnik może być włączony. Ale sama usługa postgres może nadal inicjować się w kontenerze.

możesz także dodać go do opcji polecenia np.

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

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

aby poczekać na porcie, możesz również użyć czegoś takiego

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

Aby wydłużyć czas oczekiwania, możesz zhakować trochę więcej:

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 zrobił dla mnie lewę ... patrz poniżej

---
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"

Do rozpoczęcia zamawiania kontenera użyj

depends_on:

Do oczekiwania na poprzedni kontener uruchom skrypt

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

Ten artykuł pomoże Ci https://docs.docker.com/compose/startup-order/

Możesz również rozwiązać ten problem, ustawiając punkt końcowy, który czeka na uruchomienie usługi, używając netcat (używając skryptu docker-wait ). Podoba mi się to podejście, ponieważ nadal masz czystą commandsekcję docker-compose.ymli nie musisz dodawać do aplikacji kodu specyficznego dla dokera:

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

Następnie twój 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

Jest to obecnie udokumentowane w oficjalnej dokumentacji dokera .

PS: Należy zainstalować netcatw instancji dokera, jeśli nie jest to dostępne. Aby to zrobić, dodaj to do Dockerpliku:

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

Istnieje gotowe do użycia narzędzie o nazwie „ docker-wait ”, którego można używać do oczekiwania.

Próbowałem na wiele różnych sposobów, ale podobała się jej prostota: https://github.com/ufoscout/docker-compose-wait

Pomysł, że można użyć ENV vars w pliku doker redagowania przedłożyć wykaz usług gospodarze (z otworami), który powinien być „oczekiwany” tak: WAIT_HOSTS: postgres:5432, mysql:3306, mongo:27017.

Powiedzmy, że masz następujący plik docker-compose.yml (copy / past from 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

Następnie, aby usługi mogły czekać, należy dodać następujące dwa wiersze do plików Docker (do pliku Docker usług, które powinny oczekiwać na uruchomienie innych usług):

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

Kompletny przykład takiego przykładowego pliku Docker (ponownie z repozytorium projektu 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

Aby uzyskać szczegółowe informacje na temat możliwego użycia, zobacz README

na podstawie tego postu na blogu https://8thlight.com/blog/dariusz-pasciak/2016/10/17/docker-compose-wait-for-dependencies.html

Skonfigurowałem mój, docker-compose.ymljak pokazano poniżej:

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: {}

Następnie robię dla run =>:

docker-compose up start_dependencies

rabbitmqusługa uruchomi się w trybie demona, start_dependencieszakończy pracę.

W wersji 3 pliku Docker Compose możesz użyć RESTART .

Na przykład:

docker-compose.yml

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

Zauważ, że użyłem depend_on zamiast linków, ponieważ ten ostatni jest przestarzały w wersji 3.

Nawet jeśli działa, może nie być idealnym rozwiązaniem, ponieważ restartujesz kontener dokera przy każdej awarii.

Mają wygląd RESTART_POLICY również. pozwala dostroić zasady restartu.

Podczas korzystania z funkcji Komponuj w produkcji najlepszą praktyką jest użycie zasady ponownego uruchamiania:

Określanie zasad ponownego uruchamiania, takich jak restart: zawsze w celu uniknięcia przestojów

Jednym z alternatywnych rozwiązań jest użycie rozwiązania do aranżacji kontenerów, takiego jak Kubernetes. Kubernetes ma obsługę kontenerów init, które działają do końca, zanim inne kontenery będą mogły się uruchomić. Możesz znaleźć tutaj przykład z kontenerem Linux Server SQL Server 2017, w którym kontener API używa kontenera init do zainicjowania bazy danych

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

Oto przykład, w którym mainkontener czeka na workerrozpoczęcie odpowiedzi na ping:

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

Jednak właściwym sposobem jest użycie healthcheck(> = 2.1).

Niezalecane w przypadku poważnych wdrożeń, ale tutaj jest zasadniczo polecenie „poczekaj x sekund”.

W docker-composewersji 3.4dodano start_periodinstrukcjęhealthcheck . Oznacza to, że możemy wykonać następujące czynności:

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

To, co się tutaj dzieje, polega na tym, że healthcheckwywoływane jest po 5 sekundach. To wywołuje status.shskrypt, który zawsze zwraca „Bez problemu”. Właśnie zmusiliśmy zmq_clientkontener do oczekiwania 5 sekund przed rozpoczęciem!

Uwaga: ważne, że masz version: "3.4". Jeśli tego .4nie ma, dokerowanie-komponowanie narzeka.

Mam tylko 2 pliki do komponowania i zaczynam pierwszy, a drugi później. Mój skrypt wygląda tak:

#!/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