Yanaştırma Oluştur Y'yi başlatmadan önce X kabını bekle

Rabbitmq ve docker-compose ile buradan basit bir python örneği kullanıyorum . Benim sorunum, rabbitmq'in tamamen başlamasını beklemem gerektiğidir. Şimdiye kadar aradım, y (rabbitmq) başlayana kadar x (benim durumumda işçi) konteyner ile nasıl beklemek bilmiyorum.

Diğer blogun çevrimiçi olup olmadığını kontrol ettiği blog bloğunu buldum . Ayrıca bu docker komutunu buldum :

Bekle

Kullanım: docker bekleyin KONTEYNER [KONTEYNER ...]

Bir kap durana kadar engelleyin, ardından çıkış kodunu yazdırın.

Bir kapının durmasını beklemek belki de aradığım şey değil, eğer öyleyse, docker-compose.yml içinde bu komutu kullanmak mümkün mü? Şimdiye kadarki çözümüm birkaç saniye beklemek ve limanı kontrol etmek, ama bunu başarmanın yolu bu mu? Beklemezsem bir hata alırım.

liman işçisi-compose.yml

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

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

python merhaba örneği (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()

İşçi için Dockerfile:

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

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

Kasım 2015 Güncellemesi :

Bir kabuk komut dosyası veya programınızın içinde beklemek olası bir çözüm olabilir. Ancak bu sorunu gördükten sonra , docker / docker-compose'un kendisinin bir komutunu veya özelliğini arıyorum.

Sağlık kontrolünü uygulamak için en iyi seçenek olabilecek bir çözümden bahsediyorlar. Açık bir tcp bağlantısı, hizmetinizin hazır veya hazır kalabileceği anlamına gelmez. Buna ek olarak dockerfile dosyamdaki giriş noktasını değiştirmem gerekiyor.

Bu yüzden docker-compose on board komutları ile bir cevap bekliyorum, umarım bu sorunu bitirirlerse böyle olur.

Mart 2016 Güncellemesi

Bir kabın "canlı" olup olmadığını belirlemek için yerleşik bir yol sağlamak için bir teklif vardır . Yani docker-compose bunu yakın gelecekte kullanabilir.

Haziran 2016 Güncellemesi

Sağlık kontrolünün Sürüm 1.12.0'da bağlantı istasyonuna entegre edileceği anlaşılıyor

Güncelleme Ocak 2017

Bir docker-compose çözümü buldum: Bkz. Docker Y'yi başlatmadan önce X konteynerini bekle

Sonunda bir docker-compose yöntemiyle bir çözüm buldu. Docker -compose dosya biçimi 2.1 olduğundan, sağlık kontrolleri tanımlayabilirsiniz .

Örnek bir projede yaptım, en az 1.12.0+ docker yüklemeniz gerekiyor. Rabbitmq yönetimi Dockerfile'ı da genişletmem gerekiyordu , çünkü curl resmi görüntüde yüklü değil.

Şimdi rabbitmq konteynerinin yönetim sayfasının mevcut olup olmadığını test ediyorum. Curl çıkış kodu 0 ile biterse, konteyner uygulaması (python pika) başlatılır ve merhaba kuyruğuna bir mesaj yayınlanır. Şimdi çalışıyor (çıktı).

docker-compose (sürüm 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

çıktı:

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

Sürüm 3 artık depends_on koşul biçimini desteklemiyor . Bu yüzden başarısızlık üzerinde yeniden başlatmak için depends_on taşındı. Şimdi uygulama kabım çalışana kadar 2-3 kez yeniden başlayacak, ancak yine de giriş noktasının üzerine yazmadan docker-compose özelliğidir.

docker-compose (sürüm 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

Doğal olarak bu henüz mümkün değil. Ayrıca bu özellik isteğine de bakın .

Şimdiye kadar, CMDgerekli tüm hizmetler gelene kadar beklemek için kaplarınızda bunu yapmanız gerekir .

Gelen Dockerfiles CMDEğer tamamladı kapsayıcı hizmetini başlatırken o kendi başlangıç komut dosyası başvurabilecekler. Başlamadan önce, aşağıdakine benzer bir tane beklersiniz:

Dockerfile

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

Muhtemelen sizin de netcat kurmanız gerekiyor Dockerfile. Python görüntüsüne neyin önceden yüklendiğini bilmiyorum.

Basit tcp port kontrolleri için kullanımı kolay bekleme mantığı sağlayan birkaç araç vardır:

• Bunun için bekle
• dockerize

Daha karmaşık beklemeler için:

• goss - Açıklama blogu

restart: unless-stoppedVeya kullanmak restart: alwaysbu sorunu çözebilir.

containerRabbitMQ hazır olmadığında çalışan durursa, durana kadar yeniden başlatılır.

Son zamanlarda bu depends_onözelliği eklediler .

Düzenle:

Oluşturma sürümüyle birlikte 2.1+ kullanabilirsiniz depends_onbirlikte healthcheckbunu başarmak için:

Dokümanlardan :

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 sürümünden önce

Yine de kullanabilirsiniz depends_on, ancak yalnızca hizmetlerin başlatılma sırasını etkiler - bağımlı hizmet başlamadan önce hazır olmaları durumunda değil.

En azından 1.6.0 sürümünü gerektiriyor gibi görünüyor.

Kullanım böyle bir şey olurdu:

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

Dokümanlardan:

İki etkisi olan hizmetler arasında açık bağımlılık:

• docker-compose up hizmetleri bağımlılık sırasına göre başlatacaktır. Aşağıdaki örnekte, db ve redis web'den önce başlatılacaktır.
• docker-compose up SERVICE otomatik olarak SERVICE bağımlılıklarını içerecektir. Aşağıdaki örnekte, docker-compose up web de db ve redis oluşturur ve başlatır.

Not: Anladığım kadarıyla, bu kapların yüklenme sırasını ayarlamasına rağmen. Kap içindeki hizmetin gerçekten yüklendiğini garanti etmez.

Örneğin, postgres kapsayıcı yukarı olabilir. Ancak postgres hizmetinin kendisi hala kap içinde başlatılıyor olabilir.

sadece komut seçeneğine de ekleyebilirsiniz.

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

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

bir limanda beklemek için böyle bir şey de kullanabilirsiniz

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

bekleme süresini artırmak için biraz daha hackleyebilirsiniz:

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 benim için hile yaptı .. aşağıya bakın

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

Konteyner siparişi vermeye başlayın

depends_on:

Önceki kapsayıcıyı beklemek için komut dosyası kullanın

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

Bu makale https://docs.docker.com/compose/startup-order/ adresine yardımcı olacaktır.

Bunu, netcat kullanarak ( docker-wait komut dosyasını kullanarak) hizmetin hazır olmasını bekleyen bir bitiş noktası ayarlayarak da çözebilirsiniz . Hala temiz bir commandbölüm var docker-compose.ymlve uygulamanıza docker özel kod eklemek gerekmez gibi bu yaklaşımı seviyorum :

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

Sonra 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

Bu, günümüzde resmi liman işçiliği belgelerinde belgelenmiştir .

Not: Kullanılamıyorsa netcatdocker örneğinize yüklemeniz gerekir . Bunu yapmak için bunu Dockerdosyanıza ekleyin :

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

Beklemek için kullanılabilecek " docker-wait " adlı kullanıma hazır bir yardımcı program vardır .

Birçok farklı yol denedim, ancak bunun basitliğini beğendik: https://github.com/ufoscout/docker-compose-wait

Eğer ENV kullanabileceği düşüncesi böyle "beklenen" olmalıdır (bağlantı noktasına sahip) hizmetlerinin ana bilgisayarların listesini göndermek için liman işçisi oluşturma dosyasında vars: WAIT_HOSTS: postgres:5432, mysql:3306, mongo:27017.

Yani Diyelim ki (Repo gelen kopya / geçmiş aşağıdaki liman işçisi-compose.yml dosyası var diyelim 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

Ardından, hizmetlerin beklemesi için Docker dosyalarınıza (diğer hizmetlerin başlamasını beklemesi gereken hizmetlerin Docker dosyasına) aşağıdaki iki satırı eklemeniz gerekir:

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

Bu tür numune tam Örnek Dockerfile (yine Repo proje 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

Olası kullanım hakkında diğer ayrıntılar için bkz. README

bu blog yazısına dayanarak https://8thlight.com/blog/dariusz-pasciak/2016/10/17/docker-compose-wait-for-dependencies.html

docker-compose.ymlAşağıda gösterildiği gibi yapılandırdım :

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

Sonra run => için yapmak:

docker-compose up start_dependencies

rabbitmqhizmet daemon modunda başlayacak start_dependencies, işi bitirecek.

Bir Docker Oluştur dosyasının sürüm 3, sen kullanabilirsiniz RESTART .

Örneğin:

liman işçisi-compose.yml

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

Kullandığım Not olduğunu depends_on yerine linkleriSürüm 3'te kullanımdan kaldırıldığından .

Her ne kadar çalışırsa da, docker kapsayıcısını her hatada yeniden başlattığınız için ideal bir çözüm olmayabilir.

RESTART_POLICY'ye de bir göz atın . yeniden başlatma politikasına ince ayar yapmanıza olanak tanır.

Ne zaman üretimde Yaz'ı kullanın , bu yeniden başlatma ilkesini kullanmak en iyi yöntem aslında:

Yeniden başlatma gibi bir yeniden başlatma politikası belirleme: kesinti süresinden kaçınmak için her zaman

Alternatif çözümlerden biri, Kubernetes gibi bir konteyner düzenleme çözümü kullanmaktır. Kubernetes, diğer kaplar başlamadan önce tamamlanmaya başlayan init kapsayıcıları için desteğe sahiptir. Burada, API kapsayıcısının bir veritabanını başlatmak için init kapsayıcısını kullandığı SQL Server 2017 Linux kapsayıcısında bir örnek bulabilirsiniz.

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

mainKapsayıcı workerpinglere yanıt vermeye başladığında bekleyeceği örnek :

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

Ancak, doğru yol kullanmaktır healthcheck(> = 2.1).

Ciddi konuşlandırmalar için önerilmez, ancak burada esasen bir "x saniye bekleyin" komutudur.

İle docker-composesürümüne 3.4bir start_periodtalimat eklendihealthcheck . Bu, aşağıdakileri yapabileceğimiz anlamına gelir:

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

Burada olan healthcheck, 5 saniye sonra çağrılmasıdır. Bu status.shher zaman "Sorun değil" döndüren komut dosyasını çağırır . Yeni yaptıkzmq_client başlamadan önce konteyner 5 saniye bekleyin!

Not: Sahip olmanız önemlidir version: "3.4". Eğer .4orada değilse, liman işçisi şikayet eder.

Ben sadece 2 dosya oluşturmak ve bir birinci ve ikinci bir sonra başlatmak. Senaryom şöyle görünüyor:

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