Docker कम्पोज़ Y शुरू करने से पहले कंटेनर X की प्रतीक्षा करें


324

मैं से RabbitMQ और एक साधारण अजगर नमूना उपयोग कर रहा हूँ यहाँ डोकर-लिखें सुविधा के साथ एक साथ। मेरी समस्या यह है कि मुझे पूरी तरह से शुरू करने के लिए खरगोशों की प्रतीक्षा करने की आवश्यकता है। अब तक मैंने जो कुछ भी खोजा है, मैं नहीं जानता कि कंटेनर एक्स (मेरे मामले में कार्यकर्ता) के साथ वाई (खरगोशबिटक) शुरू होने तक इंतजार कैसे करें।

मुझे यह ब्लॉगपोस्ट मिला जहां वह जांचता है कि क्या दूसरा होस्ट ऑनलाइन है। मुझे यह डॉकटर कमांड भी मिली :

रुको

उपयोग: डॉकटर प्रतीक्षा करें [कंटेनर ...]

एक कंटेनर बंद होने तक ब्लॉक करें, फिर उसका निकास कोड प्रिंट करें।

एक कंटेनर के रुकने का इंतजार करना शायद वह नहीं है जिसकी मुझे तलाश है लेकिन अगर ऐसा है तो क्या उस कमांड का इस्तेमाल डोकर-कम्पोज के अंदर करना संभव है। मेरा अब तक का समाधान कुछ सेकंड इंतजार करना और बंदरगाह की जांच करना है, लेकिन क्या इसे प्राप्त करने का तरीका है? अगर मैं प्रतीक्षा नहीं करता तो मुझे एक त्रुटि मिलती है।

डोकर-compose.yml

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

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

अजगर हेल्लो सैंपल (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()

कार्यकर्ता के लिए डॉकरीफाइल:

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

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

अद्यतन नवंबर 2015 :

एक शेल स्क्रिप्ट या आपके कार्यक्रम के अंदर प्रतीक्षा करना शायद एक संभव समाधान है। लेकिन इस मुद्दे को देखने के बाद मैं खुद ही docker / docker-compose की कमांड या फीचर की तलाश कर रहा हूं।

वे स्वास्थ्य जांच को लागू करने के लिए एक समाधान का उल्लेख करते हैं, जो सबसे अच्छा विकल्प हो सकता है। एक खुला tcp कनेक्शन का मतलब यह नहीं है कि आपकी सेवा तैयार है या तैयार रह सकती है। इसके अलावा मुझे अपने डॉकटराइल में अपना प्रवेश बिंदु बदलना होगा।

इसलिए मैं बोर्ड कमांड पर डॉकटर-कंपोज़ के साथ जवाब की उम्मीद कर रहा हूं, जो इस मामले को खत्म करने की उम्मीद करेंगे।

अपडेट मार्च 2016

वहाँ एक है प्रस्ताव एक अंतर्निहित तरीका अगर एक कंटेनर "जीवित" है निर्धारित करने के लिए प्रदान करने के लिए। इसलिए निकट भविष्य में डॉकटर-कंपोज इसका उपयोग कर सकते हैं।

अपडेट जून 2016

ऐसा लगता है कि Healthcheck को संस्करण 1.12.0 में docker में एकीकृत किया जाएगा

अपडेट जनवरी 2017

मुझे एक डॉकटर- कंपोज़ सॉल्यूशन देखने को मिला: Y शुरू करने से पहले डॉकटर कंपोज़ कंटेनर X का इंतज़ार करें


2
वितरित सिस्टम फॉल्ट को सहिष्णु बनाने के लिए प्रोत्साहित करने के लिए 2.3 में डॉकटर-कंपोज़ में हेल्थचेक का उपयोग किया गया है। देखें: docs.docker.com/compose/startup-order
Kmaid

जवाबों:


283

अंत में डॉकटर-कंपोज़ विधि के साथ एक समाधान मिला। फ़ाइल प्रारूप 2.1 बनाने के बाद से आप स्वास्थ्य जांच को परिभाषित कर सकते हैं ।

मैंने इसे एक उदाहरण परियोजना में किया था जिसे आपको कम से कम 1.12.0+ स्थापित करने की आवश्यकता है। मुझे खरगोश-प्रबंधन डॉकफाइल का विस्तार करने की भी आवश्यकता थी , क्योंकि आधिकारिक छवि पर कर्ल स्थापित नहीं है।

अब मैं परीक्षण करता हूं कि क्या खरगोश-कंटेनर का प्रबंधन पृष्ठ उपलब्ध है। यदि कर्ल एग्ज़िटकोड 0 के साथ खत्म हो जाता है तो कंटेनर ऐप (पायथन पिका) शुरू हो जाएगा और हैलो कतार में एक संदेश प्रकाशित करेगा। इसका अब काम करना (आउटपुट)।

docker- रचना (संस्करण 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 (खरगोश + कर्ल):

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

संस्करण 3 अब depend_on की स्थिति रूप का समर्थन नहीं करता है । इसलिए मैं विफलता पर पुनः आरंभ करने के लिए depend_on से चला गया। अब मेरा ऐप कंटेनर 2-3 बार पुनरारंभ होगा जब तक कि यह काम नहीं कर रहा है, लेकिन यह अभी भी एक डॉकटर-कंपोज़ फीचर है जो एंट्रीपॉइंट को ओवरराइट किए बिना है।

docker- रचना (संस्करण 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

6
@svenhornberg pingICMP का उपयोग करता है इसलिए टीसीपी पोर्ट का समर्थन नहीं करता है। शायद ncएक टीसीपी पोर्ट का परीक्षण करने के लिए। शायद psql -h localhost -p 5432कुछ का उपयोग करने और क्वेरी करने के लिए बेहतर है।
मैट

36
"निर्भर करता है" संस्करण 3 में हटा दिया गया है docs.docker.com/compose/compose-file/#dependson
nha

48
@nha ऐसा लग रहा है conditionके रूप depends_onनिकाल दिया जाता है, लेकिन depends_onखुद v3 में चारों ओर अब भी है
akivajgordon

14
कैसे healthchecks अभी भी अगर नियंत्रण स्टार्टअप क्रम में इस्तेमाल किया जा सकता depends_onके साथ conditionहटा दिया गया है?
फ्रांज

42
इस तरह के दर्द पर विश्वास करना मुश्किल है
npr

71

मूल रूप से यह संभव नहीं है, फिर भी। यह सुविधा अनुरोध भी देखें ।

अब तक आपको अपने CMDसभी आवश्यक सेवाओं के होने तक इंतजार करने के लिए अपने कंटेनरों में करने की आवश्यकता है।

में Dockerfileरों CMDआप अपने खुद के शुरू स्क्रिप्ट की जानकारी दे सकती है कि wraps अपने कंटेनर सेवा शुरू। इसे शुरू करने से पहले, आप एक के लिए इंतजार करना पसंद करते हैं:

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

शायद आपको अपने Dockerfileसाथ ही नेटकैट भी इंस्टॉल करना होगा । मुझे नहीं पता कि अजगर छवि पर पूर्व-स्थापित क्या है।

वहाँ कुछ उपकरण हैं जो प्रतीक्षा तर्क का उपयोग करने के लिए आसान प्रदान करते हैं, सरल tcp पोर्ट चेक के लिए:

अधिक जटिल वेट के लिए:


क्या आप बता सकते हैं कि आपका सीएमडी से क्या मतलब है? क्या इसका मतलब यह है कि मेरे प्रोग्राम को यह करना होगा, जैसे मैंने इसे पोर्ट चेक के साथ किया था? या क्या आप इसके लिए उदाहरण के लिए linux से एक विशिष्ट CMD मतलब है?
स्वेनहॉर्नबर्ग

समझाने के लिए धन्यवाद, मैं आपके उत्तर को बढ़ाता हूं। लेकिन मुझे लगता है कि आगामी फीचर अनुरोध, मेरे प्रश्न का सही उत्तर होगा, इसलिए मैं इसे अभी तक अनुत्तरित छोड़ देता हूं।
svenhornberg

44

इस समस्या का उपयोग restart: unless-stoppedया restart: alwaysहल कर सकते हैं।

यदि containerखरगोश बंद होने पर श्रमिक तैयार नहीं होता है, तो इसे तब तक फिर से शुरू किया जाएगा।


3
मैं इस मामले के लिए इस समाधान को पसंद करता हूं, लेकिन यह उन कंटेनरों के लिए काम नहीं करता है जो तब नहीं निकलते हैं जब उपप्रोसेस में से एक जिसे वह चलाता है वह विफल हो जाता है। उदाहरण के लिए, एक टॉमकैट कंटेनर तब भी चलता रहेगा, जब एक जावा सर्वलेट जो इसे चलाता था, डेटाबेस सर्वर से कनेक्ट करने में विफल रहता था। दी गई, डॉकटर कंटेनर टॉम्केट जैसे सर्वलेट कंटेनरों को ज्यादातर अनावश्यक रूप से प्रस्तुत करते हैं।
डेरेक महार

@DerekMahar, यदि आपके पास जावा-आधारित वेब अनुप्रयोग है जो केवल REST कॉल परोसता है, तो आप Jetty / Tomcat के बजाय क्या उपयोग करते हैं?
जोजी

2
@JoeG, मेरा मतलब था टॉमकैट सर्वलेट कंटेनर जो कई अनुप्रयोगों की मेजबानी कर सकता है, टॉमकैट एम्बेडेड नहीं। उदाहरण के लिए, डॉक़र पूर्व को अधिकांशतः अनावश्यक रूप से प्रस्तुत करता है, जबकि बाद वाले को अधिक से अधिक लोकप्रिय बनाता है।
डेरेक महार

35

हाल ही में उन्होंने depends_onफीचर जोड़ा है ।

संपादित करें:

संस्करण 2.1+ के रूप में आप इसे प्राप्त करने के लिए depends_onसंयोजन के साथ उपयोग कर सकते हैं healthcheck:

डॉक्स से :

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 निर्भरता क्रम में सेवाएं शुरू करेगा। निम्नलिखित उदाहरण में, db और redis वेब से पहले शुरू किया जाएगा।
  • डॉक-कंपोज़ अप सेवा में स्वचालित रूप से सेवा की निर्भरता शामिल होगी। निम्नलिखित उदाहरण में, docker-compose up web भी db और redis बनाएंगे और शुरू करेंगे।

नोट: जैसा कि मैंने इसे समझा, हालांकि यह उस क्रम को निर्धारित करता है जिसमें कंटेनर लोड किए जाते हैं। यह गारंटी नहीं देता है कि कंटेनर के अंदर सेवा वास्तव में भरी हुई है।

उदाहरण के लिए, आप कंटेनर को स्थगित कर सकते हैं। लेकिन पोस्टग्रेज सेवा स्वयं कंटेनर के भीतर शुरू हो सकती है।


10
dnephin ने लिखा है: depend_on केवल ऑर्डर कर रहा है। वास्तव में एक और कंटेनर के शुरू होने में देरी करने के लिए किसी तरह का पता लगाने की आवश्यकता होगी जब एक प्रक्रिया ने खुद को प्रारंभिक रूप से समाप्त कर दिया हो।
svenhornberg

15
"संस्करण 3 अब की स्थिति फ़ॉर्म का समर्थन नहीं करता है depends_on।" docs.docker.com/compose/compose-file/#dependson
akauppi

depends_onतब तक इंतजार न करें जब तक कि कंटेनर readyराज्य में नहीं है (जो भी आपके मामले में मतलब हो सकता है)। यह केवल तब तक इंतजार करता है जब तक कि कंटेनर 'चालू' स्थिति में न हो।
१३

19

आप इसे केवल कमांड विकल्प में भी जोड़ सकते हैं।

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"

13

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"

12

कंटेनर के लिए उपयोग का आदेश देना शुरू करें

depends_on:

पिछले कंटेनर प्रतीक्षा के लिए स्क्रिप्ट का उपयोग करना शुरू करें

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

यह लेख आपकी मदद करेगा https://docs.docker.com/compose/startup-order/


5
@svenhornberg टिप्पणी में, आप लिंक करते हैं, प्रतीक्षा-for-it.sh सुविधा के बारे में कोई स्पष्टीकरण नहीं है।
छोड़ दिया

7

आप इसे एक समापन बिंदु सेट करके भी हल कर सकते हैं, जो कि नेटकैट (docker- वेट स्क्रिप्ट का उपयोग करके ) सेवा की प्रतीक्षा करता है । मुझे यह दृष्टिकोण पसंद है क्योंकि आपके पास अभी भी एक साफ commandखंड है docker-compose.ymlऔर आपको अपने आवेदन में 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

यह आजकल सरकारी डॉक्यूमेंट डॉक्यूमेंटेशन में प्रलेखित है

PS: netcatयदि यह उपलब्ध नहीं है, तो आपको अपने docker इंस्टेंस में स्थापित करना चाहिए । ऐसा करने के लिए इसे अपनी Dockerफ़ाइल में जोड़ें :

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

4

" डॉकटर-वेट " नामक उपयोगिता का उपयोग करने के लिए तैयार है जिसे प्रतीक्षा के लिए इस्तेमाल किया जा सकता है।


1
धन्यवाद, लेकिन यह केवल एक शेल स्क्रिप्ट है इसलिए यह h3nrik जवाब या अजगर के अंदर इंतजार करने जैसा है। यह खुद को बनाने वाले की विशेषता नहीं है। आपके पास github.com/docker/compose/issues/374 में एक नज़र हो सकता है कि वे एक स्वास्थ्य परीक्षण लागू करने की योजना बना रहे हैं जो सबसे अच्छा तरीका होगा। एक खुला tcp कनेक्शन का मतलब यह नहीं है कि आपकी सेवा तैयार है या तैयार रह सकती है। इसके अलावा मुझे अपने डॉकटराइल में अपना प्रवेश बिंदु बदलना होगा।
svenhornberg

3

कई अलग-अलग तरीकों की कोशिश की, लेकिन इस की सादगी को पसंद किया: https://github.com/ufoscout/docker-compose-wait

यह विचार कि आप ई-वी वीआर का उपयोग डॉक कंपोज़ फाइल में कर सकते हैं सेवाओं की एक सूची प्रस्तुत करने के लिए होस्ट (बंदरगाहों के साथ) जिसे इस तरह "प्रतीक्षित" किया जाना चाहिए WAIT_HOSTS: postgres:5432, mysql:3306, mongo:27017:।

तो मान लें कि आपके पास निम्नलिखित docker-compose.yml फ़ाइल है (प्रतिलिपि / पिछले 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

इसके बाद, सेवाओं की प्रतीक्षा करने के लिए, आपको अपने डॉकरएफ़ाइल्स में निम्नलिखित दो पंक्तियों को जोड़ने की आवश्यकता है (सेवाओं की डॉकरीफ़ाइल में जो शुरू करने के लिए अन्य सेवाओं की प्रतीक्षा करनी चाहिए):

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

इस तरह के नमूने Dockerfile (परियोजना रेपो 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 देखें


मैं सिमिनेटिव जवाब की तलाश में था। मैंने आमतौर पर hub.docker.com/r/dadarek/wait-for-d dependencies के साथ काम किया है क्योंकि यह नीचे की तरफ नेटकट का उपयोग करता है। जो आपने प्रदान किया है वह रस्ट-आधारित है। आप की गुणवत्ता पर टिप्पणी नहीं कर सकते, लेकिन मेरे लिए कोई अतिरिक्त परत एक निश्चित समर्थक नहीं है।
फिलिप मालकक

1
मैं सुरक्षा के आधार पर इसके खिलाफ पुरजोर सिफारिश करता हूं। आप हाइपरलिंक से एक मनमाना निष्पादन योग्य चला रहे हैं। एक बेहतर समाधान एक स्थिर स्क्रिप्ट के साथ एक ही काम करना होगा जो कि COPY के साथ छवि में कॉपी किया गया है
पॉल के

@PaKK बेशक, यह समझ में आता है कि हाइपरलिंक से कुछ भी चलाना सुरक्षित नहीं है, लेकिन यह सिर्फ एक डेमो है कि कैसे https://github.com/ufoscout/docker-compose-waitलाइब्रेरी को काम करना है :) जिस तरह से आप उस लाइब्रेरी का उपयोग करते हैं वह एक उत्तर को नहीं बदलता है जिससे आप कुछ काम का उपयोग कर सकते हैं। सुरक्षा एक जटिल विषय है और अगर हम बहुत दूर जाते हैं, तो हमें यह देखना चाहिए कि पुस्तकालय वैसे भी क्या कर रहा है, भले ही हम इसे कॉपी करें :) आपकी टिप्पणी में अधिक विशिष्ट होना बेहतर है जैसे: "मैं उस पुस्तकालय के उपयोग के खिलाफ दृढ़ता से अनुशंसा करता हूं हाइपरलिंक से ”। आशा है कि आप सहमत हैं, एक संकेत के लिए धन्यवाद!
एवरेक

2

इस ब्लॉग पोस्ट को आधार बनाते हुए https://8thlight.com/blog/dariusz-pasciak/2016/10/17/docker-compose-wait-for-d 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होगी, काम पूरा करेगी।


lol, क्वेरी बनाने के "curl", "-f", "http://localhost:15672"लिए जिसके माध्यम से यू को managementप्लगइन स्थापित करने और हेल्थचेक का उपयोग करने की आवश्यकता है जो पहले से ही पदावनत है - इसका सबसे अच्छा जवाब। ncइसके डाउनवोट के माध्यम से चेक के साथ सरल कार्य उदाहरण । हा, ठीक है ...
इगोर कोमर

यदि आप कर्ल, एनसी या अन्य साधनों का उपयोग करते हैं, तो इसका उत्तर एक देशी डॉकटर सुविधा का उपयोग नहीं करता है। जबकि! nc वही है जो पहले से ही अन्य उत्तरों में पोस्ट किया गया है।
svenhornberg


1
@IgorKomar, धन्यवाद आदमी, आपने मेरा दिन बचा लिया! : 3 मैं वास्तविक आवेदन शुरू होने से पहले mysql सर्वर तैयार करने के लिए लगभग एक ही मैकेनिक का उपयोग करता था। ;) मैं इसी तरह के आदेश को पारित कर रहा हूंdocker-compose run --name app-test --rm "app" bash -l -c 'echo Waiting for mysql service start... && while ! nc -z db-server 3306; do sleep 1; done && echo Connected! && /bin/bash /script/ci_tests.sh'
TooroSan

1

डॉकर कंपोज़ फ़ाइल के संस्करण 3 में, आप RESTART का उपयोग कर सकते हैं ।

उदाहरण के लिए:

डोकर-compose.yml

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

ध्यान दें कि मैंने उपयोग किया था links_on के बजाय लिंक के बाद से संस्करण 3 में पदावनत किया गया है।

भले ही यह काम करता है, यह आदर्श समाधान नहीं हो सकता है क्योंकि आप हर विफलता पर डॉकटर कंटेनर को पुनरारंभ करते हैं।

करने के लिए एक नज़र RESTART_POLICY रूप में अच्छी तरह। यह आपको पुनः आरंभ करने की नीति को ठीक करने देता है।

जब आप उत्पादन में कम्पोज़ का उपयोग करते हैं , तो असल में रीस्टार्ट पॉलिसी का उपयोग करना सबसे अच्छा अभ्यास है:

पुनरारंभ की तरह एक पुनरारंभ नीति निर्दिष्ट करना: हमेशा डाउनटाइम से बचने के लिए


0

वैकल्पिक समाधान में से एक कुबेरनेट्स जैसे कंटेनर ऑर्केस्ट्रेशन समाधान का उपयोग करना है। कुबेरनेट्स के पास इनिट कंटेनर के लिए समर्थन है जो अन्य कंटेनरों को शुरू करने से पहले पूरा करने के लिए चलता है। आप SQL सर्वर 2017 लिनक्स कंटेनर के साथ यहां एक उदाहरण पा सकते हैं जहां एपीआई कंटेनर एक डेटाबेस को इनिशियलाइज़ करने के लिए init कंटेनर का उपयोग करता है

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


0

यहाँ उदाहरण है कि mainकंटेनर 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)।


0

गंभीर तैनाती के लिए अनुशंसित नहीं है, लेकिन यहां अनिवार्य रूप से "प्रतीक्षा एक्स सेकंड" कमांड है।

docker-composeसंस्करण के साथ 3.4एक start_periodनिर्देश जोड़ा गया है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

यहां क्या होता है कि healthcheck5 सेकंड के बाद लागू किया जाता है। यह status.shस्क्रिप्ट को कॉल करता है , जो हमेशा "कोई समस्या नहीं" देता है। हमने अभी zmq_clientशुरू होने से 5 सेकंड पहले कंटेनर प्रतीक्षा की!

नोट: यह महत्वपूर्ण है कि आपके पास है version: "3.4"। अगर .4वहाँ नहीं है, docker- रचना शिकायत करता है।


1
एक भोली "प्रतीक्षा 5 एस" समाधान के रूप में, यह काफी सरल है। मैं उत्थान करूंगा, लेकिन मैं ऐसा नहीं करूंगा क्योंकि यह वास्तव में ठेस लगाने वाले सेटअपों के साथ काम नहीं करता है और मुझे डर है कि कोई व्यक्ति ध्यान से पढ़ने के बजाय वोटों की संख्या को देखेगा। फिर भी, मैं कहना चाहता था "आदमी, वह स्मार्ट है";)
फ़िलिप मालकक

पुनश्च। अधिक जटिल समाधानों के लिए, एवरेक का उत्तर देखें
फिलिप मालकक

ऐसा इसलिए है नहीं क्या start_periodकरता है। उस कॉन्फ़िगरेशन का मतलब है कि एक अनुग्रह अवधि है जहां विफल स्वास्थ्य जांचों की गिनती के रूप में गणना नहीं की जाती है। यदि यह जल्दी सफल होता है, तो इसे स्वस्थ माना जाता है। शुरुआत की अवधि के बाद, एक विफलता एक रिट्री के रूप में गिना जाएगा। देखें docs.docker.com/engine/reference/builder/#healthcheck
पूंजी Etheriel

-4

मेरे पास अभी 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

यह एक अच्छा अभ्यास नहीं माना जाता है। आप एक रचना फ़ाइल से कई conatiners से मिलकर समाधान वितरित नहीं कर सकते।
जूही
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.