काम पर हम अपनी निर्भर सेवाओं को एक स्क्रिप्ट में लपेटते हैं जो यह जांचता है कि लिंक अभी तक है या नहीं। मुझे पता है कि मेरे एक साथी को भी इसमें दिलचस्पी होगी! व्यक्तिगत रूप से मुझे लगता है कि सेवाओं के उपलब्ध होने की प्रतीक्षा करना एक कंटेनर-स्तर की चिंता है, लेकिन मैं गलत हो सकता हूं :)

हम रैपिंग के साथ एक ही काम करते हैं। आप यहां एक उदाहरण देख सकते हैं: https://github.com/dominionenterprise/tol-api-php/blob/master/tests/provisioning/set-env.sh

यह एक एंट्रीपॉइंट स्क्रिप्ट होना आसान होगा जो सभी लिंक पर लूप करता है और जब तक वे इसे पास करने से पहले कमांड को शुरू करने से पहले काम कर रहे हैं, तब तक इंतजार करते हैं।

यह डॉकटर को ही बनाया जाना चाहिए, लेकिन समाधान एक रास्ता है। एक कंटेनर को तब तक शुरू नहीं माना जाना चाहिए जब तक कि यह लिंक खुल न जाए।

@ बफिरश मैं कल्पना कर रहा था की तुलना में अधिक है, लेकिन उत्कृष्ट होगा।

एक कंटेनर को तब तक शुरू नहीं माना जाना चाहिए जब तक कि यह लिंक खुल न जाए।

मुझे लगता है कि वास्तव में लोगों को इसकी आवश्यकता है।

अभी के लिए, मैं https://github.com/aanand/docker-wait पर एक बदलाव का उपयोग करूंगा

हाँ, मुझे इस तरह से कुछ करने में दिलचस्पी होगी - इसका मतलब पहले इसके बारे में पोस्ट करना था।

सबसे छोटा प्रभाव पैटर्न जिसके बारे में हम सोच सकते हैं कि यह हमारे लिए ठीक होगा, निम्नलिखित होगा:

एक नई कुंजी के रूप में "प्रतीक्षा" को अंजीर में जोड़ें। लिंक के समान मूल्य शब्दार्थ के साथ। डॉकर इसे पूर्व-आवश्यकता के रूप में मानेगा और इस कंटेनर को ले जाने से पहले बाहर निकलने तक प्रतीक्षा करें।

इसलिए, मेरी डॉक फ़ाइल कुछ इस तरह दिखाई देगी:

db:
  image: tutum/mysql:5.6

initdb:
  build: /path/to/db
  link:
    - db:db
  command: /usr/local/bin/init_db

app:
  link:
    - db:db
  wait:
    - initdb

रनिंग ऐप पर, यह सभी लिंक कंटेनर शुरू करेगा, फिर प्रतीक्षा कंटेनर चलाएगा और प्रतीक्षा कंटेनर (initdb) से बाहर निकलने के बाद केवल वास्तविक ऐप कंटेनर में प्रगति करेगा। initdb एक स्क्रिप्ट चलाएगा जो डेटाबेस के उपलब्ध होने का इंतजार करता है, फिर कोई भी इनिशियलाइज़ेशन / माइग्रेशन / जो भी हो, चलाता है।

वैसे भी मेरे विचार हैं।

(संशोधित, नीचे देखें)

यहां भी +1। यह बहुत ही अपील करने के लिए खुद को आदेशों में ऐसा नहीं है।

साथ ही +1। बस इस मुद्दे में भाग गया। महान उपकरण btw, मेरे जीवन को इतना आसान बनाता है!

+1 करना बहुत अच्छा होगा।

+1 भी। हाल ही में समस्याओं के एक ही सेट में चला गया

+1 भी। dockerguys से कोई बयान?

मैं वर्तमान समय में सिंक्रनाइज़ करने के लिए रैपर स्क्रिप्ट के रूप में रैपर स्क्रिप्ट लिख रहा हूं, सुनिश्चित नहीं है कि अंजीर में एक तंत्र होने पर बुद्धिमान है यदि आपके पास अपने कंटेनरों के लिए अन्य लक्ष्य हैं जो ऑर्केस्ट्रेशन एक अलग तरीके से करते हैं। मेरे लिए बहुत ही विशिष्ट अनुप्रयोग लगता है, जैसे कि काम करने वाले कंटेनरों की जिम्मेदारी।

कुछ विचार और प्रयोग के बाद मैं इससे सहमत हूं।

इस तरह के एक आवेदन के रूप में मैं मूल रूप से निर्माण कर रहा हूँ एक तुल्यकालिक है
waforfor (होस्ट, पोर्ट) फ़ंक्शन जो मुझे एप्लिकेशन की सेवाओं की प्रतीक्षा करता है
पर निर्भर करता है (या तो पर्यावरण के माध्यम से या स्पष्ट रूप से पता चला है
cli विकल्पों के माध्यम से विन्यास)।

चियर्स
जेम्स

जेम्स मिल्स / प्रोलोगिक

E: [email protected]
डब्ल्यू: prologic.shortcircuit.net.au

शुक्र पर, 22 अगस्त 2014 को शाम 6:34 बजे, मार्क स्टुअर्ट नोटिफिकेशन @github.com
लिखा था:

मैं वर्तमान समय में सिंक्रनाइज़ करने के लिए रैपर स्क्रिप्ट लिख रहा हूं,
सुनिश्चित करें कि अगर अंजीर में एक तंत्र है अगर आप के लिए अन्य लक्ष्य हैं तो समझदार नहीं है
आपके कंटेनर जो एक अलग तरीके से ऑर्केस्ट्रेशन करते हैं। बहुत लगता है
कंटेनरों की जिम्मेदारी के रूप में मेरे लिए विशिष्ट अनुप्रयोग
काम कर रहा है।

-
इस ईमेल का उत्तर सीधे दें या इसे GitHub पर देखें
https://github.com/docker/fig/issues/374#issuecomment -53036154

हाँ कुछ बुनियादी "यहाँ पर निर्भर" पर निर्भर ...
इसलिए यदि आपके पास 20 कंटेनर हैं, तो आप अंदाजा नहीं लगा सकते हैं और सब कुछ सही क्रम से शुरू होता है ...
हालाँकि इसके पास कुछ टाइमआउट विकल्प या अन्य विफलता पकड़ने वाले तंत्र भी हैं

एक और +1 यहाँ। मैं Django से अधिक समय लेने के लिए Postgres है ताकि DB हैकिंग के बिना माइग्रेशन कमांड के लिए नहीं है।

@ahknight दिलचस्प है, run दौरान माइग्रेशन क्यों चल रहा है?

क्या आप build चरण के दौरान वास्तव में माइग्रेट नहीं करना चाहते हैं? इस तरह आप बहुत तेजी से ताजा छवियों को स्टार्टअप कर सकते हैं।

प्रश्न में आवेदन के लिए एक बड़ा स्टार्टअप स्क्रिप्ट है, अफसोस। अभी के लिए, हम गैर-डीबी कार्य पहले कर रहे हैं, डीबी के लिए प्रतीक्षा करने के लिए लूप में nc -w 1 का उपयोग कर रहे हैं, फिर डीबी कार्रवाई कर रहे हैं। यह काम करता है, लेकिन यह मुझे गंदा (एर) महसूस कराता है।

मुझे fig build चरण के दौरान यह काम करने में बहुत सफलता मिली है। मैं एक django परियोजना (अभी भी प्रगति के माध्यम से एक काम) के साथ इसका एक उदाहरण है: https://github.com/dnephin/readthedocs.org/blob/fig-demo/dockerfiles/database-Dockerfile#L21

स्टार्टअप के लिए चुनाव की आवश्यकता नहीं है। हालाँकि मैंने mysql के साथ कुछ ऐसा ही किया है, जहाँ मुझे स्टार्टअप के लिए चुनाव करना था क्योंकि mysqld init स्क्रिप्ट पहले से ही ऐसा नहीं कर रही थी। यह इनगिट स्क्रिप्ट बहुत बेहतर लगती है।

यहाँ मैं क्या सोच रहा था:

Docker / docker # 7445 के विचार का उपयोग करके हम अंजीर में इस "wa_for_helth_check" विशेषता को लागू कर सकते हैं?
तो यह एक डॉक नहीं मुद्दा होगा?

वहाँ वैसे भी जुड़ा कंटेनर पर tcp स्थिति की जाँच करने के लिए अंजीर बना रहा है, अगर ऐसा है तो मुझे लगता है कि यह जाने का रास्ता है। =)

@dnephin क्या आप थोड़ा और समझा सकते हैं कि आप इसकी मदद करने के लिए डॉकरीफाइल्स में क्या कर रहे हैं?
क्या बिल्ड चरण रनटाइम को प्रभावित करने में असमर्थ है?

@docteurklein मैं कर सकता हूं। मैंने ऊपर से लिंक तय किया (https://github.com/dnephin/readthedocs.org/blob/fig-demo/dockerfiles/database/Dockerfile#L21)

विचार यह है कि आप निर्माण के दौरान सभी धीमी "सेटअप" संचालन करते हैं, इसलिए आपको कंटेनर स्टार्टअप के दौरान कुछ भी इंतजार नहीं करना होगा। डेटाबेस या खोज सूचकांक के मामले में, आप निम्न कार्य करेंगे:

1. सेवा शुरू करें
2. उपयोगकर्ता, डेटाबेस, तालिकाओं और स्थिरता डेटा बनाएँ
3. सेवा बंद करें

सभी एक निर्माण कदम के रूप में। बाद में जब आप fig up डेटाबेस कंटेनर को मूल रूप से तुरंत जाने के लिए तैयार हो जाते हैं, और आपको इन धीमे संचालन के लिए डॉक बिल्ड कैश का लाभ उठाना होगा।

अच्छा! धन्यवाद :)

@dnephin अच्छा, ऐसा नहीं सोचा था।

+1 यह निश्चित रूप से आवश्यक है।
एक बदसूरत समय देरी हैक ज्यादातर मामलों में पर्याप्त होगा, लेकिन एक _real_ समाधान का स्वागत किया जाएगा।

क्या आप इसका एक उदाहरण दे सकते हैं कि क्यों / कब इसकी आवश्यकता है?

मेरे पास उपयोग के मामले में, मेरे पास एक इलास्टिक्स खोज सर्वर है और फिर एक एप्लिकेशन सर्वर है जो एलिटिक्स खोज से जुड़ रहा है। इलास्टिसर्च को स्पिन करने में कुछ सेकंड लगते हैं, इसलिए मैं केवल एक fig up -d क्योंकि एलिस्टिक्स खोज सर्वर से कनेक्ट होने पर एप्लिकेशन सर्वर तुरंत विफल हो जाएगा।

कहते हैं कि एक कंटेनर MySQL शुरू करता है और दूसरा एक ऐप शुरू करता है, जिसे MySQL की आवश्यकता होती है और यह पता चलता है कि दूसरा ऐप तेजी से शुरू होता है। हमारे पास क्षणिक fig up असफलताएँ हैं।

क्रेन के पास एक ऐसा तरीका है जिससे आप व्यक्तिगत रूप से शुरू किए जा सकने वाले समूह बना सकते हैं। तो आप MySQL समूह को शुरू कर सकते हैं, 5 सेकंड प्रतीक्षा कर सकते हैं और फिर उस पर निर्भर अन्य सामान को शुरू कर सकते हैं।
छोटे पैमाने पर काम करता है, लेकिन वास्तविक समाधान नहीं।

@oskarhane को यकीन नहीं है कि अगर यह "5 सेकंड प्रतीक्षा करें" मदद करता है, तो कुछ मामलों में अधिक प्रतीक्षा करने की आवश्यकता हो सकती है (या यह सुनिश्चित नहीं किया जा सकता है कि यह 5 सेकंड से अधिक नहीं होगा) ... यह बहुत सुरक्षित नहीं है समय के इंतजार पर भरोसा करें।
इसके अलावा, आपको मैन्युअल रूप से इस प्रतीक्षा और दूसरे समूह को लोड करना होगा, और यह एक प्रकार का लंगड़ा है, अंजीर को आपके लिए ऐसा करना चाहिए / =

@oskarhane , @dacort , @ddossot : ध्यान रखें कि, वास्तविक दुनिया में, चीजें क्रैश और रीस्टार्ट होती हैं, नेटवर्क कनेक्शन आते हैं और जाते हैं, आदि चाहे अंजीर टीसीपी सॉकेट पर प्रतीक्षा करने के लिए एक सुविधा का परिचय देता है या नहीं, आपके कंटेनर होना चाहिए कनेक्शन विफलताओं के लिए लचीला। इस तरह वे हर जगह ठीक से काम करेंगे।

आप सही हैं, लेकिन जब तक हम सभी महत्वपूर्ण मौजूदा ऐप को ठीक करने के लिए अपने महत्वपूर्ण संसाधनों (जैसे DB) की अनुपस्थिति से शुरू होने पर (जो कि एक महान बात है ™) लेकिन दुर्भाग्य से शायद ही कभी फ्रेमवर्क द्वारा समर्थित शायद ही कभी ठीक हो जाए, जैसे काम करना चाहिए। fig start बजाय देरी के साथ, एक निश्चित क्रम में व्यक्तिगत कंटेनर शुरू करने के लिए fig up ।

मैं एक शेल स्क्रिप्ट देख सकता हूँ जो अंजीर को नियंत्रित करने के लिए नियंत्रित करने के लिए आ रही है: पलक:

मैं अंजीर में नहीं बनाया जा रहा है के साथ ठीक हूँ, लेकिन तत्परता पर इंतजार करने के लिए सबसे अच्छा अभ्यास पर कुछ सलाह अच्छा होगा

मैंने पहले की टिप्पणी से जुड़े कुछ कोड में यह किया था:

while ! exec 6<>/dev/tcp/${MONGO_1_PORT_27017_TCP_ADDR}/${MONGO_1_PORT_27017_TCP_PORT}; do
    echo "$(date) - still trying to connect to mongo at ${TESTING_MONGO_URL}"
    sleep 1
done

मेरे मामले में कोई /dev/tcp रास्ता नहीं है, हो सकता है कि यह एक अलग Linux डिस्ट्रो (?) है - मैं उबंटू में हूँ

मैंने इस विधि के बजाय पाया जो ठीक लगता है:

until nc -z postgres 5432; do
    echo "$(date) - waiting for postgres..."
    sleep 1
done

यह काम करने लगता है, लेकिन मुझे पता नहीं है कि ऐसी चीजों के बारे में अगर यह मजबूत है ... किसी को भी पता है कि क्या वहाँ पोर्ट के बीच एक संभावित दौड़ की स्थिति nc और सर्वर _really_ स्वीकार करने में सक्षम है आदेशों?

मुझे खुशी होगी अगर चेक को पलटना संभव था - आश्रित कंटेनरों से मतदान के बजाय, क्या यह संभव है कि टारगेट (यानी पोस्टग्रेज सर्वर) कंटेनर से सभी आश्रितों को एक संकेत भेजना संभव है?

शायद यह एक मूर्खतापूर्ण विचार है, किसी के पास कोई विचार है?

@anentropic Docker लिंक एक तरफ़ा हैं, इसलिए वर्तमान में डाउनस्ट्रीम कंटेनर से मतदान करना एकमात्र तरीका है।

क्या किसी को पता है कि वहाँ पोर्ट के बीच एक संभावित दौड़ की स्थिति है जो nc को दिखा रहा है और सर्वर को वास्तव में कमांड स्वीकार करने में सक्षम है?

सामान्य मामले में पता करने का कोई तरीका नहीं है - यह पोस्टग्रेज के लिए सच हो सकता है, यह अन्य सेवाओं के लिए गलत हो सकता है - जो कि अंजीर में नहीं करने के लिए एक और तर्क है।

@आनंद मैंने आपके

मुझे उम्मीद थी कि ओरिएंटडब के लिए प्रतीक्षा कंटेनर को जोड़ने से मुझे यह त्रुटि नहीं दिखाई देगी। लेकिन दुर्भाग्य से मैं अभी भी इसे बेतरतीब ढंग से प्राप्त कर रहा हूं। यहाँ मेरा सेटअप है (डॉक वर्जन १.४.१, एक Ubuntu १४.०४ बॉक्स पर १०:३०):

orientdb:
    build: ./Docker/orientdb
    ports:
        -   "2424:2424"
        -   "2480:2480"
wait:
    build: ./Docker/wait
    links:
        - orientdb:orientdb
....
core:
    build:  ./Docker/core
    ports:
        -   "3000:3000"
    links:
        -   orientdb:orientdb
        -   nsqd:nsqd

किसी भी मदद की सराहना की है। धन्यवाद।

@mindnuts wait छवि एक प्रदर्शन की अधिक है; यह fig.yml में उपयोग के लिए उपयुक्त नहीं है। आप अपने में उसी तकनीक (बार-बार मतदान) का उपयोग करना चाहिए core के लिए प्रतीक्षा करने कंटेनर orientdb कंटेनर मुख्य प्रक्रिया बंद लात से पहले शुरू करने के लिए।

+1 ने अभी इसमें भाग लेना शुरू किया क्योंकि मैं कस्टम निर्मित छवियों को खींच रहा हूं। उन्हें अंजीर में निर्माण कर रहा हूं। नोड ऐप विफल हो रहा है क्योंकि मोंगोडब अभी तैयार नहीं है ...

मैंने सिर्फ यह डिबगिंग में घंटों बिताए कि क्यों वर्ड के साथ मैन्युअल रूप से वर्डप्रेस शुरू करते समय MySQL पहुंच रहा था, और यह अंजीर से शुरू होने पर ऑफ़लाइन क्यों था। केवल अब मुझे एहसास हुआ कि जब भी मैं आवेदन शुरू करता हूं, तो Fig हमेशा MySQL कंटेनर को पुनरारंभ करता है, इसलिए वर्डप्रेस प्रविष्टि। अभी तक MySQL से कनेक्ट नहीं हो पा रहा है।

मैंने अपनी स्वयं की ओवरराइड की गई प्रविष्टिबिंदु को जोड़ा है। वास्तविक प्रविष्टि को निष्पादित करने से पहले 5 सेकंड तक प्रतीक्षा करता है। लेकिन स्पष्ट रूप से यह एक उपयोग का मामला है, जिसे एक सामान्य समाधान की आवश्यकता है, अगर डॉकर / अंजीर के साथ एक MySQL + वर्डप्रेस कंटेनर संयोजन लॉन्च करना आसान होना चाहिए।

इसलिए WordPress entrypoint.sh की मृत्यु अभी तक MySQL से जुड़ने में सक्षम नहीं है।

मुझे लगता है कि यह वर्डप्रेस कंटेनर के साथ एक मुद्दा है।

जबकि मैं शुरू में इस विचार का प्रशंसक था, https://github.com/docker/docker/issues/7445#issuecomment -56391294 पढ़ने के बाद, मुझे लगता है कि इस तरह की सुविधा गलत दृष्टिकोण होगी, और वास्तव में बुरी प्रथाओं को प्रोत्साहित करती है।

ऐसा प्रतीत होता है कि दो मामले हैं जो इस मुद्दे को संबोधित करते हैं:

कुछ प्रारंभ करने के लिए एक निर्भरता सेवा उपलब्ध होनी चाहिए।

किसी भी कंटेनर आरंभीकरण को वास्तव में build दौरान किया जाना चाहिए। इस तरह यह कैश हो गया है, और काम को छवि के प्रत्येक उपयोगकर्ता द्वारा दोहराने की आवश्यकता नहीं है।

एक निर्भरता सेवा उपलब्ध होनी चाहिए ताकि एक कनेक्शन खोला जा सके

आवेदन को वास्तव में कनेक्शन विफलताओं के लिए लचीला होना चाहिए और कनेक्शन को वापस लेना चाहिए।

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

समस्या वास्तव में बहुत कम अप्रिय होगी यदि अंजीर ने हमेशा कंटेनर (यानी डेटाबेस सर्वर) को एप्लिकेशन कंटेनर को पुनरारंभ करते समय पुनरारंभ नहीं किया। मैं वास्तव में नहीं जानता कि ऐसा क्यों होता है।

समस्या वास्तव में बहुत कम अप्रिय होगी यदि अंजीर ने हमेशा कंटेनर (यानी डेटाबेस सर्वर) को एप्लिकेशन कंटेनर को पुनरारंभ करते समय पुनरारंभ नहीं किया। मैं वास्तव में नहीं जानता कि ऐसा क्यों होता है।

वास्तव में यह सिर्फ _restart_ कंटेनरों में नहीं होता है, यह _destroys और इन्हें पुनः बनाता है, क्योंकि यह fig.yml सुनिश्चित परिवर्तन करने का सबसे सरल तरीका है। हमें अंतत: एक होशियार समाधान लागू करना चाहिए जो "वर्तमान कॉन्फ़िगरेशन" की तुलना "वांछित कॉन्फ़िगरेशन" के साथ कर सकता है और केवल वही बदल सकता है जो बदल गया है।

मूल मुद्दे पर वापस जाना, मुझे वास्तव में यह नहीं लगता है कि कंटेनरों से कनेक्शन की पुनरावृत्ति तर्क की अपेक्षा करना अवास्तविक है - यह वितरित प्रणाली को डिजाइन करने के लिए मौलिक है जो काम करता है। यदि अलग-अलग स्क्रिप्ट को साझा करने की आवश्यकता है, तो इसे एक निष्पादन योग्य (या भाषा-विशिष्ट मॉड्यूल यदि आप शेल का उपयोग नहीं कर रहे हैं) में विभाजित किया जाना चाहिए, इसलिए प्रत्येक स्क्रिप्ट शीर्ष पर waitfor db कर सकती है।

@kennu --no-recreate बारे में क्या? / cc @aanand

@ नानंद का मतलब था कि

व्यक्तिगत रूप से मैं बल्कि कंटेनर / छवियों को सरल रखना चाहूंगा और अंतर्निहित प्रणाली को निर्भरता के समाधान के बारे में चिंता करने दूंगा। वास्तव में, डॉकर की पुनरारंभ नीति पहले से ही सब कुछ हल कर सकती है (यदि एप्लिकेशन कंटेनर डेटाबेस से कनेक्ट करने में विफल रहता है, तो यह पुनरारंभ हो जाएगा और डेटाबेस उपलब्ध होने तक फिर से प्रयास करेगा)।

लेकिन पुनरारंभ नीति पर भरोसा करने का मतलब है कि इसे डिफ़ॉल्ट रूप से सक्षम किया जाना चाहिए, या अन्यथा लोग समस्या को डीबग करने में घंटों बिताते हैं (जैसे मैंने अभी किया था)। फली के लिए RestartPolicyAlways को एग कुबेरनेट्स डिफॉल्ट करता है।

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

सभी डॉकटर छवियों को बदलने की उम्मीद करते हैं और पूरे समुदाय कनेक्शन को लागू करते हैं पुन: प्रयास अभ्यास उचित नहीं है

ऐसा नहीं है कि डॉकटर या अंजीर के कारण किसी एप्लिकेशन को फिर से प्रयास करना चाहिए। अनुप्रयोगों को गिराए गए कनेक्शन के लिए लचीला होना चाहिए क्योंकि नेटवर्क विश्वसनीय नहीं है । किसी भी एप्लिकेशन को पहले से ही इस तरह बनाया जाना चाहिए।

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

यदि आप यह सुनिश्चित करते हैं कि सभी आरंभीकरण "बिल्ड" चरण के दौरान होता है, और यह कि कनेक्शन अगले अनुरोध पर फिर से स्थापित हो जाते हैं तो आपको फिर से प्रयास करने की आवश्यकता नहीं होगी (या अन्य कंटेनरों के शुरू होने की प्रतीक्षा करें)। यदि कनेक्शन उत्सुकता से (स्टार्टअप के दौरान) के बजाय आलसी (जब पहला अनुरोध किया जाता है) खोले जाते हैं, तो मुझे संदेह है कि आपको बिल्कुल भी पीछे हटने की आवश्यकता नहीं होगी।

समस्या क्रम में है [अंजीर] बातें करता है

मुझे अब तक इस चर्चा में इसका कोई उल्लेख नहीं मिला। अंजीर में निर्दिष्ट लिंक के आधार पर स्टार्टअप ऑर्डर करता है, इसलिए इसे हमेशा सही क्रम में कंटेनर शुरू करना चाहिए। क्या आप एक परीक्षण मामला प्रदान कर सकते हैं जहां आदेश गलत है?

मुझे यहां @dnephin से सहमत

कम्पोज़ / अंजीर ये निर्णय नहीं ले सकता है, और निगरानी सेवाओं को कंटेनर के अंदर चलने वाले अनुप्रयोगों की जिम्मेदारी होनी चाहिए।

मैं सुझाव देना चाहूंगा कि

मैं वर्डप्रेस इनिशियलाइज़ेशन का उदाहरण भी दोहराना चाहूंगा: यह एक स्टार्टअप शेल स्क्रिप्ट चलाता है जो एक नया डेटाबेस बनाता है यदि MySQL कंटेनर में अभी तक यह नहीं है (डॉक छवि बनाते समय ऐसा नहीं किया जा सकता है, क्योंकि यह निर्भर है। बाहरी रूप से माउंटेड डेटा वॉल्यूम)। इस तरह की स्क्रिप्ट काफी जटिल हो जाती है अगर इसे "डेटाबेस अभी तैयार नहीं है" त्रुटियों से सामान्य डेटाबेस त्रुटियों को अलग करना है और शेल स्क्रिप्ट के भीतर कुछ सेंस रिट्री लॉजिक को लागू करना है। मैं यह अत्यधिक संभावना मानता हूं कि छवि के लेखक वास्तव में उक्त दौड़ की स्थिति के खिलाफ स्टार्टअप स्क्रिप्ट का परीक्षण नहीं करेंगे।

फिर भी, डॉकर की अंतर्निहित पुनरारंभ नीति इसके लिए एक समाधान प्रदान करती है, यदि आप यह स्वीकार करने के लिए तैयार हैं कि कंटेनर छिटपुट रूप से शुरू करने में विफल हैं और नियमित रूप से लॉग में त्रुटियों को प्रिंट करते हैं। (और अगर आपको इसे चालू करना याद है।)

निजी तौर पर, मैं अंजीर ऑटोडेक्ट बनाकर, जो कंटेनर पोर्ट एक लिंक्ड कंटेनर के संपर्क में हैं, लिंक कंटेनर को शुरू करने से पहले पिंग करके (एक समय सीमा के साथ), और अंततः एक कार्यक्षमता को ओवरराइड / अक्षम करने के लिए कॉन्फ़िगरेशन सेटिंग प्रदान करता हूं।

डॉकर छवि बनाते समय ऐसा नहीं किया जा सकता है, क्योंकि यह बाहरी रूप से माउंट किए गए डेटा वॉल्यूम पर निर्भर है

सच। यहाँ एक दृष्टिकोण डेटाबेस डेटाबेस को आरंभ करने के लिए (यदि आवश्यक हो, एक अलग प्रविष्टि बिंदु / कमांड के साथ) एक बार सिर्फ डेटाबेस कंटेनर शुरू करना है, या डेटाबेस के लिए डेटा-केवल कंटेनर का उपयोग करना है, जो डेटाबेस कंटेनर के रूप में एक ही छवि से बनाया गया है।

ऐसी स्क्रिप्ट काफी जटिल हो जाती है अगर उसे "डेटाबेस अभी तक तैयार नहीं है" त्रुटियों से सामान्य डेटाबेस त्रुटियों को अलग करना है

कम्पोज़ / अंजीर वहाँ एक ही मुद्दे में चलेगा; MySQL अप होने पर कैसे जांचें, और _accepting_ कनेक्शन? (और PostgreSQL, और (_ अपनी सेवा यहाँ_) दर्ज करें)। इसके अलावा, _where_ को "पिंग" से निष्पादित किया जाना चाहिए? कंटेनर के अंदर आप होस्ट से शुरू कर रहे हैं?

जहां तक ​​मैं बता सकता हूं, आधिकारिक वर्डप्रेस छवि में यह देखने के लिए एक चेक शामिल है कि क्या MySQL docker-entrypoint.sh में कनेक्शन स्वीकार कर रहा है या नहीं?

@thaJeztah "MySQL कनेक्शन त्रुटियों के लिए PHP में कुछ सरल पुनर्प्रयास तर्क जोड़ें" tianon द्वारा लिखित 2 दिन - नाइस। :-) कौन जानता है, शायद यह सब के बाद एक मानक दृष्टिकोण बन जाएगा, लेकिन मुझे अभी भी मेरी शंका है, विशेष रूप से इस तरह के पुन: कार्यान्वयन के बारे में वास्तव में सभी छवि लेखकों द्वारा परीक्षण किया जा रहा है।

पोर्ट पिंगिंग के बारे में - मैं यह नहीं कह सकता कि इष्टतम कार्यान्वयन क्या होगा। मुझे लगता है कि ECONNREFUSED प्राप्त करते समय एक अस्थायी लिंक्ड कंटेनर से पुन: सरल कनेक्शन की जाँच हो सकती है। जो भी समस्याओं का 80% (या संभवतः 99%) हल करता है, इसलिए उपयोगकर्ताओं को हर बार फिर से उन्हें स्वयं से हल करने की आवश्यकता नहीं है।

@kennu आह! धन्यवाद, यह अभी हाल ही में जोड़ा गया था पता नहीं था, बस इस चर्चा के कारण अब स्क्रिप्ट की जाँच की।

स्पष्ट होने के लिए, मुझे समझ में आ रहा है कि आप जो समस्याएँ हैं, लेकिन मुझे यकीन नहीं है कि Compose / Fig उन्हें एक साफ तरीके से हल करने में सक्षम होगा जो सभी के लिए काम करता है (और मज़बूती से)। मैं समझता हूं कि रजिस्ट्री में कई छवियों को इन मुद्दों को संभालने के लिए "सुरक्षा उपाय" नहीं हैं, लेकिन मुझे संदेह है कि इसे ठीक करने के लिए Compose / Fig की जिम्मेदारी है।

ऊपर कहा गया है; I _do_ मुझे लगता है कि यह डॉकफेरील सर्वोत्तम प्रथाओं अनुभाग में दस्तावेज करना एक अच्छी बात होगी।

लोगों को इसके बारे में जागरूक किया जाना चाहिए और सेवा "आउटेज" को संभालने के लिए उदाहरण के लिए कुछ उदाहरण जोड़े जाने चाहिए। संदर्भ के लिए @dnephin (और संभवतः अन्य स्रोतों) का उल्लेख करने वाले

मैं उसी समस्या में भाग गया और @kennu के इस विचार को

Personally, I would make Things Just Work, by making Fig autodetect which container ports are exposed to a linked container, ping them before starting the linked container (with a sane timeout), and ultimately provide a configuration setting to override/disable this functionality.

मुझे लगता है कि यह बहुत सामान्य उपयोग के मामलों को हल करेगा, जैसे मेरे लिए जब आधिकारिक मोंगोडब कंटेनर पर निर्भर करता है।

मैं @soupdiver से सहमत हूं। मुझे एक मोंगो कंटेनर के साथ संयोजन करने में भी परेशानी हो रही है, और हालांकि मेरे पास यह एक start.sh स्क्रिप्ट के साथ काम कर रहा है, स्क्रिप्ट बहुत गतिशील नहीं है और मुझे अपने रेपो में रखने के लिए एक और फ़ाइल जोड़ने की आवश्यकता है (मैं सिर्फ एक करना चाहूंगा Dockerfile और docker-compose.yml मेरे नोड रेपो में)। यह अच्छा होगा अगर किसी तरह से सिर्फ मेक इट वर्क हो, लेकिन मुझे लगता है कि कुछ आसान है जैसे एक वेट टाइमर इसे ज्यादातर मामलों में नहीं काटेगा।

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

क्या डोकर या अंजीर इन चेकों को संभाल सकता है?

क्या डोकर या अंजीर इन चेकों को संभाल सकता है?

संक्षेप में: _no_। विभिन्न कारणों से;

• एक कंटेनर के भीतर से "पिंग" प्रदर्शन करने का मतलब होगा दूसरी प्रक्रिया चलाना। अंजीर / कम्पोज स्वचालित रूप से इस तरह की प्रक्रिया शुरू नहीं कर सकता है, और मुझे नहीं लगता कि आप अपने कंटेनर को _installing_ सॉफ़्टवेयर (जैसे कर्ल या टेलनेट) द्वारा संशोधित करना चाहते हैं।
• (जैसा कि मैंने पिछली टिप्पणी में उल्लेख किया है), प्रत्येक सेवा को यह जांचने के लिए अलग-अलग तरीके की आवश्यकता होती है कि क्या वह कनेक्शन स्वीकार कर रहा है / उपयोग के लिए तैयार है। कुछ सेवाओं को कनेक्शन के लिए क्रेडेंशियल या प्रमाणपत्र की आवश्यकता हो सकती है। अंजीर / रचना स्वचालित रूप से आविष्कार नहीं कर सकती कि कैसे करें।

और मुझे नहीं लगता कि आप इसमें सॉफ्टवेयर (जैसे कि कर्ल या टेलनेट) स्थापित करके अपने कंटेनर को संशोधित करने के लिए अंजीर / रचना चाहते हैं।

नहीं, निश्चित रूप से नहीं।

अंजीर / रचना स्वचालित रूप से आविष्कार नहीं कर सकती कि कैसे करें।

आविष्कार नहीं। मैं अंजीर या डॉकर के लिए एक निर्देश के बारे में अधिक सोच रहा था, इसे कैसे जांचें, जैसे।

web:
    image: nginx
    link: db
db:
   is_available: "curl DB_TCP_ADDR:DB_TCP_PORT"

telnet आदेश डॉकटर-होस्ट पर निष्पादित किया जाएगा, न कि कंटेनर में।
लेकिन मैं सिर्फ जोर से सोच रहा हूं, मुझे पता है कि यह सही समाधान नहीं है। लेकिन कंटेनरों के लिए कस्टम चेक-स्क्रिप्ट का उपयोग करने के वर्तमान तरीके में सुधार किया जा सकता है।

टेलनेट कमांड को कंटेनर में नहीं, डॉकटर-होस्ट पर निष्पादित किया जाएगा।

तब curl या <name a tool that's needed> को होस्ट पर स्थापित करना होगा। यह बहुत बड़ा सुरक्षा मुद्दा हो सकता है (जैसे कोई व्यक्ति मजाकिया होना चाहता है और is_available: "rm -rf /" का उपयोग करता है)। इसके अलावा, _host_ से डेटाबेस को एक्सेस करने में सक्षम होना कोई गारंटी नहीं है कि यह कंटेनर के अंदर से भी सुलभ है।

लेकिन मैं सिर्फ जोर से सोच रहा हूं, ...

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

@thaJeztah मैं

मैं एक सुझाव को दोहराने जा रहा हूं जो मैंने पहले किया था: यह मेरे लिए पर्याप्त होगा यदि मैं अंजीर में बता सकता हूं "इस कंटेनर को इस अन्य कंटेनर को चलाने से पहले बाहर निकलने के लिए प्रतीक्षा करें"।

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

मैं इसे कुछ इस तरह कॉन्फ़िगर करूंगा:

"" "
एप्लिकेशन:
लिंक:
- डीबी: डीबी
prereqs:
- रूठने की क्रिया

runthisfirst:
लिंक:
- डीबी: डीबी
"" "

runthisfirst में एक लिंक है जिसका मतलब है कि डेटाबेस शुरू होता है इसलिए यह एक्सेस की जांच कर सकता है। ऐप केवल एक बार चलेगा जब रनथिसिस्ट्रेट्स बाहर निकल गया है (बोनस अंक यदि रनथ्रिस्पस्ट को सफलतापूर्वक बाहर निकलना है)।

क्या यह उत्तर के रूप में संभव है?

KJL

10 फरवरी 2015 को, 05:28 पर, टोबियास मंक नोटिफिकेशन @github.com ने लिखा:

@thaJeztah https://github.com/thaJeztah मैं आपसे पूरी तरह सहमत हूँ। और यह बहुत संभावना है कि कोई 100% समाधान नहीं होगा।

-
इस ईमेल का उत्तर सीधे दें या इसे GitHub https://github.com/docker/fig/issues/374#issuecomment -73561930 पर

मैंने अभी-अभी अपने शेल स्क्रिप्ट लॉन्चरों को माइग्रेट करने की कोशिश की है और इस मुद्दे में भाग गया हूं। बस एक साधारण नींद / प्रतीक्षा कुंजी जोड़ना भी अच्छा होगा जो कि अगले कंटेनर को लॉन्च करने से पहले केवल कुछ सेकंड के लिए सोती है।

db:
  image: tutum/mysql:5.6
  sleep: 10
app:
  link:
    - db:db

मैं वास्तव में कई कारणों से इसे पसंद नहीं करूंगा।

क) मुझे लगता है कि यह इसके लिए गलत जगह है
बी) आप कब तक सोते हैं?
ग) यदि टाइमआउट लंबे समय तक लागू नहीं होता है तो क्या होगा?

स्पष्ट मुद्दों के अलावा मुझे वास्तव में नहीं लगता
बुनियादी ढांचे को इस बात की परवाह करनी चाहिए कि आवेदन क्या है
है और इसके विपरीत। IHMO एप्लिकेशन होना लिखा होना चाहिए
अधिक सहिष्णु और / या होशियार यह अपनी आवश्यकताओं के बारे में है।

कहा जा रहा है कि मौजूदा अनुप्रयोगों और विरासत अनुप्रयोगों
कुछ की आवश्यकता होगी - लेकिन यह शायद अधिक होना चाहिए
की पंक्तियाँ:

एक docker-compose.yml :

db:
  image: tutum/mysql:5.6
app:
  wait: db
  link:
    - db:db

जहां wait लिए db पर "उजागर" सेवाओं की प्रतीक्षा करता है।

समस्या यह है कि आप यह कैसे निर्धारित करते हैं?

सरलतम मामलों में आप तब तक प्रतीक्षा करते हैं जब तक आप सफलतापूर्वक नहीं खोल सकते
उजागर सेवाओं के लिए एक tcp या udp कनेक्शन।

यह इस समस्या के लिए overkill हो सकता है लेकिन एक अच्छा समाधान क्या होगा यदि docker ने एक इवेंट ट्रिगरिंग सिस्टम प्रदान किया है जहाँ आप एक कंटेनर से ट्रिगर शुरू कर सकते हैं जिसके परिणामस्वरूप किसी अन्य कंटेनर में कॉलबैक हो सकता है। एक अन्य सेवा शुरू करने से पहले MySQL डेटाबेस में डेटा आयात करने की प्रतीक्षा करने के मामले में, बस पोर्ट पर्याप्त नहीं था या नहीं, इसकी निगरानी करना।

एंट्रीपॉइंट स्क्रिप्ट होने से डॉकटर को कंटेनर के अंदर से एक अलर्ट सेट किया जाता है (उदाहरण के लिए एक पूर्व-निश्चित वातावरण चर सेट करें) जो किसी अन्य कंटेनर में एक घटना को ट्रिगर करता है (शायद एक ही सिंक्रनाइज़ पर्यावरण चर सेट करना) दोनों पक्षों पर स्क्रिप्ट को सक्षम कर सकता है, जब कुछ पता हो। कार्य पूर्ण हैं।

बेशक हम अपना स्वयं का सॉकेट सर्वर या अन्य साधन सेट कर सकते हैं लेकिन कंटेनर ऑर्केस्ट्रेशन समस्या को हल करने के लिए थकाऊ है।

@aandand I _almost_ ने शुरुआती बिंदु के रूप में आपके प्रतीक्षा दृष्टिकोण का उपयोग करते हुए कुछ काम किया डॉकटर-कंपोज़ रन और डॉकर रन के बीच कुछ और होता है, जहां पूर्व में लटका हुआ प्रतीत होता है, जबकि बाद में एक आकर्षण काम करता है।

उदाहरण docker-compose.yml:

db:
  image: postgres
  ports:
    - "5432"
es:
  image: dockerfile/elasticsearch
  ports:
    - "9200"
wait:
  image: n3llyb0y/wait
  environment:
    PORTS: "5432 9200"
  links:
    - es
    - db

तब का उपयोग कर ...

docker-compose run wait

हालांकि यह होना नहीं है। लिंक की गई सेवाएँ शुरू हो जाती हैं और ऐसा लगता है कि हम केवल इसके लिए प्रतीक्षा करने वाले हैं (कम से कम मेरे वर्चुअलबॉक्स env के भीतर। मुझे nc लूप मिलता है और हमें तब एक ही बिंदी मिलती है ... कुछ भी नहीं)।

हालाँकि, चल रही सेवाओं के साथ मैं इस पद्धति का उपयोग कर सकता हूं (जो अनिवार्य रूप से मैं अपने सीआई बिल्ड के लिए कर रहा हूं)

docker run -e PORTS="5432 9200" --links service_db_1:wait1 --links service_es_1:wait2 n3llyb0y/wait

ऐसा लगता है कि docker-compose run को उसी तरह से काम करना चाहिए। अंतर यह है कि जब docker-compose run का टुकडा झंडा -d आपको प्रतीक्षा कंटेनर पृष्ठभूमि के रूप में कोई प्रतीक्षा लाभ नहीं मिलता है और मुझे लगता है कि (इस समय में) ध्वज का उपयोग नहीं करने से प्रतीक्षा होती है अन्य गैर-पृष्ठभूमि वाली सेवाओं पर रोक लगाने के लिए। मैं करीब से देखने जा रहा हूं

थोड़ा परीक्षण और त्रुटि के बाद ऐसा लगता है कि उपरोक्त दृष्टिकोण काम करता है! यह सिर्फ बिजीबॉक्स बेस में एक नेटकाट उपयोग नहीं है जो बहुत अच्छी तरह से काम करता है। मेरे संशोधित संस्करण @aanand इंतजार उपयोगिता का उपयोग करते समय डोकर-लिखें 1.1.0 के खिलाफ काम करता है docker-compose run <util label> के बजाय docker-compose up । लिंक में उपयोग का उदाहरण।

यह सुनिश्चित नहीं है कि यह मूल प्रश्न के अनुसार जंजीर स्थितियों को संभाल सकता है। शायद ऩही।

आप क्या सोचते हैं मुझे बताओ।

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

run mysql
waitUntil "docker exec -t mysql mysql -u root -prootpass database -e \"show tables\""
run mysql-backup
waitUntil "docker exec -t mysql mysql -u root -prootpass database -e \"describe my_table\""
run web1
waitUntil "dexec web1 curl localhost:9000 | grep '<h1>Home</h1>'"
run web2
waitUntil "dexec web2 curl localhost:9000 | grep '<h1>Home</h1>'"
run nginx

जहां waitUntil फ़ंक्शन का टाइमआउट के साथ एक लूप होता है, जो docker exec … कमांड को निकालता है और जांचता है कि क्या एग्ज़िट कोड 0 है।

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

इसलिए मुझे लगता है कि यह कंपोजिट यूटिलिटी के भीतर एकीकृत करने का विकल्प हो सकता है। हो सकता है कि ऐसा कुछ हो, जहां wait_until अन्य निर्भरता (कंटेनरों) की एक सूची की घोषणा करता है और प्रत्येक के लिए प्रतीक्षा करता है जब तक कि वे संबंधित आदेश के लिए ठीक जवाब न दें (या हो सकता है कि एक वैकल्पिक पैटर्न या regex के साथ जाँच करें कि परिणाम मेल खाता है या नहीं कुछ जो आप उम्मीद करते हैं, हालांकि grep कमांड का उपयोग करना पर्याप्त हो सकता है)।

mysql:
  image: mysql
  ...
mysql-backup:
  links:
   - mysql
  wait_until:
   - mysql: mysql -u root -prootpass database -e "show tables"
  ...
web1:
  links:
   - mysql
  wait_until:
   - mysql: mysql -u root -prootpass database -e "describe my_table"
  ...
web2:
  links:
   - mysql
  wait_until:
   - mysql: mysql -u root -prootpass database -e "describe my_table"
  ...
nginx:
  links:
   - web1
   - web2
  wait_until:
   - web1: curl localhost:9000 | grep '<h1>Home</h1>'
   - web2: curl localhost:9000 | grep '<h1>Home</h1>'
  ...

Wha यह बंदरगाह की तरह एक साधारण ईट नहीं है?
http://docs.azk.io/en/azkfilejs/wait.html#

@robsonpeixoto : बहुत अधिक उपयोग मामलों के लिए पोर्ट की प्रतीक्षा करना पर्याप्त नहीं है। उदाहरण के लिए, मान लें कि आप निर्माण पर डेटा के साथ एक डेटाबेस का बीजारोपण कर रहे हैं और नहीं चाहते कि वेब सर्वर शुरू हो और इसे तब तक कनेक्ट करें जब तक डेटा ऑपरेशन पूरा न हो जाए। पोर्ट पूरे समय खुला रहेगा ताकि वेब सर्वर शुरू होने से अवरुद्ध न हो।

AWS CloudFormation के WaitCondition जैसा कुछ अच्छा होगा। http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-waitcondition.html

+1, मेरे Rails ऐप्स के परीक्षण के लिए Docker का उपयोग करते समय मुझे वही समस्या आ रही है जो MySQL पर निर्भर करते हैं

+1 मेरे पास यह मुद्दा भी है। मुझे @adrianhurt आइडिया पसंद है, जहां आप वास्तव में यह निर्धारित करने के लिए मूल्यांकन किए जाने के लिए शर्त की आपूर्ति करते हैं कि क्या इंतजार पूरा हुआ है। इस तरह से आपके पास अभी भी एक अच्छा घोषणात्मक yml है, और आपके पास "तैयार" की मनमानी परिभाषा नहीं है।

+1

मैंने इस टैब को कुछ समय के लिए खुला रखा है: http://crosbymichael.com/docker-events.html ... प्रासंगिक लगता है

+1

सरल टाइमआउट के लिए +1

तैयार स्थिति के लिए +1

+1

मैं थोड़ी देर से आवेदन स्तर पर इसे बहुत मज़बूती से हल कर रहा हूं, जैसे कि इस धागे में इसकी सिफारिश की गई थी।

बस आपको यह अंदाजा लगाने के लिए कि यह MySQL + PHP के लिए मेरे कोड को कैसे लागू किया जा सकता है।

• PHP रिट्री पैकेज
• सीएलआई कमांड डीबी-कनेक्शन की जांच करने, डेटाबेस बनाने और अनुमतियाँ देने के लिए

Igorw / रिट्री से :)

चूंकि नेटवर्क विश्वसनीय है, चीजों को हमेशा काम करना चाहिए। क्या मैं सही हू? उन मामलों के लिए जब वे नहीं करते हैं, फिर से प्रयास करना है।

+1

@ schmunk42 अच्छा सामान - मुझे यह पसंद है कि यह कनेक्शन स्थापित करने और एक आदर्श डेटाबेस सेटअप ऑपरेशन करने दोनों का एक अच्छा उदाहरण है।

डॉक्स में शामिल करने के लिए (कुछ) मूल उदाहरण (उदाहरण) बनाने के लिए अच्छा हो सकता है, विभिन्न मामलों के लिए, जैसे नोड्स, रूबी, पीएचपी।

+1, कम से कम कंटेनर सफलतापूर्वक शुरू होने से पहले कुछ देरी जोड़ने के लिए कुछ विकल्प प्रदान करना चाहिए।

+1

समस्याओं को कैसे हल करें जब आप उन सेवाओं को जोड़ने का प्रयास करते हैं जो आपके कोड नहीं हैं।
उदाहरण के लिए, यदि कोई सेवा Service और डेटाबेस InfluxDB । Services लिए InfluxDB Services आवश्यकता होती है और InfluxDB में एक धीमा स्टार्टअप होता है।

InfluxDB लिए इंतजार करने वाले कंपोज़ कैसे तैयार हो सकते हैं?

मैं कोड है मेरा, मैं इसे एक रिट्री डाल हल कर सकता हूं। लेकिन तीसरे ऐप के लिए मैं कोड नहीं बदल सकता।

@robsonpeixoto नेटकट या इसी तरह के तरीकों से इस टिकट में कुछ उदाहरण हैं। आप एक अन्य टिकट में मेरे MySQL उदाहरण पर नज़र डाल सकते हैं: https://github.com/docker/docker/issues/7445#issuecomment -101523662

यही कारण है कि मुझे लगता है कि प्रत्येक कंटेनर में अपनी स्वयं की तत्परता को इंगित करने की वैकल्पिक क्षमता होनी चाहिए। एक DB के लिए, उदाहरण के लिए, मैं सेवा पूरी तरह से तैयार होने तक इंतजार करना चाहता हूं, जब प्रक्रिया नहीं बनाई जाती है। मैं इसे अनुकूलित चेक के साथ docker exec साथ हल करता हूं और जांचता हूं कि क्या यह एक सरल क्वेरी को हल कर सकता है, उदाहरण के लिए।

आंतरिक चेक कमांड को इंगित करने के लिए docker run लिए कुछ वैकल्पिक ध्वज बाद में लिंक के लिए एक विशेष ध्वज का उपयोग करके इसे दूसरे कंटेनर से लिंक करना बहुत अच्छा होगा।

कुछ इस तरह:

$ sudo docker run -d --name db training/postgres --readiness-check /bin/sh -c "is_ready.sh"
$ sudo docker run -d -P --name web --link db:db --wait-for-readiness db training/webapp python app.py

जहाँ is_ready.sh एक साधारण बूलियन परीक्षण है जो कंटेनर के तैयार होने पर निर्णय के प्रभारी के रूप में होता है।

+1

@ schmunk42 अच्छा उद्धरण!

+1

+1

+1

+1

+1 और स्वयं की स्क्रिप्ट का उपयोग करके समाधान

+1

+1

+1

+1

+1

वास्तव में मैंने इस बारे में अपना विचार बदल दिया है, इसलिए -1

आपके कंटेनर के लिए यह सुनिश्चित करने के लिए कि 3 जी पार्टी सेवा उपलब्ध है, और यह आसानी से थोड़ा सा बैश आवरण स्क्रिप्ट के साथ किया जाता है, जो उदाहरण के लिए nc का उपयोग करता है।

देरी पर भरोसा करना लुभावना है, लेकिन इसका एक बुरा हल है क्योंकि:

• आपका कंटेनर तैयार होने से पहले _always_ प्रतीक्षा X सेकंड करेगा।
• X सेकंड्स अभी भी कुछ मामलों में पर्याप्त नहीं हो सकते हैं (जैसे होस्ट पर भारी I / O या CPU), इसलिए आपका कंटेनर अभी भी विफल नहीं है।
• कोई असफल रणनीति नहीं।

रैपर बैश स्क्रिप्ट लिखने पर भरोसा करना बेहतर है क्योंकि:

• आपका कंटेनर तैयार है जितनी जल्दी हो सके।
• आप किसी भी असफल रणनीति को लागू कर सकते हैं, उदाहरण के लिए 10 बार प्रयास करें, फिर विफल रहें, हमेशा के लिए प्रयास करें, आदि। आप कोशिश करने से पहले सोने से देरी को भी लागू कर सकते हैं!

इस सूत्र के माध्यम से पढ़कर मैं देखता हूं कि कोई भी रहस्य का उल्लेख नहीं करता है। मैं एक डेटा-केवल कंटेनर का उपयोग करने की कोशिश कर रहा हूं, जो एक बार चलने के बाद रहस्यों का अनुरोध करता है। मेरे पास जो समस्या है: यदि मेरे रहस्यों को प्रसारित / डिक्रिप्ट करने में बहुत लंबा समय लगता है तो मेरा आश्रित कंटेनर विफल हो जाता है क्योंकि यह जिस डेटा की अपेक्षा कर रहा है वह नहीं है। मैं वास्तव में "कंटेनर में सब कुछ डालने से पहले इसे चलाने की विधि का उपयोग नहीं कर सकता" क्योंकि वे रहस्य हैं।

मुझे पता है कि रिटर्न कोड के संदर्भ के कारण रचना में डेटा-ओनली कंटेनर के आसपास कुछ अस्पष्टता है, लेकिन क्या ऐसा करने का एक बेहतर तरीका है?

इसी तरह इस पर मेरा मन बदल रहा है, -1। @dnephin का दृष्टिकोण पूरी तरह से सही है। यदि आपका _application_ एक _service_ पर निर्भर करता है, तो एप्लिकेशन को उस सेवा की अनुपलब्धता को इनायत से प्रबंधित करने में सक्षम होना चाहिए (जैसे एक कनेक्शन को फिर से स्थापित करना)। यह कुछ बैश रैपर स्क्रिप्ट या कम्पोज़ या डॉकर में कुछ तर्क नहीं होना चाहिए, यह आवेदन की जिम्मेदारी है। आवेदन स्तर पर कुछ भी नहीं केवल आरंभ पर काम करेगा; यदि वह सेवा समाप्त हो जाती है, तो एक आवरण स्क्रिप्ट या कुछ निष्पादित नहीं किया जाएगा।

अब यदि हम इस जिम्मेदारी को महसूस करने और समर्थन करने के लिए एप्लिकेशन / लाइब्रेरी / फ्रेमवर्क डेवलपर्स प्राप्त कर सकते हैं, तो यह शानदार होगा।

उन दृष्टिकोणों पर विचार करने के लिए कठिन है जिन्हें आप अन्य डेमों को साइडलोड करना शामिल करेंगे जो अनुशंसित नहीं है। मेरे उदाहरण के लिए जहां मेरे पास एक रेल एप्लिकेशन है जो MySQL डेटाबेस से जुड़ने का प्रयास कर रहा है, जबकि एक अन्य रेल एप्लिकेशन वर्तमान में माइग्रेट कर रहा है और प्रारंभिक स्टार्टअप पर DB को सीडिंग कर रहा है, मेरे लिए रेल एप्लिकेशन को DB का उपयोग करने का प्रयास नहीं करने के लिए जानता है, मैं या तो करूंगा ActiveRecord लाइब्रेरी को मॉडिफाई करना है (ऐसा नहीं होने वाला है) या एक स्क्रिप्ट चलाएं जो यह देखने के लिए जाँच करती है कि क्या DB को माइग्रेट और सीड किया गया है। लेकिन मैं यह कैसे सुनिश्चित कर सकता हूं कि यह जानने के लिए कि क्या डेटा होना चाहिए और / या कुछ स्क्रिप्ट है जो उस सिस्टम पर चलती है जो DB को सीड कर रहा है ताकि बाकी को उससे कनेक्ट करने के लिए सूचित कर सके।

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

@mattwallington मुझे यकीन भी नहीं है कि कंपोज़ उस स्थिति के लिए एक समाधान कैसे प्रदान करेगा ...
यह भी बहुत ही विशिष्ट है जो कम्पोज को आविष्कार करने के लिए और भी कठिन बना देगा। मैं इनिशियलाइज़ेशन / माइग्रेशन / सीडिंग पर ऊपर दिए गए कुछ @dnephin के टिप्स

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

समझ लिया। मेरा सुझाव पहले जो इन उपयोग के मामलों के लिए बहुत काम करेगा कंटेनर के बीच एक साझा पर्यावरण चर है। एक पक्ष चर को मतदान करने पर लॉक कर सकता है और दूसरा कार्रवाई कर सकता है और फिर चर को सेट कर सकता है।

कंटेनरों के बीच साझा पर्यावरण चर के +1 @mattwallington विचार

धन्यवाद। यह सरल है (उत्पाद स्तर पर। मुझे नहीं पता कि यह विकास की तरफ से क्या लेगा क्योंकि मैंने कोड को नहीं देखा है) लेकिन यह इन समस्याओं का एक बहुत कुछ हल करेगा और शायद बहुत से अन्य के रूप में यह विशिष्ट नहीं है। इस मुद्दे।

लेकिन मैं यह कैसे सुनिश्चित कर सकता हूं कि यह जानने के लिए कि क्या डेटा होना चाहिए और / या कुछ स्क्रिप्ट है जो उस सिस्टम पर चलती है जो DB को सीड कर रहा है ताकि बाकी को उससे कनेक्ट करने के लिए सूचित कर सके।

@mattwallington : स्कीमा तालिका में माइग्रेशन नंबर की जाँच करें। यदि संख्या सही है, तो आपको पता है कि माइग्रेशन चला गया है।

यह कुछ बैश रैपर स्क्रिप्ट या कम्पोज़ या डॉकर में कुछ तर्क नहीं होना चाहिए, यह आवेदन की जिम्मेदारी है। आवेदन स्तर पर कुछ भी नहीं केवल आरंभ पर काम करेगा; यदि वह सेवा समाप्त हो जाती है, तो एक आवरण स्क्रिप्ट या कुछ निष्पादित नहीं किया जाएगा।

@ agilgur5 : हाँ मैं मानता हूँ कि यह एप्लिकेशन द्वारा नियंत्रित किया जाएगा, लेकिन एक बैश स्क्रिप्ट उन अनुप्रयोगों को संभालने के लिए एक सरल समाधान है जो इस तरह कोडित नहीं हैं, जैसे कि सेवा उपलब्ध नहीं होने पर ऐप को पुनरारंभ करके।

तर्क पूरे दिन किए जा सकते हैं कि ऐप के स्तर पर क्या किया जाना चाहिए या किया जा सकता है, लेकिन इससे निपटने के लिए बाजार पर हर ऐप की अपेक्षा करने के बजाय और स्वयं पुनर्प्राप्ति पर भयानक हो जाते हैं (संभावना नहीं) कि हम कुछ सुविधाओं को जोड़ने के खिलाफ क्यों हैं जो हल कर सकते हैं डॉक में चलने वाले ऐप्स के लिए यह समस्या इस बात की परवाह किए बिना है कि तीसरे पक्ष के ऐप कैसे लिखे जाते हैं या वे क्या करते हैं, लेकिन ऐसा नहीं होगा। इस पर हमारा नियंत्रण है। आइए समस्या को सुलझाने के बजाय यह तय करें कि इसे हल करने वाला कौन होना चाहिए क्योंकि हमारा उस पर कोई नियंत्रण नहीं है।

मैं @mattwallington से सहमत हूं। आपको प्रत्येक एकल कंटेनर छवि के प्रत्येक डेवलपर से ऐप-स्तरीय आत्म-पुनर्प्राप्ति के लिए इस अतिरिक्त प्रयास की आवश्यकता हो सकती है, लेकिन उनमें से एक बड़ा प्रतिशत बहुत अज्ञानी होने के लिए बाध्य है या बस इसे लागू करने और ध्यान से परीक्षण करने के लिए बहुत व्यस्त है। अंतिम परिणाम यह होगा कि कुछ कंटेनरों को पता है कि कैसे स्वयं को ठीक करना है जबकि कई को नहीं। और एक उपयोगकर्ता के रूप में, आप उन लोगों को प्रबंधित करने के लिए किसी भी उपकरण के बिना होंगे जो नहीं करते हैं।

एक आइडिया जो अभी मेरे दिमाग में आया: कंटेनर स्टार्टअप्स में देरी से समस्या को हल करने के बजाय, असफल कंटेनर को पुनर्प्राप्त करने के लिए कम्पोज़ कोशिश कर सकता था।

recover: auto जैसा कुछ भी 2, 4, 8, 16 और 32 सेकंड में 5 बार के लिए विफल कंटेनर को पुनरारंभ करेगा और फिर पूरी तरह से दे देगा।

क्या किसी के पास कंटेनर निर्भरता कंटेनर की धारणा का _thought_ है?

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

`` `#! yml
db:
छवि: mysql

के लिए इंतजार:
लिंक:
- डी.बी.
मात्रा:
- /वर/लिब/docker.sock:/docker.sock
- $ {PWD} /docker-compose.yml:/docker-compose.yml
कमांड: डॉक-कम्पोज अप -d ऐप

एप्लिकेशन:
छवि: myuser / myapp
लिंक:
- डी.बी.
`` `

यहाँ मूल विचार यह है कि आप _solve_ कंटेनरों के लिए समस्या है कि एक समर्पित पुन: प्रयोज्य सेवा है कि Docker हब को प्रकाशित किया जा सकता है बनाने के द्वारा स्वयं वसूली तंत्र नहीं है कि हर कोई तो बस अपनी रचना में इंजेक्ट कर सकते हैं।

मैं _would_ यहां तक ​​कि इस तरह की सेवा / कंटेनर / छवि को प्रोटोटाइप करने के लिए तैयार हूं और इसके साथ अन्य छींटे देखने के लिए कि यह कैसे दूर है ...

@prologic एक निर्भरता के साथ समस्या है, कैसे सुनिश्चित करें कि जिस सेवा के लिए आप बोलना चाहते हैं वह वास्तव में है?

आपका db कंटेनर ping जवाब दे सकता है, लेकिन कुछ प्री लॉन्च सफाई कर रहा है / डेटाबेस को शुरू करने से पहले यह वास्तव में mysql / psql आदेशों के लिए उपलब्ध है।

क्या उस परीक्षण को एक विन्यास योग्य तरीके से परिभाषित किया जा सकता है और / या फिर एक स्क्रिप्ट में पुन: प्रयोज्य waitfor प्रकार की सेवा प्रदान की जा सकती है?

IMHO, यह एक बहुत ही सामान्य मुद्दा है और सभी की अपनी विशिष्ट आवश्यकताएं हैं। इस मुद्दे से पहले एक टिप्पणी के रूप में, मुझे लगता है कि डॉकटर एक कंटेनर के लिए अपनी खुद की तत्परता की जांच करने के लिए एक सरल आदेश निर्दिष्ट करने का एक तरीका प्रदान कर सकता है (और चाहिए)। जाहिर है, हमें डेवलपर्स के रूप में विशेष रूप से प्रत्येक कंटेनर की तत्परता की जांच करने का संकेत देना चाहिए।

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

कुछ इस तरह:

$ sudo docker run -d --name db training/postgres --readiness-check /bin/sh -c "is_ready.sh"
$ sudo docker run -d -P --name web --link db:db --wait-for-readiness db training/webapp python 

जहाँ is_ready.sh एक साधारण बूलियन परीक्षण है जो कंटेनर के तैयार होने पर निर्णय के प्रभारी के रूप में होता है।

यह मैन्युअल रूप से इसकी तत्परता की जांच करने के लिए एक कंटेनर के लिए एक कमांड भी हो सकता है।

जहाँ is_ready.sh एक साधारण बूलियन परीक्षण है जो कंटेनर के तैयार होने पर निर्णय के प्रभारी के रूप में होता है।

जिसका अर्थ है कि प्रत्येक डेवलपर को _something_ को शामिल करने के लिए अपनी छवियों / कंटेनरों को तैयार करना चाहिए जो कि कंटेनर तैयार होने पर जाँच के लिए उपयोग किया जा सकता है।

जो हमें 1 वर्ग में वापस लाता है ।; डेवलपर्स अपने कंटेनरों को सेवा आउटेज / स्टार्टअप समय के लिए लचीला बनाने के लिए जिम्मेदार हैं, क्योंकि वे केवल एक ही हैं जो उनकी स्थिति के लिए "क्या" बता सकते हैं?

या मैं यहाँ कुछ देख रहा हूँ?

मैं सहमत हूँ। जिम्मेदारी डेवलपर / कंटेनर / सेवा के साथ है

गुरुवार, 30 जुलाई 2015 को, सेबेस्टियन वैन स्टिजन नोटिफिकेशन @ithub.com
लिखा था:

जहाँ is_ready.sh एक सरल बूलियन परीक्षण है, जिसका प्रभारी है
जब कंटेनर तैयार माना जाता है।

जिसका अर्थ है कि प्रत्येक डेवलपर को अपनी छवियों / कंटेनरों को तैयार करना चाहिए
_something_ शामिल हैं जिनका उपयोग चेकिंग के लिए किया जा सकता है यदि कंटेनर है
तैयार।

जो हमें 1 वर्ग में वापस लाता है ।; डेवलपर इसके लिए जिम्मेदार हैं
अपने कंटेनरों को सेवा आउटेज / स्टार्टअप समय के लिए लचीला बनाने, क्योंकि
वे केवल वही हैं जो "स्थिति" का अर्थ बता सकते हैं कि उनकी स्थिति क्या है?

या मैं यहाँ कुछ देख रहा हूँ?

-
इस ईमेल का उत्तर सीधे दें या इसे GitHub पर देखें
https://github.com/docker/compose/issues/374#issuecomment -126278215

जेम्स मिल्स / प्रोलोगिक

E: [email protected]
डब्ल्यू: prologic.shortcircuit.net.au

हां बिल्कुल। मेरे लिए, केवल एक जो वास्तव में जानता है जब एक कंटेनर तैयार होता है वह खुद का कंटेनर होता है। डॉकटर कंटेनर की सामग्री के बारे में कुछ नहीं जान सकता है। यह एक ब्लैक बॉक्स है। केवल एक चीज यह कर सकती है कि कंटेनर से पूछें (जब आप दौड़ना चाहते हैं, तो एक कस्टम क्रिया निर्दिष्ट करें, जैसे मैंने प्रस्तावित किया था, या किसी अन्य सामान्य तरीके से इसका परीक्षण करें)। और जाहिर है कि डेवलपर एकमात्र ऐसा है जो जानता है कि उसे क्या चाहिए और उस ब्लैक बॉक्स की सामग्री।

हाँ यह सही है!

गुरुवार, 30 जुलाई 2015 को, एड्रियनहार्ट नोटिफिकेशन @github.com ने लिखा:

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

-
इस ईमेल का उत्तर सीधे दें या इसे GitHub पर देखें
https://github.com/docker/compose/issues/374#issuecomment -126285056

जेम्स मिल्स / प्रोलोगिक

E: [email protected]
डब्ल्यू: prologic.shortcircuit.net.au

ठीक है - इन-डेवलपमेंट या लीगेसी सॉफ़्टवेयर की खातिर, जो नेटवर्क विफलता को संभाल नहीं सकते हैं, मान लीजिए कि हम इस समस्या को हल करना चाहते हैं। मैं यह नहीं कह रहा हूं कि हम सिंटैक्स, शब्दार्थ और जटिलता के लिए एक अनुभव प्राप्त करना चाहते हैं।

आवश्यकताओं का न्यूनतम सेट लगता है:

• मैं चाहता हूं कि कंपोज एक सेवा शुरू करने के लिए इंतजार करे जब तक कि दूसरी सेवा "तैयार" न हो जाए।
• मैं "रेडी" को परिभाषित करना चाहता हूं क्योंकि "पोर्ट एक्स पर टीसीपी कनेक्शन स्वीकार कर रहा है", या कुछ और।

चलिए यह भी मान लेते हैं कि स्वास्थ्य जांच थोड़ी देर के लिए इसे डॉकर में नहीं बनाया जाएगा।

मुझे आश्चर्य है कि अगर यह सामान्य मामले में किसी अन्य सेवा के कंटेनरों के लिए _wait को बाहर निकलने के लिए संभव बनाकर हल किया जा सकता है। फिर आप अपनी स्वास्थ्य जांच को केवल एक अन्य सेवा के रूप में लिख सकते हैं।

web:
  image: mywebapp
  links: ["db"]
  wait_for: ["db_wait"]

db_wait:
  image: netcat
  links: ["db"]
  command: sh -c "while ! nc -w 1 -z db 5432; do sleep 1; done"

db:
  image: postgres

यदि आप किसी प्रकार की कस्टम स्वास्थ्य जांच चाहते हैं, तो इसे "प्रतीक्षा" सेवा में परिभाषित करें। यहाँ, db_wait केवल एक बार mytable mydb डेटाबेस में मौजूद है:

db_wait:
  image: postgres
  links: ["db"]
  command: sh -c "while ! psql --host db --dbname mydb -c "\d mytable"; do sleep 1; done"

यदि आपके पास पहले चलाने के लिए एक db तैयारी स्क्रिप्ट है, तो आप उस चीज़ का इंतज़ार कर सकते हैं:

web:
  image: mywebapp
  links: ["db"]
  wait_for: ["prepare_db"]

prepare_db:
  image: prepare_db
  links: ["db"]
  command: ./prepare.sh

db:
  image: postgres

पहला मामला (प्रतीक्षा करें जब तक कि कंटेनर टीसीपी कनेक्शन स्वीकार नहीं कर रहा है) तब तक आम हो सकता है, जो आउट-ऑफ-द-बॉक्स का समर्थन करने लायक हो।

web:
  image: mywebapp
  links: ["db"]
  wait_for_tcp: ["db:5432"]

db:
  image: postgres

इस सब में एक छिपी हुई निहितार्थ है: docker-compose up -d को ब्लॉक करना होगा जबकि मध्यस्थ स्वास्थ्य जांच या तैयारी सेवा चल रही है, ताकि यह उपभोक्ता सेवा शुरू कर सके।

हाँ। हालांकि, मेरी राय में, डॉकटर को यह निर्धारित करने के लिए एक तरीका प्रदान करना चाहिए कि कंटेनर कब तैयार है, और फिर रचना इसे प्रबंधित कर सकती है। हम तब एक नया मुद्दा सीधे docker में उठा सकते हैं। मेरे लिए, यह कुछ इस तरह हो सकता है:

web:
  image: mywebapp
  links: ["db"]
  wait_for: ["db"]

db:
  image: postgres
  ready_when: sh -c "while ! psql --host db --dbname mydb -c "\d mytable"; do sleep 1; done"

फिर, वर्कअराउंड के रूप में नई सेवाएँ बनाने की आवश्यकता नहीं है

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

एक साझा पर्यावरण चर को कैसे अपडेट किया जाएगा? जहाँ तक मैं जानता हूँ, आप एक बार शुरू होने के बाद पर्यावरण चर के एक सेट में बदलाव नहीं कर सकते।

आप उन्हें एक bash सत्र में बदल सकते हैं, लेकिन वे अन्य सभी परतों में प्रचारित नहीं होंगे।

ऐसा करने के लिए, परिवर्तन को प्रतिबद्ध करना होगा और कंटेनर को फिर से शुरू करना होगा। इस परिदृश्य में यह बहुत बेकार है।

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

चूंकि हम वास्तव में केवल विकास के वातावरण में विरासत कंटेनरों के लिए इस समस्या को हल करने के बारे में बात कर रहे हैं, मुझे लगता है कि इसे एक उपकरण के रूप में हल किया जा सकता है जो docker-compose ps -s (निर्भरता क्रम में सूची सेवाओं, # 1077) की रचना करता है।

इन दो आदेशों के साथ, एक उपकरण लिखा जा सकता है जो कुछ इस तरह से होता है:

1. निर्भरता क्रम में सेवाओं के नामों की सूची प्राप्त करने के लिए docker-compose ps -s चलाएं
2. docker-compose up -d --no-recreate <first service from the list> चलाएं
3. उस सेवा के लिए "स्वास्थ्य परीक्षण" कमांड तब तक चलाएं जब तक कि यह स्वस्थ न हो जाए या यह समय समाप्त न हो जाए। यह एक HTTP अनुरोध या docker exec कॉल हो सकता है
4. सूची में प्रत्येक सेवा के लिए 2 और 3 दोहराएं
5. भागो docker-compose logs (या नहीं तो -d पारित किया जाता है)

इस तरह "हेल्थीचेक" और "प्रतीक्षा" के लिए विन्यास रचना के लिए बाहरी हो सकता है, लेकिन मुझे नहीं लगता कि डेवलपर को ऊपर कुछ भी प्रदान करने की आवश्यकता है, अगर इसे कंपोज़ के भाग के रूप में लागू किया गया हो तो क्या आवश्यक होगा।

किसी भी कारण से यह काम नहीं करेगा?

मुझे खुशी है कि हमने विरासत के कंटेनरों के दायरे को सीमित कर दिया है, यह अधिक उचित है: +1:

@dnephin मुझे लगता है कि यह तात्कालिक परिप्रेक्ष्य से बहुत अच्छा है कि यह लचीला है और कम्पोज को विरासत के कंटेनरों के लिए कुछ अंतर्निहित समर्थन नहीं है, लेकिन मुझे @mattwallington के समान एक तत्काल समस्या दिखाई

+1

डॉक-कम्पोज़ फ़ाइलों में निर्भरता निर्दिष्ट करने में सक्षम होने के लिए ...

... लिंक का उपयोग नहीं करना (जैसा कि वे नेट = होस्ट के साथ असंगत हैं)। मैंने सोचा होगा कि यह काम है या कम से कम मल्टी-कंटेनर मैनेजमेंट टूल की चिंता है कि यह जानने के लिए कि चीजों को किस क्रम में शुरू करना चाहिए, जैसे कठपुतली का अपना आश्रित वृक्ष होता है, लेकिन कभी-कभी उपयोगकर्ता सबसे अच्छा जानता है और ओवरराइड कर सकता है। उपरोक्त सभी को पढ़ना, यह मुझे लगता है, एकमात्र कठिनाई यह तय कर रही है कि एक कंटेनर "ऊपर" है ताकि निर्भरता श्रृंखला में अगले कंटेनर को शुरू किया जा सके। यह ठीक वैसा ही तंत्र हो सकता है जैसा कि लिंक तंत्र (अभी के लिए) - कुछ भी नहीं से बेहतर है। बाद में, "निर्भरता पूरी करने" का स्पष्टीकरण डॉकटर-कम्पोज़ फ़ाइल द्वारा निर्दिष्ट किया जा सकता है, उदाहरण के लिए - यह निर्भरता मायने रखती है कि कंटेनर चल रहा है

depends_on:
  container: foo
  requires: running

या यह निर्भरता यह मायने रखती है कि कंटेनर TCP पोर्ट सुन रहे हैं।

depends_on:
  container: foo
  requires: listening

यह कहना कि यह कुछ बाहरी टूल या स्क्रिप्ट का काम है, docker-compose कहना यह है कि docker-compose के लिए एक ही मशीन पर 2 या अधिक कंटेनर चलाने के ऑर्केस्ट्रेशन के लिए कोई वास्तविक रुचि या जिम्मेदारी नहीं है। तो इसका उद्देश्य क्या है?

मैंने सोचा होगा कि यह काम है या कम से कम मल्टी-कंटेनर मैनेजमेंट टूल की चिंता है कि यह जानने के लिए कि चीजों को किस क्रम में शुरू करना चाहिए

नहीं, जरूरी नहीं। इस धागे में पहले से ही कई बार दिए गए कारणों के लिए, मेरा मानना ​​है कि इस काम को कंटेनर प्रबंधन उपकरण से बंद करने के लिए केवल दो बहाने हैं:

1. आप ऑफ-द-शेल्फ कंटेनर छवियों को चला रहे हैं जो उन अपस्ट्रीम सेवाओं की अनुपलब्धता के लिए लचीला नहीं हैं जो वे निर्भर करते हैं, और तकनीकी या व्यावसायिक कारणों से आप उन्हें बदल नहीं सकते हैं या उनका विस्तार नहीं कर सकते हैं।
2. आप सॉफ्टवेयर को विशुद्ध रूप से एक विकास के वातावरण में चला रहे हैं, उत्पादन के लिए नहीं, और आपको लचीलापन लागू करने की तुलना में समय बिताने के लिए बेहतर चीजें मिल गई हैं।

हालाँकि, यदि आपके पास अपने सॉफ़्टवेयर पर नियंत्रण है और आप इसे उत्पादन में तैनात करने की योजना बना रहे हैं, तो आप बाहरी उपकरण पर भरोसा करने की उम्मीद नहीं कर सकते हैं, जो केवल चीजों को सही क्रम में शुरू करता है, भले ही आपने अपनी तत्परता की शर्तों को ध्यान से परिभाषित किया हो। यह मूलभूत समस्या का एक गैर-समाधान है, और आपका सिस्टम उस समय गिर जाएगा जब एक नेटवर्क हिचकी होगी। सबसे अच्छा, आपको हर बार होने वाले अपने सभी वेब फ्रंटेंड कंटेनरों को स्वचालित रूप से पुनरारंभ करना होगा, और मैं यह नहीं देख सकता कि किसी के लिए डाउनटाइम की स्वीकार्य राशि हो।

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

शायद मैं एक JVM चलाने वाला क्लाइंट कंटेनर चलाना चाहता हूं, और एक अन्य मॉनिटरिंग टूल जो इसे होस्ट करने के लिए है, दोनों मेजबान PID नामस्थान में हैं ताकि एक दूसरे पर नजर रख सके और मैं केवल अधिकृत विक्रेताओं के साथ इस तरह के टूल को चलाने के लिए अधिकृत हूं । यदि निगरानी उपकरण मौजूदा जेवीएम की निगरानी करता है, तो यह मायने रखता है कि वे किस क्रम में शुरू करते हैं (जाहिर है)। संभवतः सैकड़ों यूजेस हैं जहां ऑर्डर मायने रखते हैं, कुछ नेटवर्क (mysql, elasticsearch, सर्विस डिस्कवरी क्लस्टर्स सभी का उल्लेख किया गया है), लेकिन कुछ अन्य चीजें शामिल हैं जिन्हें अलग-अलग नामस्थानों का प्रभावी ढंग से उपयोग करके साझा किया जा सकता है।

इसलिए मैं निश्चित रूप से usecase (1) से सहमत हूं, कि कुछ परिस्थितियों में आप सिर्फ एक कंटेनर को बदल नहीं सकते

लेकिन यह भी जैसे ही एक उपकरण कई चीजों के साथ खुद को चिंतित करता है, यह तुरंत आदेश देने के खिलाफ आता है। यदि ऑर्डर देना महत्वपूर्ण है और ऑर्डर की गारंटी देने का एकमात्र तरीका है कि पहले कुछ करने के लिए docker-Compose के आसपास बैश स्क्रिप्ट लिखी जाए, और फिर कुछ और किया जाए, तो docker-compose श्रृंखला में मौजूद नहीं हो सकता है, तथ्य के अलावा अन्य JSON / YAML cmdline args से अधिक सुंदर है।

IMHO अंततः एक उपकरण या तो उपयोगी है या usecases का एक गुच्छा के लिए नहीं। एक ही मेजबान पर कई कंटेनरों के अनियंत्रित स्टार्टअप के लिए डॉकर-रचना स्पष्ट रूप से उपयोगी है। यदि पर्याप्त लोग और पर्याप्त usecases ऑर्डर करने के बारे में हैं और एक उपकरण उन्हें संबोधित नहीं करता है, तो लोग केवल उन usecases के लिए कहीं और जाएंगे जो शर्म की बात है।

वैसे भी मैं देख रहा हूं कि मैं सिर्फ पुराने तर्कों को दोहरा रहा हूं, इसलिए मैं अब इस सूत्र से बेदखल करूंगा।

यह वही तर्क है जो इतने सारे अलग-अलग विकास विषयों पर हजारों थ्रेड्स में कहा गया है "यदि सभी कोड सभी द्वारा ठीक से लिखे गए थे, तो इस तरह की कोई आवश्यकता नहीं होगी, तो चलो ऐसा नहीं करते हैं"। यह कहने के बराबर है: यदि दुनिया में सभी लोग जीवाश्म ईंधन को जलाना बंद कर देते हैं या बिजली का उपयोग करते हैं, तो हम उन समस्याओं को ठीक कर सकते हैं जो हम इस ग्रह के कारण पैदा कर रहे हैं। तुम सही हो। यदि सभी ऐप्स ने जो किया है, तो हम यहां इस बारे में बात नहीं करेंगे। लेकिन हम पृथ्वी पर रहते हैं। एक ऐसी जगह जिसमें जीवों की प्रजातियों के साथ बड़े पैमाने पर खामियां थीं, जो चीजों को कठिन तरीके से सीखने की प्रवृत्ति रखते हैं। वही लोग जो केवल कंपनियों को जमीन पर उतारते हैं क्योंकि वे प्रार्थना करने के लिए "न्यूनतम व्यवहार्य उत्पाद" का निर्माण करते हैं ताकि वे इसे धन के अगले दौर में या अगले ग्राहक जो किसी दिन उन्हें वह संस्करण बनाने की अनुमति दे सकें जो वे चाहते हैं। ।

दुनिया नहीं है और कभी भी परिपूर्ण नहीं होगी और इसलिए हम केवल वही कर सकते हैं जो हमारे पास है। और इस मामले में केवल एक चीज जो मेरे नियंत्रण में है, वह है आप सभी को समझाने की कोशिश करना (उर्फ वे लोग जो उस उपकरण को विकसित करते हैं जिसे मैं पूरी तरह से प्यार करता हूं और पागलों की तरह उपयोग करूंगा यदि इसे बनाने के लिए केवल यही एक विशेषता है) एक ऐसा तरीका जहां यह उस सॉफ्टवेयर को संभाल सकता है जो उस दुनिया में मौजूद है, जिसमें हम रहते हैं। न कि हम जो चाहते हैं, हम उसमें रहते हैं।

Jul 31, 2015 को, 3:42 पूर्वाह्न पर, Aanand Prasad सूचनाएं @github.com ने लिखा:

मैंने सोचा होगा कि यह काम है या कम से कम मल्टी-कंटेनर मैनेजमेंट टूल की चिंता है कि यह जानने के लिए कि चीजों को किस क्रम में शुरू करना चाहिए

नहीं, जरूरी नहीं। इस धागे में पहले से ही कई बार दिए गए कारणों के लिए, मेरा मानना ​​है कि इस काम को कंटेनर प्रबंधन उपकरण से बंद करने के लिए केवल दो बहाने हैं:

आप ऑफ-द-शेल्फ कंटेनर छवियों को चला रहे हैं जो उन अपस्ट्रीम सेवाओं की अनुपलब्धता के लिए लचीला नहीं हैं जो वे निर्भर करते हैं, और तकनीकी या व्यावसायिक कारणों से आप उन्हें बदल नहीं सकते हैं या उनका विस्तार नहीं कर सकते हैं।

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

हालाँकि, यदि आपके पास अपने सॉफ़्टवेयर पर नियंत्रण है और आप इसे उत्पादन में तैनात करने की योजना बना रहे हैं, तो आप बाहरी उपकरण पर भरोसा करने की उम्मीद नहीं कर सकते हैं, जो केवल चीजों को सही क्रम में शुरू करता है, भले ही आपने अपनी तत्परता की शर्तों को ध्यान से परिभाषित किया हो। यह मूलभूत समस्या का एक गैर-समाधान है, और आपका सिस्टम उस समय गिर जाएगा जब एक नेटवर्क हिचकी होगी। सबसे अच्छा, आपको हर बार होने वाले अपने सभी वेब फ्रंटेंड कंटेनरों को स्वचालित रूप से पुनरारंभ करना होगा, और मैं यह नहीं देख सकता कि किसी के लिए डाउनटाइम की स्वीकार्य राशि हो।

-
इस ईमेल का उत्तर सीधे दें या इसे GitHub पर देखें।

+1 @ आनंद यह ऐसा कुछ नहीं है जिसे आप दायरे में सीमित करने में सक्षम होने जा रहे हैं। यदि ऐसा किया जाता है, तो फीचर को कुछ लोगों पर भरोसा करने की आवश्यकता है। वे लंबे समय से "टिकाऊ" बुनियादी ढांचे के लिए कोडिंग कर रहे हैं और जनता को परिवर्तित करने में लंबा समय लग रहा है। वे _will_ आने वाले लंबे समय तक इसका उपयोग करते हैं।

मैं दोहराना चाहूंगा कि हमने कंटेनरों के बीच स्टार्टअप टाइमिंग की निर्भरता की समस्या को दूर करने के लिए कुछ लागू करने से इनकार नहीं किया है - मैंने कल ही एक संभव समाधान निकाला

लेकिन मैं चाहता हूं कि हम उसी पृष्ठ पर हों, जिसके बारे में यह सुविधा है कि यह किस समस्या का समाधान करेगा, यह किन समस्याओं का समाधान करेगा। _ हल नहीं करेगा और इसे किस डिग्री पर निर्भर किया जा सकता है। यही मैं महसूस करने की कोशिश कर रहा हूं।

इसके अलावा, तत्परता की कई परिभाषाएं मौजूद हैं ("कंटेनर शुरू हो गया है" ("कंटेनर" शुरू हो गया है) कंटेनर टीसीपी कनेक्शन स्वीकार कर रहा है "बनाम" कस्टम स्वास्थ्य जांच पास "), और उनमें से प्रत्येक के कार्यान्वयन की भिन्नता, मैं एक तुलनात्मक रूप से प्राप्त करना चाहता हूं। हर एक के लिए आउट-ऑफ-द-बॉक्स समर्थन से कितने लोगों को लाभ होगा, इसका विचार।

सेवाओं को सिंक्रोनाइज़ करने के लिए एक सामान्य तकनीक कुछ ऐसी है जैसे कि etcd या समान का उपयोग करके "सर्विस रजिस्ट्री"। कैसे एक wa_for_service के बारे में:

web:
  image: mywebapp
  links: ["db"]
  wait_for_service:
    type: etcd (or consul, or zk)    -- or use swarm type notation
    addr: http://my.etcd.com/
    path: postgres.service

db:
  image: postgres

रचना यह नहीं जानती है कि क्या सेवा वास्तव में तैयार है, लेकिन यह रजिस्ट्री में डेटा की तलाश कर सकती है और उसके आधार पर आश्रित कंटेनर को शुरू कर सकती है। यह सेवाओं की जिम्मेदारी है (जैसे पोस्टग्रेज की) रजिस्ट्री के लिए उनकी उपलब्धता को प्रकाशित करना ताकि विरासत अनुप्रयोगों के लिए किसी प्रकार की रैपिंग स्क्रिप्ट ऐसा करेगी: ऐप शुरू करें, लाइव जाने के लिए पोर्ट देखें, फिर रजिस्ट्री में प्रकाशित करें।

हाय @आनंद।

मैं आज इस पर चर्चा कर रहा था @bfirsh के साथ

विशेष रूप से, कई छोटे डॉक्यूमेंट किए गए घटकों में से एक वितरित प्रणाली का निर्माण करते समय मुझे एकीकरण परीक्षणों की आवश्यकता होती है जो सभी मुख्य इंटरफ़ेस ऐप और उनकी निर्भरता को पीछे छोड़ देते हैं, फिर सभी को फिर से फाड़ने से पहले उनके खिलाफ विभिन्न परीक्षण किए।

यह उदाहरण के लिए Riak के मुद्दों को जन्म देता है और इसे उपयोग करने वाली किसी भी चीज़ की तुलना में शुरू करने में थोड़ा समय लगता है।

मैं विशेष रूप से यह कहते हुए विरोध नहीं करूंगा कि "कंटेनर async शुरू होते हैं, इसके साथ सौदा करते हैं", लेकिन प्रत्येक सेवा के चारों ओर डिजाइन करना एक सुसंगत स्वास्थ्य परीक्षण को उजागर करना कम से कम कोड के बजाय प्रति सेवा एक कार्यान्वयन के लिए "इसके साथ काम करना" होगा। सेवा पर भरोसा करने वाले प्रत्येक ऐप में पुन: प्रयास करने वाले कनेक्शन से निपटने के लिए।

निगरानी के उद्देश्यों के लिए अपने स्वयं के स्वास्थ्य परीक्षण को परिभाषित करने वाली सेवाएँ भी लाभदायक हैं।

@elliotcm दोनों बिंदुओं पर सहमत हुए।

हमारे CI पर परीक्षण के लिए, हमने एक छोटी सी उपयोगिता का निर्माण किया जिसका उपयोग डॉकटर कंटेनर में किया जा सकता है ताकि लिंक की गई सेवाओं के तैयार होने का इंतजार किया जा सके। यह स्वचालित रूप से सभी लिंक की गई टीसीपी सेवाओं को उनके पर्यावरण चर से बार-बार और समवर्ती रूप से टीसीपी कनेक्शन को स्थापित करने की कोशिश करता है जब तक कि यह सफल या बाहर नहीं हो जाता।

हमने यह बताते हुए एक कि हमने इसे क्यों बनाया और हम इसका उपयोग कैसे करते हैं ।

@eeeeee कि वास्तव में अच्छा और उपयोगी लग रहा है! क्या आप हमें उदाहरण दे सकते हैं कि यह कैसे घूम रहा है; विशेष रूप से एक डॉक-कम्पोज़ के साथ उपयोग में?

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

मैं किसी प्रकार की प्रतीक्षा / जाँच व्यवहार का समर्थन करने के लिए बहुत उत्सुक हूँ, लेकिन वहाँ कुछ भ्रामक मुश्किल मामले हैं। मुझे चर्चाओं में भाग लेने की खुशी है।

@prologic आपको अपने एप्लिकेशन या परीक्षण चलाने से पहले अन्य सेवाओं / कंटेनरों के आधार पर डॉकर कंटेनर में waitforservices कमांड चलाना होगा। यह सभी लिंक की गई सेवाओं को ढूंढता है और तब तक चलता है जब तक यह उनसे जुड़ नहीं सकता है या एक निश्चित समय बीत चुका है (डिफ़ॉल्ट रूप से 60 सेकंड)। बस सभी कोड चलाएं जो बाइनरी छोड़ने के बाद अन्य सेवाओं पर निर्भर करता है (आप बाहर निकलने की स्थिति की जांच करना चाहते हैं)।

@pugnascotia आपका डेटाबेस सर्वर बूटस्ट्रैप होने के दौरान केवल लोकलहोस्ट पर ही सुन सकता था - आपको किसी भी तरह के इंडिकेटर का खुलासा करना होगा कि क्या कंटेनर वैसे भी तैयार है। हम MySQL का उपयोग नहीं करते हैं, लेकिन आधिकारिक रूप से पोस्टग्रेस छवि के साथ वेटफ़ोर्स सर्विसेज़ पूरी तरह से काम करती हैं।

@aanand Postgres वास्तव में चुनने के लिए एक उत्कृष्ट उदाहरण है, क्योंकि TCP पोर्ट के खुलने का इंतज़ार _not_ पर्याप्त है - यदि आप इस प्रकार के (docker) परिदृश्य में ऐसा करते हैं, तो आप कभी-कभी FATAL: the database system is starting up. जैसी त्रुटि से प्रभावित होंगे। psql आवश्यक हो जाता है यदि आप सुनिश्चित करना चाहते हैं कि पोस्टग्रैज तैयार है - मैं select version() उपयोग करता हूं, लेकिन शायद एक हल्का विकल्प है।

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

इसे वर्कअराउंड के रूप में उपयोग करना (यह सुनिश्चित नहीं है कि यह बुलेटप्रूफ है):

db:
  image: postgres:9.3
  ports:
    - "5432:5432"
createdbs:
  image: postgres:9.3
  links:
    - db
  command: >
    /bin/bash -c "
      while ! psql --host=db --username=postgres; do sleep 1; done;
      psql --host=db --username=postgres -c 'CREATE DATABASE \"somedatabase\";';
    "

मैं @olalonde के समान तरीकों का उपयोग कर रहा हूं। /bin/bash -c बाद निष्पादित होने वाली कमांड के लिए एकल उद्धरणों का उपयोग करते समय, मैं उन पर्यावरण चर का भी उपयोग करने में सक्षम हूं जो लिंक से फिर से उपयोग किए जाते हैं जब अन्य एप्लिकेशन ताकि मैं उपयोगकर्ता नाम और पासवर्ड का उपयोग कर सकता हूं बिना उन्हें बनाए रखने के लिए दो में स्थानों। यह उन स्थितियों के लिए अच्छी तरह से काम करता है जहां मेरे पास एक सेवा है, जैसे कि एपीआई, जिसमें एक डेटाबेस होने की आवश्यकता है, और एक विशिष्ट तालिका या रिकॉर्ड मौजूद है या नहीं यह देखने के लिए एक क्वेरी जाँच चलाकर उचित डेटा बूटस्ट्रैप किया गया है। इसका मतलब यह भी है कि मुझे डेटाबेस को ठीक से क्वेरी करने के लिए कंटेनर में किसी प्रकार के क्लाइंट को स्थापित करने की आवश्यकता है, लेकिन यह काम करता है।

+1 मुझे वास्तव में इस कार्यक्षमता में दिलचस्पी है

निर्भरता के लिए +1। मैं मानता हूं कि किसी भी स्टार्ट अप ऑर्डर का समर्थन करने के लिए सिद्धांत रूप में वास्तुकला काफी मजबूत होनी चाहिए। लेकिन, कई बार, ऐसा करना व्यावहारिक नहीं होता है।

यह महसूस करता है कि इस सुविधा के लिए पीछे से धक्का दूसरों को वास्तुकला से दूर करने की कोशिश कर रहा है; जहां उन्हें वास्तव में ऐसा करने का कोई अधिकार नहीं है। यह सुविधा समय-समय पर रिफ्लेक्टर का काम करने की अनुमति देती है; अल्पकालीन मूल्य के साथ। (रीफैक्टरिंग की खातिर रिफ्लेक्टरिंग)।

हां, मैंने कहा "चारों ओर काम"; और मुझे गंदा लगता है। लेकिन मेरी रचना वास्तव में दूसरों को उत्पादक बनाने में सक्षम बनाने के बारे में है। यह सरल विन्यास सक्षम बनाता है।

यदि यह सुविधा टूलस्ट में मौजूद है, तो मैं अपनी समस्या को एक मिनट में हल कर सकता हूं और वास्तविक मूल्य जोड़ सकता हूं। इसके बजाय, मैं बाहरी निर्भरता वाले ऑर्डर के मुद्दों को शुरू करने की कोशिश कर रही दीवार के खिलाफ अपना सिर पीट रहा हूं।

@beardface , और बाकी सभी: कौन सी सुविधा, विशेष रूप से, आपको अपने ऐप को विकसित करने के साथ आगे बढ़ने में सक्षम करेगी?

1. उस सेवा को निर्दिष्ट करने की क्षमता A को सेवा B शुरू होने तक प्रतीक्षा करने की आवश्यकता है? (जो, ध्यान रखें, अभी भी रेस की स्थिति को हल नहीं करेगा जब एक कंटेनर शुरू होता है लेकिन कनेक्शन स्वीकार करने के लिए तैयार नहीं है)
2. यह निर्दिष्ट करने की क्षमता कि सेवा B को कनेक्शन स्वीकार करने तक प्रतीक्षा करनी होगी? (जो, ध्यान रखें, अभी भी दौड़ की स्थिति को हल नहीं करेगा जब एक कंटेनर की बात सुनकर लेकिन प्रारंभिक रूप से समाप्त नहीं हुई है - उदाहरण के लिए स्टार्टअप पर एक डेटाबेस बनाने वाला कंटेनर @rarkins उदाहरण का उपयोग
3. सेवा बी पर एक स्वास्थ्य जांच को परिभाषित करने की क्षमता, और उस सेवा को निर्दिष्ट करने के लिए ए को सेवा बी के स्वास्थ्य जांच से गुजरने तक इंतजार करना होगा?

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

+3

हालांकि, कुछ बुनियादी स्वास्थ्य जांचों को शामिल करना अच्छा होगा। पोर्ट 80_ पर _http 200 ओके जैसा कुछ इतना आम है कि यह प्रयास के लायक हो सकता है।

यह अच्छा होगा एक "बैटरी शामिल" नंबर 3 (ताकि मैं उपरोक्त सभी कहने की हिम्मत करता हूं?)

"कंटेनर ऊपर है" के लिए क्षमता में निर्मित Ie, "फ़ाइल मौजूद है" और "पोर्ट खुला है" प्रकार के वेट और फिर लोगों को अपने स्वयं के "एप्लिकेशन लेयर" चेक को परिभाषित करने का एक तरीका है।

3 को मेरा वोट मिला

3 एक अधिक सामान्य है 2 एक अधिक सामान्य है। सभी 3 पसंद करेंगे, लेकिन 2 या 1 कुछ के लिए पर्याप्त होगा।

3 के लिए वोट करें

जाहिर है तीसरा विकल्प। इस चर्चा में केवल मामलों का भार है। इसलिए पहला और दूसरा विकल्प बहुत अच्छा होगा और बहुत से लोग खुश होंगे, लेकिन यह मुद्दा खुला रहेगा।

3 के लिए वोट करें

3 के लिए वोट करें

वोट के लिए 3. बीटा परीक्षण में रुचि यह भी।

3 के लिए वोट करें।

वोट के लिए 3. बीटा परीक्षण में रुचि यह भी।

3 के लिए वोट करें

3

सबको धन्यवाद। अब आप मतदान रोक सकते हैं - मुझे लगता है कि संदेश स्पष्ट है।

मैं https://github.com/docker/compose/issues/374#issuecomment -126312313 में प्रस्तावित डिज़ाइन पर प्रतिक्रिया चाहता

wait_for_tcp सुविधा पद्धति उपयोगी होगी, लेकिन मेरे लिए यह स्पष्ट नहीं है कि स्वास्थ्य जांच करने के लिए एक अलग कंटेनर होने से यह उसी कंटेनर में करने से आसान है जैसा कि @olalonde और @mbentley द्वारा ऊपर वर्णित है। ।

क्या कुछ ऐसा करने के बारे में क्या alexec docker-maven-plugin में कर रहा है? उन्होंने स्पष्ट रूप से अपने विन्यास को डॉक-कंपोज़ / अंजीर के समान बनाया और अब तक, यह मेरी परियोजनाओं के लिए बहुत अच्छा काम किया।

healthChecks:
  pings:
     # check this URL for 200 OK
     - https://localhost:8446/info
     # check another URL with non-default time out, with a pattern, and non checking SSL certificates
     - url: https://localhost:8446/info
       timeout: 60000
       pattern: pattern that must be in the body of the return value
       sslVerify: false
  logPatterns:
     - pattern that must be in log file
     - pattern: another pattern with non-default timeout
       timeout: 30000

स्रोत: https://github.com/alexec/docker-maven-plugin/blob/master/forage.d

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

@ceagan जैसा। कस्टम कमांड भी उपयोगी होंगे। जैसे

healthChecks:
  custom:
    # retry this command until it returns success exit code
    - cmd: psql --host=localhost --username=postgres
      sleep: 1s

मुझे भी लगता है कि checks healthChecks से बेहतर होगा क्योंकि केस कन्वेंशन को याद करने की कोई आवश्यकता नहीं है। wait (स्वास्थ्य जांच चलाने के लिए शुरू होने से पहले कितने सेकंड इंतजार करना उपयोगी हो सकता है), attempts (कितनी बार स्वास्थ्य को छोड़ने से पहले जांच की जानी चाहिए), retire (पूरी तरह से देने से पहले इंतजार करने के लिए कितने सेकंड) पैरामीटर।

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

यहाँ भी, विकल्प 3।

+1

+1

+1

मैं एक कस्टम प्रतीक्षा स्क्रिप्ट के साथ रहूँगा, हालाँकि, यह बहुत अच्छा होगा।

+1

+1

विकल्प 3-स्वास्थ्य परीक्षण अच्छा लगता है।

+1

+1

+1

+3।
चर्चा में कुछ अन्य विचारों को जोड़ने के लिए, @ नानानंद ने जो विकल्प प्रस्तावित किए हैं, वे वास्तव में कह रहे हैं: कंटेनरों की स्थिति में डॉक-कंपोज की । डॉकटर-कम्पोज इन सभी उपयोग के मामलों को साफ-सुथरे और सुरुचिपूर्ण तरीके से लागू कर सकता था, अगर डॉकटर राज्य की जानकारी प्रदान करता। लेकिन कर्ता नहीं है। यह तत्काल, स्टेटलेस कंटेनरों की दृष्टि से चिपक जाता है, इतनी तेजी से लॉन्च करना कि इस प्रकार के सिंक्रनाइज़ेशन मुद्दे महत्वहीन हैं।
मेरे मामले में, मैं अपनी सेवाओं के लिए, प्रत्येक मामले के लिए सर्वश्रेष्ठ वास्तुकला चुनने में सक्षम होने के विचार का पीछा करता हूं। उदाहरण के लिए, कभी-कभी मैं कई MariaDB उदाहरण चाहते हैं, प्रत्येक एक एकल अनुप्रयोग की सेवा कर रहा है। अन्य बार मैं एक एकल मारियाडीबी उदाहरण चाहता हूं, जो कई अनुप्रयोगों की सेवा कर रहा है। मैं नहीं चाहता कि डोकर मुझे बताए कि सबसे अच्छा क्या है, या मुझे इसके बजाय क्या करना चाहिए। डॉकर को हमेशा इस तरह के प्रलोभन लगते हैं;)।
मुझे लगता है कि सबसे अच्छा समाधान डॉकटर को यह समझाने के लिए है कि कंटेनरों ने अपने बारे में मनमाना मेटाडेटा घोषित किया है, और उस सुविधा का उपयोग डॉकटर-कंपोज को यह पता लगाने के लिए करें कि क्या कंटेनर को "तैयार" माना जाता है ताकि दूसरों पर भरोसा कर सकें।
"सिंगल डीबी-मल्टीपल एप्स" दृष्टिकोण के लिए, मैं एक परिभाषा चाहूंगा जैसे:

db:
  image: postgres:9.3
  ports:
    - "5432:5432"
app1:
  image: wordpress
  links:
    - db [WP]
app2:
  image: ghost
  links:
    - db [GST]

Docker Compose "db" लॉन्च करेगा, और इसके मेटाडेटा (Docker Compose के लिए प्रासंगिक) के बारे में पूछेगा। Yml फ़ाइल से, यह जानता है कि "app1" "db" को "वर्डप्रेस रेडी" होने का अर्थ है (न केवल कनेक्शन को स्वीकार करना, बल्कि आवश्यक वस्तुओं के साथ भी)।

मेरे पास इस स्थिति को हल करने के लिए एक सरल समाधान नहीं है। मैं वर्तमान में इसे दो चरणों में मैन्युअल रूप से करता हूं: एक कस्टम पोस्टग्रैक्स्ल-बूटस्ट्रैप छवि, जिसमें मैं इसे एक्सेस करने के लिए डीबी और डेटाबेस उपयोगकर्ता बनाता हूं; और एक कस्टम liquibase-postgresql छवि, डीडीएल द्वारा प्रदान किए गए डेटाबेस ऑब्जेक्ट से उत्पन्न करने के लिए (या Wordpress कंटेनर से निकाला)। तभी, मैं "app1" लॉन्च कर सकता हूं।
यदि मुझे "अवसंरचना" और "ऐप्स" समूहों में कंटेनरों को अलग करने के लिए मजबूर किया जाता है, अगर "अवसंरचना" कंटेनर विभिन्न अनुप्रयोगों की सेवा कर रहे हैं।

Docker Compose खुद Docker की तरह ही स्टेटलेस होना चाहता है। मुझे नहीं पता कि क्या यह संभव है अगर यह वास्तव में उपयोगी होना चाहता है।

विकल्प 3 के लिए +1

+1

विकल्प 3 के लिए +1।

विकल्प 3 के लिए +1

विकल्प 3 के लिए +1

यह मुद्दा कुछ समय के आसपास रहा है, इसका समाधान क्या है?

@ bweston92 मुझे लगता है कि स्थिति यह है कि @aand ने इस धागे में पहले एक समाधान प्रस्तावित किया था और इसकी तलाश कर रहा है

किसी भी वैकल्पिक डिजाइन प्रस्तावों, उनकी ताकत / कमजोरियों की चर्चा के साथ।

व्यक्तिगत रूप से, मुझे लगता है कि @aanand का प्रस्तावित समाधान बहुत मायने रखता है। यह मेरे लिए बहुत स्पष्ट लगता है, जबकि लचीले ढंग से भी। यह मेरी जरूरतों को पूरा करेगा ओटी टीसीपी पोर्ट के खुलने का इंतजार कर रहा है या बस एक निश्चित समय का इंतजार कर रहा है।

मेरा उपयोग मामला सिर्फ परीक्षण के लिए है। डेटाबेस बनने से पहले शुरू होने पर मेरे परीक्षण विफल हो जाएंगे, इसलिए मैंने उनकी कॉमैंड को bash -c "sleep 2; python manage.py test --keepdb" बदल दिया, जैसे:

db:
    image: postgres:9.5
test:
    build: .
    command: bash -c "sleep 2; python manage.py test --keepdb"
    volumes:
        - ./test_project:/app
    links:
        - db
        - selenium
    environment:
        - EXTERNAL_TEST_SERVER=http://testserver:8000/
        - SELENIUM_HOST=http://selenium:4444/wd/hub
selenium:
    image: selenium/standalone-chrome:2.48.2
    links:
        - testserver
testserver:
    build: .
    command: bash -c "sleep 5; python manage.py testserver 8000 --static"
    volumes:
        - ./test_project:/app
    ports:
      - "8000:8000"
    links:
        - db

ताकि मैं पहले डेटाबेस को शुरू करने और प्रतीक्षा किए बिना docker-compose run test चला सकूं।

यह बताना मुश्किल है कि इन दिनों कौन सा मुद्दा "सही" है एक नए डॉकटर की कार्यक्षमता के लिए वोट करने के लिए जो स्पष्ट निर्भरता की घोषणा करने की अनुमति देता है, लेकिन मेरे वोट को एक मजबूत विचार है। नए डॉकटर 1.9 नेटवर्किंग कार्यक्षमता के साथ, और इसके पक्ष में कंटेनर लिंक के घटते घटाव के साथ, अब यह सुनिश्चित करने का कोई शानदार तरीका नहीं है कि कंटेनर A कंटेनर B से पहले शुरू होता है - क्योंकि यदि आप Docker 1.9 उपयोगकर्ता द्वारा परिभाषित नेटवर्किंग का उपयोग करते हैं, तो आप अब कंटेनर लिंक निर्दिष्ट नहीं करें। वह ... टूट गया है।

मैं सहमत हूँ। वहाँ विकल्प 3 प्राप्त करने के लिए एक समयरेखा है? यह तेजी से होना बहुत अच्छा होगा।

यह ध्यान देने योग्य है कि निर्भरता आदेश वास्तव में इस समस्या को ठीक नहीं करता है। यह समस्या लिंक पर भी लागू होती है। कई मामलों में एक कंटेनर पर्याप्त तेजी से शुरू होता है कि आप इस मुद्दे को नोटिस नहीं करते हैं, लेकिन मुद्दा अभी भी है।

इस समस्या को हल करने के लिए जो आवश्यक है, वह है आवेदन-जागरूक स्वास्थ्य परीक्षण। एक स्वास्थ्य परीक्षण मूल रूप से एक लूप है जो कुछ ऑपरेशन को तब तक के लिए छोड़ देता है जब तक कि: ऑपरेशन सफल हो, या टाइमआउट हिट हो जाए। HTTP सेवा के मामले में, यह तब तक http अनुरोध कर रहा है जब तक आपको 2xx कोड नहीं मिलता। डेटाबेस के लिए यह एक टेबल से कनेक्ट और सेलेक्ट हो सकता है।

जो भी हो, यह अनुप्रयोग विशिष्ट है, इसलिए डेवलपर द्वारा परिभाषित करने की आवश्यकता है। अगर हम https://github.com/docker/compose/issues/374#issuecomment -135090543 से विकल्प 3 को लागू करने के लिए थे, तो भी आपको इस स्वास्थ्य जांच तर्क को लागू करने की आवश्यकता होगी।

इस अंक में कुछ समय पहले ही इसका उल्लेख किया गया है (https://github.com/docker/compose/issues/374#issuecomment-53036154, https://github.com/docker/compose/issues/374#issuecomment-7134229999 ), लेकिन पुन: पुनरावृति करने के लिए, आप इस समस्या को हल कर सकते हैं अपने कनेक्शन को फिर से शुरू करने के लिए एक कनेक्शन को फिर से शुरू करके असफल । आप किसी भी उत्पादन प्रणाली के लिए वैसे भी यह करने की जरूरत है।

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

क्या एंट्रीपॉइंट स्क्रिप्ट के बजाय कम्पोज़ फ़ाइल में इसे शामिल करने का एक महत्वपूर्ण लाभ है? यह शायद बहस के लिए अभी भी है।

Compose फाइल में डालने के लिए बड़ा _dis नुकसान_ यह है कि यह up काफी धीमा बनाता है।

नई नेटवर्किंग के साथ हम up समानांतर में हो सकते हैं (जैसे हम स्टॉप, आरएम और स्केल के लिए करते हैं)। प्रत्येक कंटेनर एक बार में शुरू हो सकता है, कुछ आरंभीकरण कर सकता है, फिर आगे बढ़ने के लिए उपलब्ध होने के लिए इसकी निर्भरता की प्रतीक्षा करें। इससे वातावरण बहुत तेजी से शुरू होता है।

यदि कंपोज को एक हेल्थकेयर को पूरा करने के लिए इंतजार करना पड़ता है, तो स्टार्टअप प्रभावी रूप से अनुक्रमिक होता है। कंटेनर स्टार्टअप और एप्लिकेशन इनिशियलाइज़ेशन समानांतर में नहीं होता है, और सब कुछ धीमा है।

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

मेरे आईफोन से भेजा गया

18 नवंबर, 2015 को पूर्वाह्न 11:01 बजे, डैनियल नेफिन नोटिफिकेशन @ithub.com ने लिखा:

यह ध्यान देने योग्य है कि निर्भरता आदेश वास्तव में इस समस्या को ठीक नहीं करता है। यह समस्या लिंक पर भी लागू होती है। कई मामलों में एक कंटेनर पर्याप्त तेजी से शुरू होता है कि आप इस मुद्दे को नोटिस नहीं करते हैं, लेकिन मुद्दा अभी भी है।

इस समस्या को हल करने के लिए जो आवश्यक है, वह है आवेदन-जागरूक स्वास्थ्य परीक्षण। एक स्वास्थ्य परीक्षण मूल रूप से एक लूप है जो कुछ ऑपरेशन को तब तक के लिए छोड़ देता है जब तक कि: ऑपरेशन सफल हो, या टाइमआउट हिट हो जाए। HTTP सेवा के मामले में, यह तब तक http अनुरोध कर रहा है जब तक आपको 2xx कोड नहीं मिलता। डेटाबेस के लिए यह एक टेबल से कनेक्ट और सेलेक्ट हो सकता है।

जो भी हो, यह अनुप्रयोग विशिष्ट है, इसलिए डेवलपर द्वारा परिभाषित करने की आवश्यकता है। यदि हम # 374 (टिप्पणी) से विकल्प 3 को लागू करने के लिए थे, तब भी आपको इस स्वास्थ्य जांच तर्क को लागू करने की आवश्यकता होगी।

पहले से ही इस मुद्दे में कुछ समय का उल्लेख किया गया है (# 374 (टिप्पणी), # 374 (टिप्पणी)), लेकिन पुन: पुन: पुन: पुन: दर्ज करने के लिए, आप आज इस समस्या को हल कर सकते हैं अपने कनेक्शन को विफल करने के लिए एक कनेक्शन को पुनः प्रयास करके। आप किसी भी उत्पादन प्रणाली के लिए वैसे भी यह करने की जरूरत है।

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

क्या एंट्रीपॉइंट स्क्रिप्ट के बजाय कम्पोज़ फ़ाइल में इसे शामिल करने का एक महत्वपूर्ण लाभ है? यह शायद बहस के लिए अभी भी है।

कम्पोज फाइल में इसे डालने का बड़ा नुकसान यह है कि यह काफी धीमा हो जाता है।

नई नेटवर्किंग के साथ हम समानांतर में हो सकते हैं (जैसे हम स्टॉप, आरएम और स्केल के लिए करते हैं)। प्रत्येक कंटेनर एक बार में शुरू हो सकता है, कुछ आरंभीकरण कर सकता है, फिर आगे बढ़ने के लिए उपलब्ध होने के लिए इसकी निर्भरता की प्रतीक्षा करें। इससे वातावरण बहुत तेजी से शुरू होता है।

यदि कंपोज को एक हेल्थकेयर को पूरा करने के लिए इंतजार करना पड़ता है, तो स्टार्टअप प्रभावी रूप से अनुक्रमिक होता है। कंटेनर स्टार्टअप और एप्लिकेशन इनिशियलाइज़ेशन समानांतर में नहीं होता है, और सब कुछ धीमा है।

-
इस ईमेल का उत्तर सीधे दें या इसे GitHub पर देखें।

@dnephin अंतिम परिणाम यह है कि आपके पास प्रत्येक और प्रत्येक सेवा के लिए एक ही आवरण स्क्रिप्ट है। मेरा कहना है कि कुछ चीजें ऐसी हैं जो बहुत सामान्य हैं (जैसे एचटीटीपी 200 80 और 443 या टीसीपी 5432 पर) कि उन्हें रचना के साथ शिप करना एक अच्छा विचार है।

निश्चित रूप से, एप्लिकेशन स्तर पर यह सब हल करना अच्छा होगा, लेकिन वास्तव में आपके पास अपने स्वयं के एप्लिकेशन पर नियंत्रण होगा और डेटाबेस, कैश या मसाज कतार जैसे अन्य सभी चलती भागों में नहीं।

मैं @mbdas और @jayfk दोनों से सहमत हूं, और बस जोड़ दूंगा: अगर इसका प्रतिरोध यह है कि कंटेनर स्टार्टअप की निर्भरता-विशिष्टताओं और परिणामी आदेश के साथ भी विफलताएं होंगी, तो कंटेनर लिंक और वॉल्यूम का उपयोग-से नियंत्रण कंटेनर स्टार्टअप ऑर्डर कभी भी नहीं होना चाहिए - हम सभी से पूछ रहे हैं कि अब नया नेटवर्क मॉडल का अर्थ है कि लिंक को हटा दिया जा रहा है (और यह कि नया नेटवर्क मॉडल सचमुच लिंक के साथ सह-अस्तित्व नहीं रख सकता है), वही स्टार्टअप -ऑर्डर कार्यक्षमता है कि लिंक की अनुमति हमें किसी तरह से वापस दे दी जाती है। निश्चित रूप से, लिंक-आधारित कंटेनर ऑर्डरिंग के साथ होने वाली कोई भी विफलता के मामले अभी भी नए नेटवर्क मॉडल और कंटेनर निर्भरता के साथ हो सकते हैं, लेकिन हम सभी इसके साथ रहना सीख चुके हैं।

@delfuego : क्या आप इस बात पर विस्तार से अपदस्थ किया जा रहा है, और विशेष रूप से वे क्या बदल रहे हैं? कुछ डॉक्टर / उदाहरण के लिए लिंक पर्याप्त है

@Silex https://docs.docker.com/compose/networking क्या आपका मतलब है?

@ h17liner : हाँ, यह दिलचस्प है! धन्यवाद

जबकि मैं @dnephin से सहमत

इस समस्या का कुछ समय पहले ही उल्लेख किया जा चुका है, लेकिन पुन: पुन: पुन: दर्ज करने के लिए, आप इस समस्या को हल कर सकते हैं अपने कनेक्शन को फिर से शुरू करने से असफल होने पर एक कनेक्शन को पुनः प्राप्त करके। आप किसी भी उत्पादन प्रणाली के लिए वैसे भी यह करने की जरूरत है।

मैं इसे परीक्षण परीक्षणों जैसे कुछ के लिए बनाने के रूप में नहीं देखता हूं। यदि मैं सिर्फ परीक्षण कर रहा हूं कि क्या कोई मॉडल Django ऐप में सही तरीके से बचाता है, तो मुझे यकीन नहीं है कि डेटाबेस कनेक्शन में लचीलापन जोड़ने के लिए यह कितना समझ में आता है।

@delfuego मुझे लगता है कि आप मूल रूप से उस मुद्दे के लिए (# 686) सही जगह पर थे। यह समस्या आदेश देने के बारे में नहीं है, यह स्टार्टअप में कृत्रिम विलंब के बारे में है (जब कोई आदेश पहले से मौजूद है)। जबकि ये चीजें संबंधित हैं, वे अलग-अलग मुद्दे हैं।

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

मेरे आईफोन से भेजा गया

19 नवंबर, 2015 को सुबह 8:14 बजे, डैनियल नेफिन नोटिफिकेशन @ithub.com ने लिखा:

@delfuego मुझे लगता है कि आप मूल रूप से उस मुद्दे के लिए (# 686) सही जगह पर थे। यह समस्या आदेश देने के बारे में नहीं है, यह स्टार्टअप में कृत्रिम विलंब के बारे में है (जब कोई आदेश पहले से मौजूद है)। जबकि ये चीजें संबंधित हैं, वे अलग-अलग मुद्दे हैं।

-
इस ईमेल का उत्तर सीधे दें या इसे GitHub पर देखें।

मैं विकल्प 4 प्रस्तावित करना चाहूंगा (कुछ कह सकते हैं कि यह वास्तव में 3 की भिन्नता है)
कंटेनर तब तक तैयार नहीं होता जब तक कि सभी स्टार्टअप कमांड 0 एग्जिट कोड के साथ समाप्त नहीं हो जाते। प्रत्येक कंटेनर के लिए yml फ़ाइल में इन स्टार्टअप कमांड को परिभाषित करना संभव है। इन आदेशों को ऐसे निष्पादित किया जाता है जैसे आप कंटेनर चलाने के खिलाफ "docker exec" के साथ करेंगे। क्लासिक यूनिट टेस्टिंग में setUp () और आंसूओं () के तरीकों पर विचार करें। हां, हमारे पास "शटडाउन" कमांड भी हो सकती है।
स्पष्ट रूप से पदानुक्रम में अगला कंटेनर तब तक लॉन्च नहीं किया जाता है जब तक कि सभी कंटेनर निर्भर न हों।
महान DockerCon.Eu 2015 के लिए PS धन्यवाद

एक HEALTHCHECK निर्देश बहुत अधिक लचीला है (अर्थात किसी भी बाद के बिंदु पर इस्तेमाल किया जा सकता है) और सहायक। सेटअप CMD या (बेहतर अभी तक) ENTRYPOINT स्क्रिप्ट के भीतर किया जाना चाहिए, सिग्नल संकेतों को संभालने के द्वारा फाड़।

मुझे लगता है कि यहाँ समस्या यह है कि लोग एक docker-compose up कमांड एक स्टैक को लाने के लिए चाहते हैं और सब कुछ बस जादुई रूप से काम करता है।

सभी फीडबैक के आधार पर अलग-अलग उपयोग के मामलों के लिए स्पष्ट रूप से कई समाधान हैं, लेकिन कोई भी "एक आकार सभी फिट नहीं है"।

आप कई डॉकटर-कम्पोज़ कमांड्स को निष्पादित करके "इनिशियलाइज़ेशन" कार्यों को बहुत आसानी से निष्पादित कर सकते हैं - और मुझे लगता है कि यह दृष्टिकोण सबसे सामान्य और लचीला दृष्टिकोण है।

उदाहरण के लिए, मैं "एजेंट" कंटेनर में एक एकल कार्यपुस्तिका में एक एकल कार्य के साथ चलाता हूं जो मेरे डेटाबेस (MySQL) कंटेनर के लिए 3306 पोर्ट पर चलने की प्रतीक्षा करता है। यह "एजेंट" कंटेनर मेरे "db" कंटेनर से स्वचालित रूप से जुड़ा हुआ है निम्नलिखित निष्पादित होने पर इसे शुरू करता है:

$ docker-compose run --rm agent
Creating db_1

PLAY [Probe Host] *************************************************************

TASK: [Set facts] *************************************************************
ok: [localhost]

TASK: [Message] ***************************************************************
ok: [localhost] => {
    "msg": "Probing db:3306 with delay=0s and timeout=180s"
}

TASK: [Waiting for host to respond...] ****************************************
ok: [localhost -> 127.0.0.1]

PLAY RECAP ********************************************************************
localhost                  : ok=3    changed=0    unreachable=0    failed=0

जिसके बाद मैं docker-compose up चला सकता हूं यह जानते हुए कि db कंटेनर पूरी तरह से चालू है।

यहाँ एक सरल docker-compose.yml फ़ाइल है जो इसका समर्थन करती है:

...
...
db:
  image: mysql
  hostname: db
  expose:
    - "3306"
  environment:
    MYSQL_DATABASE: xxx
    MYSQL_USER: xxx
    MYSQL_PASSWORD: xxx
    MYSQL_ROOT_PASSWORD: xxx

agent:
  image: cloudhotspot/ansible
  links:
    - db
  volumes:
    - ../../ansible/probe:/ansible
  environment:
    PROBE_HOST: "db"
    PROBE_PORT: "3306"

"एजेंट" कंटेनर site.yml /ansible माउंट किए गए वॉल्यूम के नाम से एक प्लेबुक चलाता है, जो नीचे दिखाया गया है:

- name: Probe Host
  hosts: localhost
  connection: local
  gather_facts: no
  tasks: 
    - name: Set facts
      set_fact: 
        probe_host: "{{ lookup('env','PROBE_HOST') }}"
        probe_port: "{{ lookup('env','PROBE_PORT') }}"
        probe_delay: "{{ lookup('env','PROBE_DELAY') | default(0, true) }}"
        probe_timeout: "{{ lookup('env','PROBE_TIMEOUT') | default (180, true) }}"
    - name: Message
      debug: msg="Probing {{ probe_host }}:{{ probe_port }} with delay={{ probe_delay }}s and timeout={{ probe_timeout}}s"
    - name: Waiting for host to respond...
      local_action: >
        wait_for host={{ probe_host }}
        port={{ probe_port }}
        delay={{ probe_delay }}
        timeout={{ probe_timeout }}
      sudo: false

एकल docker-compose up लक्ष्य का एक समाधान डॉकटर कंपोज़ के लिए "वर्कफ़्लो" सुविधा शुरू करना और एक वैकल्पिक वर्कफ़्लो कल्पना फ़ाइल शामिल करना हो सकता है जो एक या एक से अधिक डॉकर-कंपोज़ कमांडों को निर्दिष्ट करके अधिक जटिल और नियंत्रित ऑर्केस्ट्रेशन परिदृश्यों के लिए अनुमति देता है। "कार्य" जिसे निष्पादित किया जाना चाहिए:

# The default workflow, specified tasks will be run before docker-compose up
# The "up" task is implicit and automatically invoked for the default workflow
# The "up" task is explicit for custom workflows as some workflows may not want docker-compose up
default:
  tasks:
    - run --rm agent
    - up

# Custom workflows that can be invoked via a new docker-compose command option
# This example:
# 1. Runs agent container that waits until database container is up on port 3306
# 2. Runs Django database migrations from app container
# 3. Runs Django collect static task from app container
# 4. Runs test container that runs acceptance tests against linked app container
# Does not execute a docker-compose up afterwards

test:
  tasks:
    - run --rm agent 
    - run --rm app manage.py migrate
    - run --rm app manage.py collectstatic --noinput
    - run --rm test

आज मैं मेकफाइल्स का उपयोग करके उपरोक्त प्राप्त करता हूं, जो विभिन्न परिदृश्यों के लिए अपने स्वयं के वर्कफ़्लोज़ को परिभाषित करने के लिए उच्च-क्रम की क्षमता प्रदान करता है।

यह बहुत अच्छा होगा यदि एक "वर्कफ़्लो" सुविधा या समान को डॉक रचना में पेश किया जा सकता है, जो इस विशेष मुद्दे और बहुत अधिक के लिए एक बहुत ही सामान्य और लचीला समाधान प्रदान करेगा।

सहमत, समस्या यह है कि लोगों को उम्मीद है कि उत्पादन तैनाती के लिए डॉक-कंपो पर्याप्त होगा। व्यक्तिगत रूप से, मुझे लगता है कि यह काफी समय पहले हो जाएगा और संभव है कि कुबेरनेट्स / हेल्म उस लक्ष्य के बहुत करीब हों।

@olalonde , यकीन है कि हम उत्पादन-तैयार होना पसंद करेंगे ... लेकिन हम इसे महत्वपूर्ण और मौजूदा कार्यक्षमता का समर्थन करेंगे, जो कंटेनर लिंक के अपवर्जन को देखते हुए, गायब होने जा रहा है जब तक कि इसे नए उपयोगकर्ता के लिए दोहराया नहीं जाता है निर्मित नेटवर्क मॉडल। (फिर, शायद यह अनुरोध पूरी तरह से इस विशिष्ट मुद्दे के साथ संरेखित नहीं हुआ है - यह मेरे लिए अस्पष्ट है कि क्या कंटेनर स्टार्टअप ऑर्डर प्राप्त करना "यहां" है या समस्या # 686 ...)

HEALTCHECK डॉकर निर्देश के साथ, depends_on कार्यक्षमता या तो कंटेनर स्टार्टअप (कोई हेल्थकेयर) या हेल्थकेच स्क्रिप्ट को सफलतापूर्वक बाहर निकलने के लिए इंतजार कर सकती है (कोड 0 बाहर निकलें)। यह उतना ही लचीला है जितना इसे प्राप्त होता है (आप मनमाने ढंग से तर्क को परिभाषित कर सकते हैं) और हेल्थकेक तर्क को रखता है जहां यह होता है (कंटेनर के भीतर जो जांच की जाती है)।

@ विकास और परीक्षण के लिए भी, यह कार्यक्षमता सहायक होगी। व्यक्तिगत रूप से, मैं docker-compose run test करने में सक्षम होना चाहता हूं और पहले से और मैन्युअल रूप से प्रतीक्षा करने के बिना सेवाओं को लाने के बिना काम करना है। हालांकि यह संभव है, यह सिर्फ इस परियोजना के साथ शुरू करने के लिए थोड़ा अधिक दर्दनाक बनाता है और अधिक तरीके जोड़ता है जिससे परीक्षण विफल हो सकता है।

+1

मुझे लगता है कि संकल्प के लिए एक मध्य मार्ग की आवश्यकता होती है - रचना कभी भी उन सभी अलग-अलग तरीकों का हिसाब नहीं दे पाएगी, जिनमें अनुप्रयोगों को उपलब्ध माना जा सकता है या नहीं। स्वास्थ्य जांच का विचार अलग-अलग लोगों के लिए अलग-अलग चीजों का मतलब होगा, और "यह ऊपर है या नहीं" जितना सरल नहीं हो सकता है। उत्पादन में, आप एक कंटेनर को नीचे ले जा सकते हैं यदि यह असामान्य रूप से लंबे समय तक प्रतिक्रिया समय प्रदर्शित कर रहा था, यहां तक ​​कि यह किसी भी HTTP चेक को पारित कर रहा था।

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

@pugnascotia धन्यवाद, यह एक रचनात्मक टिप्पणी है, और एक उचित दृष्टिकोण ("दोनों दुनिया के सर्वश्रेष्ठ"?)

वर्तमान में चर्चित समाधान वास्तव में _originally report_ समस्या को संबोधित नहीं करते हैं जो कि बहुत सरल है ... जो कि किसी सेवा के उपलब्ध होने की प्रतीक्षा नहीं कर रही है, बल्कि EXIT की सेवा की प्रतीक्षा कर रही है।

मेरे पास एक उपयोग-मामला है जहां मेरे पास दो कंटेनर हैं जो समान बंदरगाहों को उजागर करते हैं। पहला 15-60 सेकंड के लिए चलता है, फिर बाहर निकलता है। फिर दूसरी सेवा शुरू होनी चाहिए। आज की रचना में ऐसा करने के लिए कोई स्पष्ट (स्पष्ट) तरीका नहीं है क्योंकि यह बंदरगाह संघर्ष का पता लगाएगा और बाहर निकल जाएगा; 'पुनः आरंभ: हमेशा' भी एक समाधान नहीं है।

हां, कम्पोज़ उस उपयोग-केस के लिए डिज़ाइन नहीं किया गया है। रचना रनटाइम वातावरण के आसपास केंद्रित है, न कि पाइपलाइनों का निर्माण। मुझे नहीं लगता कि मूल रिपोर्ट के बारे में यही बात है।

अधिक बिल्ड-ओरिएंटेड सुविधाओं के लिए कुछ अनुरोध किए गए हैं, लेकिन मुझे नहीं लगता कि वे रचना के लिए समझ में आते हैं। दोनों फ़ंक्शन बहुत अलग हैं और उन्हें एक ही कॉन्फ़िगरेशन प्रारूप में फिट करने की कोशिश की जा रही है जिससे बहुत सारे भ्रम और एक बुरे अनुभव का अनुभव हो सकता है।

@ewindisch आपके उपयोग के मामले को बैच की नौकरियों की श्रृंखला चलाने के लिए सामान्यीकृत किया जा सकता है। कम्पोज़ उस मामले के लिए मददगार होता है (इसके लिए डिज़ाइन नहीं होने के बावजूद) क्योंकि यह सेवाओं के बीच निर्भरता बनाए रखता है - जैसे कि चेन। लेकिन यह अनुक्रमण और IMHO को नहीं संभालता है क्योंकि ऐसा नहीं होना चाहिए क्योंकि Compose कंटेनरों का _outside_ है और इस बात का कोई पता नहीं है कि _inside_ एक कंटेनर क्या करने जा रहा है।

Compose प्रलेखन के इस भाग में यह प्रश्न शामिल है कि Compose में यह क्षमता क्यों नहीं है:

https://docs.docker.com/compose/faq/#how -do-i-get-compose-to-wait-for-my-database-to-be-ready-before-start-my-application

हालाँकि इन पृष्ठों में इस समस्या का जिक्र नहीं है:

https://docs.docker.com/compose/django/
https://docs.docker.com/compose/rails/
https://docs.docker.com/compose/wordpress/

बहुत कम से कम, इन पृष्ठों में एक पावती शामिल होनी चाहिए कि कम्पोज़ डेटाबेस कंटेनर के तैयार होने की प्रतीक्षा नहीं करेगा। वे इससे निपटने के तरीकों के उदाहरण भी शामिल कर सकते हैं।

@ewindisch वास्तव में, यह वही है जो मैं https://github.com/docker/compose/issues/374#issuecomment -126312313 में प्रस्तावित कर रहा था - इस परिकल्पना के साथ कि _that_ समस्या को हल करना भी उपयोगकर्ताओं को स्टार्टअप ऑर्डर समस्या को हल करने के लिए उपकरण ( यदि दीर्घकालीन लचीलापन की समस्या नहीं है)।

मुझे अब भी उस समाधान स्थान की खोज में दिलचस्पी है, अगर कोई और है।

मैं हूँ।

मैं भी।

+1

+3

+1

+1 को https://github.com/docker/compose/issues/374#issuecomment -12631234 समाधान के कार्यान्वयन के लिए।

बड़े पैमाने पर उत्थान!
वर्तमान में यह प्रभाव कंटेनर में चलने वाले उपकरणों के उपयोग का है, लेकिन docker घटनाओं (जैसे jwilder / nginx -xy) पर भरोसा करते हैं। जिस तरह से मैं ऐसा करता हूं वह बस श्रोता को डॉकटर-कंपोज करता है और बाद में अन्य सभी कंटेनरों को चलाता है (जो एक प्रविष्टि बिंदु के रूप में डॉक-कंपोज की सभी सुंदरता को खराब कर देता है)।

@meetmatt क्या आपने बाद में jwilder / nginx -xy चलाने की कोशिश की है? शुरू करने के आदेश के लिए कोई बात नहीं होनी चाहिए, यह शुरू होने पर मौजूदा (चल रहे) कंटेनरों को उठाएगा

+1

+1

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

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

मुझे गिनें, निष्पादन पाइपलाइन की भविष्यवाणी के रूप में हम काम पर क्या करते हैं के लिए एक महत्वपूर्ण बात है। +1

+1

मेरा कुछ छूट रहा है।

क्यों कोई एक "वेटर रन (docker इंजन)) में" प्रतीक्षा तक "जोड़ने की वकालत नहीं कर रहा है। सभी मामलों में, जिनके बारे में मैं सोच सकता हूं, आश्रित कंटेनर को पता है कि यह "तैयार" कब हुआ है लेकिन डॉकटर इसका सम्मान नहीं करता है।

मूल मामले में (mysql एक बड़ा डेटा सेट और अल्फ्रेस्को लोड कर रहा है), mysql कंटेनर वापस आ सकता है या सिग्नल दे सकता है जब यह तैयार होता है और तब तक अल्फ्रेस्को कंटेनर शुरू नहीं होगा।

मैं मनमाने ढंग से तर्क और संकेत को चलाने के लिए चाहूंगा जब मैं तैयार हो जाऊंगा जैसा कि मेरे द्वारा तय किया गया है (जैसे कि जब लॉग में एक निश्चित संदेश दिखाई देता है -> सिग्नल CONTAINER_UP)।

net: "container:[name or id]" मेरे कंटेनरों के स्टार्टअप का आदेश क्यों नहीं? मुझे links गिराना पड़ा क्योंकि यह पदावनत हो जाएगा और मैं चाहता हूं कि पूरे स्टैक net: "host" नेटवर्किंग का उपयोग करें। दुर्भाग्य से यह links साथ अनुमति नहीं है। क्या कंटेनरों के बूट ऑर्डर को बदलने का एक और तरीका है या मुझे उनके बीच बेकार वॉल्यूम साझा करना होगा?

अपडेट करें:

मैंने सिर्फ links बजाय बेकार वॉल्यूम के साथ री-ऑर्डर किया:

base:
  build: ./base
  net: "host"
  volumes:
    - /root/lemp_base
phpmyadmin:
  build: ./phpmyadmin
  net: "host"
  volumes_from:
    - base
  volumes:
    - /root/lemp_phpmyadmin
ffmpeg:
  build: ./ffmpeg
  net: "host"
  volumes_from:
    - phpmyadmin
  volumes:
    - /root/lemp_ffmpeg
mariadb:
  build: ./mariadb
  net: "host"
  volumes_from:
    - ffmpeg
  volumes:
    - /root/lemp_mariadb
php:
  build: ./php
  net: "host"
  volumes_from:
    - mariadb
  volumes:
    - /root/lemp_php
nginx:
  build: ./nginx
  net: "host"
  volumes_from:
    - php
  volumes:
    - /root/lemp_nginx

(मैंने स्टैक से अन्य साझा किए गए संस्करणों को साफ किया और कंटेनर_नाम जैसे अन्य इन्फोस, सरल दिखने के लिए पोर्ट।)

अगर मैं net: "container:base साथ उपयोग करना चाहता हूं, तो मुझे docker-compose build कमांड पर एक त्रुटि संदेश मिला है।

ERROR: Service "mariadb" is trying to use the network of "lemp_base", which is not the name of a service or container.

क्या मैं नहीं की तरह इस समाधान है के बारे में है कि हर दूसरे कंटेनर में वेबसर्वर फ़ाइलें मिल गया होगा /var/www से फ़ोल्डर base ।

संपादित करें:
किसी कारण से यह स्टैक स्टार्टअप पर पूरे /var/www फ़ोल्डर को हटा रहा है।

मेरा विनम्र मत है कि डॉकटर कम्पोज़ के साथ कंटेनर के बीच निर्भरता के बारे में जानने वाला कोई भी तंत्र सेपरेशन ऑफ कंसर्न के खिलाफ जाता है। Docker Compose रनिंग कंटेनर्स A और B कंटेनर्स के साथ जिम्मेदार है। A और B अपनी सर्विस के लिए जिम्मेदार हैं। यदि B सही तरीके से काम करने के लिए A पर निर्भर करता है, तो B की जिम्मेदारी है कि वह A की प्रतीक्षा करें कि वह कार्यशील स्थिति में हो। जैसा कि चर्चा में कहा गया है, यह टाइमआउट, रिट्री या जो भी हो, के माध्यम से किया जा सकता है, लेकिन यह बी की समस्या है, न कि डॉकर कंपोज और न ही ए। एस। सी। सेवा की स्वतंत्रता और उचित स्केलिंग के लिए सर्वोपरि है।

क्या आपके विचार 3 @aanand पर कोई काम है? यह जानना अच्छा होगा कि क्या कोई प्रगति है, यह एक आशाजनक शुरुआत की तरह लग रहा था जो एक संपूर्ण समाधान न होने पर भी कुछ बहुत ही सामान्य उपयोग करने में मदद करेगा।

+1

+1

शायद मैं गलत हूं लेकिन args: buildno: कंटेनर को docker-compose.yml 2 संस्करण में ऑर्डर कर सकता हूं?

मैं सहमत हूं कि यह एक ऐसी चिंता है जो कंपोज़ में नहीं है। @jwilder के उत्कृष्ट डॉकरीज़ को आश्रित कंटेनरों के लिए प्रतीक्षा करने के लिए समर्थन मिला और आप उस प्रोटोकॉल / पोर्ट को निर्दिष्ट कर सकते हैं जिस पर आप प्रतीक्षा कर रहे हैं। मैं यह सुझाव दूंगा कि यहां वर्णित अधिकांश उपयोग मामले हैं:

api:
  build: .
  ports:
   - "8000:80"
  expose:
  - "80"

test:
  build: test
  command: dockerize -wait http://api:80 -wait tcp://db:5432 somecommand -some arg -another arg2
  links:
    - api:api

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

मुझे लगता है कि इंतजार रचना के बाहर किया जाना चाहिए। अपने देव में मैं @mefellows के सुझाए गए हाइब्रिड का उपयोग करने जा रहा हूं और स्थिति पृष्ठ timercheck.io । मैं बात करता हूं कि मुझे बिल्कुल वही मिलेगा जो मुझे खरगोशबैंक या कुछ इसी तरह का उपयोग करने की जल्दबाजी के बिना चाहिए।

हम एक शेल स्क्रिप्ट एंट्रीपॉइंट

#!/usr/bin/env bash

# wait for db to come up before starting tests, as shown in https://github.com/docker/compose/issues/374#issuecomment-126312313
# uses bash instead of netcat, because netcat is less likely to be installed
# strategy from http://superuser.com/a/806331/98716
set -e

echoerr() { echo "$@" 1>&2; }

echoerr wait-for-db: waiting for db:5432

timeout 15 bash <<EOT
while ! (echo > /dev/tcp/db/5432) >/dev/null 2>&1;
    do sleep 1;
done;
EOT
RESULT=$?

if [ $RESULT -eq 0 ]; then
  # sleep another second for so that we don't get a "the database system is starting up" error
  sleep 1
  echoerr wait-for-db: done
else
  echoerr wait-for-db: timeout out after 15 seconds waiting for db:5432
fi

exec "$@"

यह आगामी (और जाहिरा तौर पर डॉक्स अपडेट होने के साथ आसन्न) depend_on , हाँ द्वारा हल किया जाना चाहिए?

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

आह, स्पष्टीकरण के लिए धन्यवाद। =)

शायद यह मदद कर सकते हैं http://www.onegeek.com.au/articles/waiting-for-dependencies-in-docker-compose

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

मेरे लिए "उपलब्धता जांच" के एक अनियंत्रित संग्रह को हार्ड-कोड करना अच्छा नहीं है। ऐसी कई स्थितियां हैं जो एक प्रकार की तैनाती के लिए विशिष्ट हैं और आप उन सभी को कभी भी कवर नहीं कर सकते हैं। एक उदाहरण के रूप में, मेरे मल्टी-कंटेनर ऐप में मुझे एक निश्चित लॉग फ़ाइल में एक निश्चित लॉग संदेश के लिए प्रतीक्षा करने की आवश्यकता है - केवल तभी कंटेनर सेवा तैयार होगी।
इसके बजाय जो आवश्यक है वह एक एसपीआई है जिसे मैं लागू कर सकता हूं। यदि डॉकर सबसे अधिक उपयोग किए जाने वाले मामलों (जैसे टीसीपी कनेक्ट) के लिए कुछ उदाहरण कार्यान्वयन प्रदान करता है, तो यह ठीक है। लेकिन मुझे अपनी कार्यक्षमता में प्लग इन करने का एक तरीका होना चाहिए और डॉकर को इसे कॉल करना होगा।
डॉकर कम्पोज़ मेरे लिए एक पूरे उत्पाद के रूप में बहुत बेकार है, अगर मैं अपने कंटेनर को ऊपर और भरोसेमंद रूप से नहीं चला सकता। तो एक स्थिर और वर्दी "कंटेनर सेवा तत्परता एसपीआई" की आवश्यकता है। और "तैयार" एक बूलियन नहीं होना चाहिए, क्योंकि संभवतः तत्परता के अधिक स्तर हैं (जैसे: "अब आप पढ़ सकते हैं" और "अब आप लिख सकते हैं")।

@realulim अच्छा

यह वही है जिसके साथ मैं आया था, एंट्रीपॉइंट फ़ाइल में;

until netcat -z -w 2 database 5432; do sleep 1; done
# do the job here, database host on port 5432 accepts connections

@kulbida ,
मैं MySQL के साथ कुछ ऐसा ही करता हूं। इस मामले में "डेटाबेस" एक रचना फ़ाइल में एक कड़ी है।

if [[ "$APP_ENV" == "local" ]]; then
    while ! mysqladmin ping -h database --silent; do
        sleep 1
    done
    # Load in the schema or whatever else is needed here.
fi

इस थ्रेड में कुछ टिप्पणियां दी गई हैं जो दावा करती हैं कि स्टार्टअप ऑर्डरिंग केवल एप्लिकेशन स्तर की त्रुटि पुनर्प्राप्ति का एक सबसेट है, जिसे आपके एप्लिकेशन को वैसे भी संभालना चाहिए। मैं उदाहरण के लिए एक उदाहरण पेश करना चाहूंगा जहां यह हमेशा नहीं हो सकता है। विचार करें कि क्या कुछ सेवाएँ क्लस्टर डेटाबेस पर निर्भर करती हैं, और जब भी किसी क्रैश आदि के कारण कोरम खो जाता है, तो आप _not_ ऐप से स्वचालित रूप से पुनः प्रयास करना चाहते हैं। उदाहरण के लिए यह मामला हो सकता है अगर डेटाबेस रिकवरी के लिए कुछ मैनुअल चरणों की आवश्यकता होती है, और जब तक उन चरणों को पूरा नहीं किया जाता है, तब तक आपको सेवाओं की आवश्यकता नहीं होती है।

अब ऐप का एरर हैंडलिंग लॉजिक स्टार्टअप लॉजिक से काफी अलग हो सकता है:

• यदि db नीचे है क्योंकि हम अभी शुरू कर रहे हैं, तो इसके उपलब्ध होने की प्रतीक्षा करें।
• अगर db नीचे है क्योंकि यह दुर्घटनाग्रस्त हो गया है, एक महत्वपूर्ण त्रुटि दर्ज करें और मर जाएँ।

यह सबसे आम परिदृश्य नहीं हो सकता है, लेकिन आप इस पैटर्न को कभी-कभी देखते हैं। इस स्थिति में, सामान्य मामले में "नेटवर्क अविश्वसनीय है" समस्या को हल करने के लिए क्लस्टरिंग का उपयोग किया जाता है, जो कुछ अपेक्षाओं को बदल देता है जिसके चारों ओर त्रुटि की स्थिति को ऐप में वापस लिया जाना चाहिए। क्लस्टर क्रैश काफी दुर्लभ हो सकते हैं, और स्वचालित रूप से उन्हें पुनरारंभ करना काफी जोखिम भरा हो सकता है, कि मैन्युअल रूप से पुनरारंभ सेवाओं को एप्लिकेशन में पुन: प्रयास करना पसंद किया जाता है। मुझे संदेह है कि अन्य परिदृश्य भी हैं, जो कि रिटायर होने के समय के आसपास की धारणाओं को चुनौती दे सकते हैं।

आम तौर पर, मैं दावा कर रहा हूं कि स्टार्टअप ऑर्डर और एरर हैंडलिंग हमेशा समतुल्य नहीं होते हैं, और यह स्टार्टअप ऑर्डर को प्रबंधित करने के लिए (वैकल्पिक) फीचर्स प्रदान करने के लिए एक फ्रेमवर्क के लिए उपयुक्त है। मुझे आश्चर्य है कि क्या यह डॉक-इंजन में है, हालांकि, रचना के बजाय। इसकी जरूरत कभी भी पड़ सकती है, भले ही कंपोज का इस्तेमाल किया जाए या नहीं।

स्वास्थ्य परीक्षण के लिए समर्थन जोड़ने के लिए प्रस्ताव https://github.com/docker/docker/issues/21142 में docker engine repo पर चर्चा शुरू हो रही है। एक बार जब यह समर्थन उपलब्ध हो जाता है, तो कंपोज़ के लिए इसे कॉन्फ़िगर करने का तरीका प्रदान करना संभव होगा, और विलंबित स्टार्ट अप के लिए इसका उपयोग करना होगा।

फ़ाइल के अस्तित्व की जाँच करने के लिए फाइल सिस्टम का उपयोग कैसे करें?

ready_on: /tmp/this_container_is_up_and_ready

इस तरह से यह तय करने के लिए कंटेनर डेवलपर पर निर्भर है कि चीजें यूपी की हैं, लेकिन जब तक कंटेनर खुद को तैयार घोषित नहीं करता तब तक इंतजार कर सकते हैं। यह एक स्पष्ट सम्मेलन है, लेकिन उन छवियों के लिए एक अतिरिक्त परत के रूप में आसानी से जोड़ा जा सकता है जिनमें ऐसा व्यवहार नहीं है।

स्वास्थ्य जांच के लिए अंतर्निहित समर्थन अच्छा होगा; इस बीच यहाँ हैक मुझे अपने स्थानीय डॉकटर-कम्पोज़ सेटअप में काम करने को मिला:

    nginx:
        image: nginx:latest
        command: /bin/bash -c "sleep 2 && echo starting && nginx -g 'daemon off;'"
        ...

(उत्पादन में, मेरा ऐप स्थानीय देव और परीक्षण में proxy_pass का उपयोग करते हुए कुछ पहले से चल रहे अपस्ट्रीम सर्वरों को सम्‍मिलित करता है, मैं इनमें से डॉक करने के उदाहरण शुरू करता हूं, और nginx को इनके शुरू होने के लिए थोड़ा इंतजार करने की जरूरत है, अन्‍यथा यह क्रैश और मर जाता है। daemon off चीज एक ही प्रक्रिया में nginx रखती है, अन्यथा डॉकटर जैसे ही कंटेनर को रोक देगा, जब तक कि पेरेंट प्रक्रिया उसके डेमॉन बच्चे को जन्म नहीं देती। "

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

हमारे जेनकिन्स CI सर्वर ने डॉकटर कम्पोज़ के साथ प्रोजेक्ट कंटेनरों को फैलाया और फिर मुख्य कंटेनर के भीतर से ANT को चलाता है, जैसे:

docker-compose up -d
docker exec -it projectx-fpm-jenkins ant -f /var/www/projectX/build.xml

यह docker-compose.yml फ़ाइल से कॉन्फ़िगरेशन का प्रासंगिक टुकड़ा है। ध्यान दें, जैसा कि ऊपर चर्चा की गई है, fpm पर निर्भर करना mysql पर निर्भर करता है, यह गारंटी देने के लिए पर्याप्त नहीं है कि MySQL सेवा तब तैयार होगी जब वास्तव में इसकी आवश्यकता होगी।

version: '2'
services:
  nginx:
    build: ./docker/nginx
    depends_on:
      - fpm
  fpm:
    build: ./docker/fpm
    depends_on:
      - mysql
  mysql:
    image: mysql:5.7
    environment:
      - MYSQL_ROOT_PASSWORD=projectx
      - MYSQL_DATABASE=projectx

लेकिन आप ANT टास्क के दौरान इसका इंतजार कर सकते हैं:

<!-- other targets... -->

<target name="setup db">
    <!-- wait until the 3306 TCP port in the "mysql" host is open -->
    <waitfor>
        <socket server="mysql" port="3306"/>
    </waitfor>

    <exec executable="php">
        <arg value="${consoledir}/console"/>
        <arg value="doctrine:database:create"/>
        <arg value="--no-interaction"/>
    </exec>
</target>

@kulbida ने जो चाल

while ! nc -w 1 -z db 5432; do sleep 0.1; done

_depends_on_ समस्या को हल कर सकता है।
डॉकटर-कंपोजिंग डॉक्यूमेंटेशन से।
सेवाओं के बीच एक्सप्रेस निर्भरता, जिसके दो प्रभाव हैं:

1. docker-compose निर्भरता क्रम में सेवाएं शुरू करेगा। निम्नलिखित उदाहरण में, db और redis वेब से पहले शुरू किया जाएगा।
2. डॉक-कंपोज़ अप सेवा में स्वचालित रूप से सेवा की निर्भरता शामिल होगी। निम्नलिखित उदाहरण में, डॉक-कम्पोज़ अप वेब भी डीबी और रेडिस बनाएगा और शुरू करेगा।

संस्करण 2'
सेवाएं:
वेब:
बिल्ड:।
निर्भर करता है:
- डी.बी.
- रेडिस
Redis:
छवि: रेडिस
db:
छवि: पोस्टग्रेट्स

@alexch : ग्राहक की ओर से प्रदर्शन परीक्षण (माइक्रो-सर्विस nginx + के माध्यम से रूट किया गया)। Dockerized nginx परीक्षण - बहुत उच्च से लोड के करीब शून्य कम करने के लिए प्रत्येक 1-2 मिनट दोहरा रहा था। अंत में वीएम के रूप में चल रहे गैर-डॉक्यूमेंटेड नग्नेक्स के साथ जाने का फैसला किया (सिर्फ विशाल प्रदर्शन अंतर के कारण), शायद एक नेटवर्क ड्राइवर प्लगइन / libNetwork समस्या।

@syamsathyan depends_on मदद के लिए प्रकट नहीं होता है।

@skorokithakis , @kulbida यह एक अच्छा समाधान है। दुर्भाग्यवश, किसी भी सेवा में netcat डिफ़ॉल्ट रूप से उपलब्ध नहीं है, जिसे मुझे अपने डेटाबेस से कनेक्ट करने की आवश्यकता है ( postgres )। क्या आप किसी वैकल्पिक विधि के बारे में जानते हैं?

@nottrobin मुझे डर नहीं है, मैंने इसे अपनी छवि में स्थापित किया है: /

@nottrobin मेरी टीम इस पर काम कर रही है, आपको एक-दो दिन में

हाल के बैश रखने वालों के लिए, एक नेटकैट-मुक्त समाधान है (इससे प्रेरित: http://stackoverflow.com/a/19866239/1581069):

while ! timeout 1 bash -c 'cat < /dev/null > /dev/tcp/db/5432'; do sleep 0.1; done

या कम वर्बोज़ संस्करण:

while ! timeout 1 bash -c 'cat < /dev/null > /dev/tcp/db/5432' >/dev/null 2>/dev/null; do sleep 0.1; done

@typekpb जो पूरी तरह से काम करता है। धन्यवाद!

अब उस HEALTHCHECK समर्थन को https://github.com/docker/docker/pull/23218 के अनुसार अपस्ट्रीम में मिला दिया गया है - यह तब निर्धारित किया जा सकता है जब ऑर्डर शुरू करने से पहले एक कंटेनर स्वस्थ हो। पहेली का आधा हल :)

अब जब HEALTHCHECK समर्थन को docker / docker # 23218 के अनुसार अपस्ट्रीम में मिला दिया गया है - यह निर्धारित करने के लिए माना जा सकता है कि ऑर्डर शुरू करने से पहले एक कंटेनर स्वस्थ है या नहीं। पहेली का आधा हल :)

अछा लगता है। docker-compose.yml पर इसे कैसे लागू किया जाए?

अछा लगता है। इसे docker-compose.yml पर कैसे लागू करें?

पहेली के दूसरे टुकड़े में स्वस्थ कंटेनरों के लिए डॉक-कम्पोज़ घड़ी होगी, और इस मुद्दे में आगे बताए गए depend_on सिंटैक्स की तरह कुछ का उपयोग करें। चीजों को काम करने के लिए पैच-टू-डू-कंपोज़ की आवश्यकता होगी।

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

मैंने एक js लाइब्रेरी लिखी है जिसमें .waitForPort() तरीका है। जैसा पहले उल्लेख किया गया था, यह सभी स्थितियों के लिए काम नहीं कर सकता है, लेकिन अधिकांश उपयोग-मामलों के लिए ठीक कर सकता है।
मेरा ब्लॉग देखें

HEALTHCHECK मर्ज बड़ी खबर है।

इस बीच, यह दस्तावेज़ समस्या और कुछ समाधानों का वर्णन करता है।

यही क्या कम है?

https://docs.docker.com/compose/startup-order/

@pablofmorales नहींं, क्योंकि depends_on सिर्फ जाँच करता है कि कंटेनर ऊपर है।

कुछ डेमॉन को खुद को बूटस्ट्रैप करने के लिए कुछ अतिरिक्त समय की आवश्यकता होती है और अपने असाइन किए गए पोर्ट और पते को सुनना शुरू करते हैं, सबसे विशेष रूप से MySQL।

मैं अभी भी सोच रहा हूं कि "READY_ON" घोषणा अभी भी समग्र रूप से सर्वश्रेष्ठ है। यह इस बात के बारे में निर्णय लेता है कि जब कोई चीज कंटेनर के लिए तैयार है, तो छवि की परवाह किए बिना, यह ऑप्ट-इन में स्पष्ट है और डॉकटर रिमोट एपीआई में रिसोर्सपथ (कंटेनर के भीतर) कार्यक्षमता न्यूनतम आवश्यक परिवर्तन सुनिश्चित करती है।

जब एक कंटेनर "अप" होता है, तो इसका प्रभाव केवल उसी पर पड़ता है। READY_ON फ़ाइल मौजूद होने पर यह केवल "अप" के रूप में रिपोर्ट करेगा।

मुझे लगता है कि यह 90% व्यवहार है जिस पर हर कोई चर्चा कर रहा है। मुझे लगता है कि यहां "स्वास्थ्य जांच" को 2 अलग-अलग घटनाओं के रूप में स्वीकार किया जा रहा है, लेकिन इसे एक में समेटने की कोशिश की जा रही है। एक बुनियादी ढांचे को कताई करते समय घटनाओं की श्रृंखला के लिए "तैयार" है, दूसरा "स्वास्थ्य" है ताकि बुनियादी ढांचे को ऊपर रखा जा सके।

"रेडी" डॉकटर की मदद करने के लिए पूरी तरह से एक उपयुक्त जगह है। "स्वास्थ्य" के रूप में, यह सिस्टम के संदर्भ में बहुत विविध है, मुझे लगता है कि यह उस से निपटने के लिए कंटेनर पर निर्भर है।

Healthcheck के बेहतर विकल्प के लिए, आप कंटेनरपिलॉट जैसी चीज़ को देखना चाहते हैं, जिसमें न केवल स्वास्थ्य, बल्कि सेवा खोज और निगरानी भी शामिल है। https://github.com/joyent/containerpilot

हां, यह एक सटीक और महत्वपूर्ण अंतर है। हालांकि, कंटेनर छवियों के बिना उस फ़ाइल को कैसे लिखेंगे जो काफी अधिक जटिल हो रही है? यह मुझे लगता है कि इसे हर एक कंटेनर के लिए एक आवरण स्क्रिप्ट की आवश्यकता होगी जो इसका उपयोग करना चाहता है।

खैर, आपको किसी भी तरह से उदाहरण को इनिशियलाइज़ करने के लिए स्क्रिप्ट को किक करना होगा ... स्क्रिप्ट को करने के लिए आखिरी चीज़ जो एक फ़ाइल को छूने की आवश्यकता है। मेरे लिए, यह एक स्वास्थ्य जांच करने के लिए रिमोट मशीन पर एक निष्पादन चलाने के प्रयास से बहुत आसान लगता है। कम से कम एक टच फ़ाइल के साथ, इसे कंटेनर के संदर्भ में प्रवेश करने की आवश्यकता के बिना पूरी तरह से एपीआई के माध्यम से देखा जा सकता है।

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

मेरे मामले में, मैं काँग एपीआई गेटवे का उपयोग कर रहा हूँ

कोन्ग कंटेनर चलाने से पहले मैं सिर्फ यह जांचता हूं कि क्या कैसेंड्रा इस स्क्रिप्ट के साथ काम कर रहा है

while true; do
    CHECK=`kong-database/check`
    if [[ $CHECK =~ "system.dateof" ]]; then
        break
    fi
    sleep 1;
done

चेक फ़ाइल में यह होता है

#!/bin/bash
docker cp cassandra-checker kong-database:/root/
docker exec -i kong-database cqlsh -f /root/cassandra-checker

कैसेंड्रा-चेकर सिर्फ एक साधारण क्वेरी है

SELECT dateof(now()) FROM system.local ;

ज़रूर, लेकिन वैकल्पिक एक स्वास्थ्य परीक्षण है, जिसमें एक स्क्रिप्ट की आवश्यकता होती है जिसे आपको वैसे भी लिखना होगा, इसलिए कोई ओवरहेड अंतर नहीं है। यह एक स्पष्ट ऑप्ट-इन भी है, जिसका अर्थ है कि आप बता रहे हैं कि आप इस व्यवहार को चाहते हैं। कुछ के लिए जो एक स्क्रिप्ट नहीं चलाता है, आप हमेशा एक pid फ़ाइल या एक यूनिक्स सॉकेट के लिए एक रेडी_नॉन पथ जांच कर सकते हैं; जिसे स्क्रिप्ट की आवश्यकता नहीं होगी।

यह सच है, तुम सही हो।

फ़ाइल के अस्तित्व की जाँच करना बहुत सारे मामलों के लिए ठीक हो सकता है, लेकिन कंटेनरों को एक स्टार्टअप स्क्रिप्ट का उपयोग करने के लिए मजबूर करना जब उन्हें अन्यथा उपद्रव की आवश्यकता नहीं होगी। अन्य साधारण स्थितियों के लिए भी जाँच क्यों नहीं हो सकती है? विशेष रूप से उपयोगी तब तक इंतजार कर रहा होगा जब तक कि प्रक्रिया एक विशेष टीसीपी पोर्ट पर सुन रही हो।

यह विचार ऑप्ट-इन है, इसलिए किसी चीज़ की कोई बाध्यता नहीं है। वास्तव में आप यह कहने में स्पष्ट हो रहे हैं कि क्या उम्मीद की जानी चाहिए।

एक tcp पोर्ट सुनने में यह बताने के लिए पर्याप्त नहीं हो सकता है कि एक कंटेनर को इनिशियलाइज़ किया गया है क्योंकि सेटअप डेटा का एक गुच्छा हो सकता है जिसे चलाने की आवश्यकता है। नरक, यदि आप एक पोस्टग्रैज कंटेनर से भी जल्दी से कनेक्ट करते हैं, यहां तक ​​कि tcp पर भी, आपको यह बताते हुए एक त्रुटि मिलेगी कि db अभी तक खो नहीं गया है।

अगर मैं आपको सही तरीके से समझाता हूं, तो यह "ऑप्ट-इन है, अन्यथा आप इस सुविधा का उपयोग नहीं कर सकते हैं"। एर्गो, अगर मुझे इस सुविधा की आवश्यकता है और मेरा ऐप एक पीआईडी ​​फ़ाइल का उपयोग नहीं करता है, तो मुझे स्टार्टअप स्क्रिप्ट का उपयोग करने के लिए मजबूर किया जाता है।

MySQL (ओपी का मामला) के लिए, एक बार सुनने के बाद, यह तैयार है। वे यह सुनिश्चित करने के लिए बहुत परेशानी में पड़ जाते हैं कि शायद इस तरह के मामलों के लिए। मेरा लेना यह है कि शायद उन परिस्थितियों की एक छोटी सूची है जिन्हें इस तरह से संकलित किया जा सकता है कि आप उन स्थितियों में से किसी के खिलाफ तैयार जांच को "ऑप्ट-इन" कर सकते हैं। मुझे लगता है कि इसका कोई कारण नहीं है कि इसे केवल एक ही किया जाए।

Mysql के लिए, एक बार सुनने के बाद, यह तैयार नहीं है। सरल एक नोड मामले में यह तैयार हो जाएगा, लेकिन यदि आपके पास एक से अधिक नोड हैं, तो यह निश्चित रूप से अभी तक तैयार नहीं होगा। मैं समझता हूं कि "एक और केवल एक ही मार्ग" से आपका क्या मतलब है, लेकिन मुझे लगता है कि आधार आधार के रूप में यह बिल्कुल सही है। मैं इसे एक ऐसे स्थान के रूप में देखता हूं जहां आप जो चाहें टूलींग लागू कर सकते हैं। हेक, आपकी स्क्रिप्ट बाहरी सेवाओं के साथ भी संवाद कर सकती है और उन्हें कंटेनर को सत्यापित करने की स्थिति में है, ऐसी स्थिति में आपकी बाहरी सेवाएँ आपके कंटेनर एजेंट को फ़ाइल लिखने के लिए संकेत दे सकती हैं। लचीलापन।

यदि आप "शर्तों" की इस सूची में किसी भी चीज़ का प्रयास करते हैं, तो हमेशा एक ऐसा मामला होगा जहां यह काम नहीं करता है। हालाँकि एक फ़ाइल को छूना हमेशा काम करेगा, क्योंकि छवि को पता है कि यह कब तैयार है (ओह, मुझे अन्य मेजबानों पर इंतजार करना होगा, मुझे फ़ाइलों को डाउनलोड करने की आवश्यकता है, मुझे यह सुनिश्चित करने की आवश्यकता है कि $ external_service भी उपलब्ध है, मैं इसे पूरा करता हूं। ठीक से, लेकिन किसी कारण से मेरे पास डेटाबेस के लिए सही अनुमति नहीं है, यह छवि आसानी से क्यों है ... आदि।

इस प्रकार की स्क्रिप्ट पहले से ही सभी जगह मौजूद हैं ... नरक यह स्क्रिप्ट लिखने के लिए पहले से ही आवश्यक है क्योंकि हमारे पास इस तरह की कार्यक्षमता पहले नहीं थी। इसलिए इस तरह से स्क्रिप्ट को गिराना कम से कम है, क्योंकि इसकी संभावना है कि स्क्रिप्ट पहले से मौजूद है।

एक और संभावित मामला यह है कि आपके पास उस होस्ट के खिलाफ शेफ या अनसिएबल रन जैसा कुछ होगा और फिर फाइल लिखें।

यदि यह डॉक-साइड चेक का सवाल है, तो कुछ ऐसा है;

UPCHECK --port=7474 --interval=0.5s --response="Please log in"

रिकॉर्ड के लिए मुझे लगता है कि फ़ाइल समाधान में बहुत योग्यता है, लेकिन यह जटिलता का भी परिचय देता है।
80% समय, टीसीपी प्रतिक्रिया की पुष्टि करने से ठीक काम होगा।

अच्छा ... मुझे लगता है:

UPCHECK --file=/tmp/container_is_ready --interval=0.5s --timeout=2m

बस वही है।

मैं वास्तव में डॉकटर-कंपोज के पुन: कार्यान्वयन पर काम कर रहा हूं जो विशिष्ट स्थितियों की प्रतीक्षा करने के लिए कार्यक्षमता जोड़ता है। यह libcompose का उपयोग करता है (इसलिए मुझे docker इंटरैक्शन को फिर से बनाने की आवश्यकता नहीं है) और इसके लिए कॉन्फिग कमांड का एक गुच्छा जोड़ता है। इसे यहाँ देखें: https://github.com/dansteen/controlled-compose

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

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

• ब्लॉग पोस्ट
• dockerhub-उदाहरण

कुबेरनेट्स के पास इन -कंटेनरों की अवधारणा है, मुझे आश्चर्य है कि अगर रचना / झुंड एक समान अवधारणा से लाभान्वित होंगे।

+1

मुझे लगता है कि जिस सेवा को आप कंटेनर में उजागर कर रहे हैं, उसे यह तय करना बेहतर है कि वह तैयार है या नहीं कि वह अपनी सेवा को उजागर करने में सक्षम है या नहीं।

उदाहरण के लिए PHP अनुप्रयोग MySQL के कनेक्शन पर निर्भर हो सकता है। इसलिए PHP कंटेनर के ENTRYPOINT पर, मैंने कुछ ऐसा लिखा।

#!/bin/bash
cat << EOF > /tmp/wait_for_mysql.php
<?php
\$connected = false;
while(!\$connected) {
    try{
        \$dbh = new pdo( 
            'mysql:host=mysql:3306;dbname=db_name', 'db_user', 'db_pass',
            array(PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION)
        );
        \$connected = true;
    }
    catch(PDOException \$ex){
        error_log("Could not connect to MySQL");
        error_log(\$ex->getMessage());
        error_log("Waiting for MySQL Connection.");
        sleep(5);
    }
}
EOF
php /tmp/wait_for_mysql.php
# Rest of entry point bootstrapping

इस तरह, मैं यह सुनिश्चित करने के लिए किसी भी तर्क को जोड़ सकता हूं कि मैं जिस सेवा का खुलासा कर रहा हूं यानी php का समाधान किया गया है।

नबिन नेपाल स्क्रीब:

मुझे लगता है कि जिस सेवा को आप कंटेनर में उजागर कर रहे हैं, उसे यह तय करना बेहतर है कि वह तैयार है या नहीं कि वह अपनी सेवा को उजागर करने में सक्षम है या नहीं।

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

एक सॉफ्टवेयर शिल्प कौशल दृष्टिकोण से किसी प्रकार का होना चाहिए
"कंटेनर रेडीनेस एसपीआई", जिसे कंटेनर डेवलपर कार्यान्वित कर सकता है। पर
दूसरी तरफ "कंटेनर रेडीनेस एपीआई" होना चाहिए, जो कि
सेवाओं पर निर्भर कर सकते हैं।

उलरिच

@realulim मैं मानता हूं कि MySQL कंटेनर में किसी भी परिवर्तन को सभी प्रभावित या लिंक किए गए कंटेनरों में दोहराया या प्रचारित किया जाना है।

हालाँकि, यदि परिवर्तन DB_HOST, DB_NAME, DB_USER और DB_PASSWORD जैसे मापदंडों के बारे में है। इन्हें ARG (तर्क) के रूप में पारित किया जा सकता है और सभी संबंधित कंटेनर द्वारा साझा किया जा सकता है। यदि आप docker-compose.yml फ़ाइल का उपयोग कर रहे हैं, तो परिवर्तन एक फ़ाइल पर होता है।

और इस बात से पूरी तरह सहमत हैं कि कंटेनर की तत्परता की जांच करने के लिए एक एपीआई होने के कारण इसे हल करने का वास्तविक तरीका है, लेकिन मुझे अभी भी विश्वास है कि इस सेवा को उजागर करने वाला एक बेहतर उम्मीदवार होगा।

एक वर्कअराउंड until nc -z localhost 27017; do echo Waiting for MongoDB; sleep 1; done

@ piotr-s-brainhub ऊपर की टिप्पणियों से यह उल्लेख मिलता है कि एक खुले बंदरगाह होने का मतलब यह नहीं है कि सेवा तैयार है।

क्या हमारे पास तत्परता की वैकल्पिक स्थिति हो सकती है जो लॉग, पोर्ट खोलने या समय की देरी से शुरू हो सकती है? कुछ इस तरह:

ready_when:
  in_logs: `MySQL init process done`
  ports_open:
  - 3306

मैंने अभी महसूस किया है कि निर्भरता वाले कंटेनरों के तैयार होने की प्रतीक्षा में आसानी से उपकरण जैसे उपकरण लगाए जा सकते हैं। क्या किसी ने उस दृष्टिकोण का उपयोग किया? क्या आप आसानी से डॉक-कंपोज़ को एंसिबल / शेफ / कठपुतली से बदल सकते हैं? गितुब पर कोई भी परियोजना इस दृष्टिकोण का प्रदर्शन कर रही है?

नोट: मैं एक मजबूत सेवा लिखने के महत्व को समझता हूं जो उस समय भी चल सकती है जब इसकी निर्भरताएं अनुपलब्ध हैं। यह सवाल नहीं है।

मैंने इसे आजकल एक टूल के साथ हल किया है जो मैंने लिखा था: https://github.com/betalo-sweden/await

यह तब तक प्रतीक्षा कर सकता है जब तक कि संसाधनों की दी गई सूची उपलब्ध नहीं है, और जो आप जारी रखना चाहते हैं उसके साथ जारी रखें, या तो अगले आदेश पर जाकर या स्पष्ट रूप से कॉल करके।

@djui , किसी दिए गए संसाधन की प्रतीक्षा करते समय क्या करता है?

@derekmahar यह मतदान करता है। इसमें 60 सेकंड का डिफ़ॉल्ट टाइमआउट है। हर बार यह संसाधन नहीं देख सकता, यह सिर्फ 1s अंतराल में पुन: प्रयास करेगा। वर्तमान में यह समवर्ती संसाधन का पता नहीं लगाता है, इसलिए यह अनुक्रमिक है, लेकिन यह काफी अच्छा है और इसे ठीक किया जा सकता है।

मैं निम्नलिखित परिदृश्य में इसका उपयोग करता हूं:

मैं एक डॉक-कम्पोजर संरचना को स्पिन करता हूं और फिर एक एकीकरण परीक्षण चालक चलाता हूं। ड्राइवर सेवा की शुरुआत अवसंरचना का उपयोग करते हुए बुनियादी ढांचे के सभी घटकों के उपलब्ध होने के बाद ही होती है; इसलिए प्रतीक्षारत ड्राइवर के रन कमांड को कॉल करता है

यहाँ एक नया तरीका है डॉकर हेल्थ डायरेक् ट के साथ ऐसा करने का तरीका:

https://gist.github.com/mixja/1ed1314525ba4a04807303dad229f2e1

[अद्यतन: कंटेनर एक त्रुटि कोड के साथ बाहर निकलता है, तो इससे निपटने के लिए अपडेट किया जाता है, क्योंकि डॉकर १.१२ कुछ हद तक मूर्खतापूर्ण तरीके से रोका कंटेनर पर स्वास्थ्य परीक्षण की स्थिति की रिपोर्ट करता है "]

धन्यवाद @ मिक्सजा , अच्छा समाधान।

@ मिक्सजा , अच्छा समाधान! ठीक यही कार्यक्षमता मुझे बॉक्स से बाहर आने की उम्मीद होगी। लेकिन अब सवाल यह है कि यदि आप अपने कंटेनरों को मैन्युअल रूप से शुरू करते हैं, तो आपको डॉकटर-कंपोज की आवश्यकता क्यों है?

परीक्षण के लिए मैं https://github.com/avast/docker-compose-gradle-plugin का उपयोग करता हूं और यह डॉकर हेल्थचेक का भी उपयोग करता है - कोई अधिक कृत्रिम ठहराव नहीं, तेजी से बनाता है।

@korya - Docker रचना वास्तव में एक ऑर्केस्ट्रेशन टूल नहीं है - यह एक पर्यावरण विनिर्देश और प्रबंधन उपकरण के अधिक है। मैं डॉकर कंपोज और डॉकर (और आवश्यकतानुसार अन्य उपकरण) पर प्रक्रियात्मक शैली ऑर्केस्ट्रेशन प्रदान करने के लिए मेक का उपयोग करता हूं। मेक, डॉकर और डॉकर कम्पोज़ का संयोजन बहुत शक्तिशाली है और आप इन बिल्डिंग ब्लॉक्स के साथ बहुत से विभिन्न परिदृश्यों को प्राप्त कर सकते हैं।

@ मिक्सजा ठीक है, हो सकता है आप सही हों। लेकिन जितने लोगों ने इस सूत्र में बताया है, एक ऑर्केस्ट्रेशन कार्यक्षमता की आवश्यकता परीक्षण वातावरण में होती है, और जब आपके टूलबॉक्स में डॉकटर-कंपोज होता है, तो डॉकटर-कंपोज से इस तरह की कार्यक्षमता की आवश्यकता होती है।

दरअसल, डॉक्स के अनुसार "कंपोज़ मल्टी-कंटेनर डॉकटर एप्लिकेशन को परिभाषित करने और चलाने के लिए एक उपकरण है"। यद्यपि यह नहीं कहता है कि रचना एक ऑर्केस्ट्रेशन उपकरण है, मुझे लगता है कि उपयोगकर्ता के दृष्टिकोण से (उदाहरण के लिए) यह प्रबंधित कंटेनरों के बीच बुनियादी निर्भरता प्रबंधन का समर्थन करने के लिए "मल्टी-कंटेनर डॉकर एप्लिकेशन को परिभाषित करने और चलाने के लिए एक उपकरण" से उम्मीद करना स्वाभाविक है। अलग सोच।

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

@mixja @korya मैं अपने उपकरण को बेहतर बनाने के लिए करना चाहते इंतजार और प्रतिक्रिया के लिए पूछने के लिए आप Makefile संस्करणों क्या प्रावधान है कि लापता है / और अधिक सुविधाजनक / अधिक सक्रिय करने के लिए चाहते हैं await ।

ऐसा लगता है कि Healthcheck + मेक वर्जन एक "वैश्विक" दृश्य प्रतीत होता है, कोई भी कंटेनर वैश्विक स्थिति को नहीं जानता (लेकिन मेकाइल करता है) और await एक "स्थानीय" दृश्य है, प्रत्येक सक्षम कंटेनर जानता है (केवल) इसे depends_on या links समान जानना आवश्यक है। इसके अलावा आप कंटेनर को हेल्थचेक के लिए आवश्यक उपकरण के साथ शिप करना पसंद करते हैं (जो कभी-कभी डिफ़ॉल्ट होता है, जैसे। mysqlshow ) और अन्यथा डॉकरफाइल को अछूता छोड़ दें। इसके अतिरिक्त, आप मुख्य रूप से रचना के लिए नहीं, बल्कि मुख्य रूप से लचीले कॉन्फ़िगरेशन के लिए डॉकटर-कंपोज़ का उपयोग करते प्रतीत होते हैं (जैसे docker-compose up -d mysql docker run -d -e ... -v ... -p ... mysql बराबर होना चाहिए)।

हाय @djui - यह शायद एक दार्शनिक दृष्टिकोण है, लेकिन मुझे लगता है कि HEALTHCHECK का पूरा आधार सही व्यवहार को बढ़ावा दे रहा है - यानी एक कंटेनर कंटेनर स्वास्थ्य की स्थापना का एक साधन प्रदान कर सकता है, बिना किसी बाहरी निर्भरता के।

यह किसी भी तरह से बाहरी सत्यापन कनेक्टिविटी होने के मूल्य से अलग नहीं होता है, हालांकि मैं आमतौर पर इसे कवर करने के लिए स्वीकृति परीक्षणों का एक सूट चलाऊंगा क्योंकि आप कनेक्टिविटी और पूरी बहुत अधिक (यानी अनुप्रयोग कार्यक्षमता) सत्यापित करना चाहते हैं। बेशक आप आम तौर पर परीक्षण के इस स्तर तक नहीं चला सकते हैं जब तक कि एक पूरा वातावरण स्थापित नहीं किया गया है और आपके await टूल और अन्य दृष्टिकोणों का दायरा जो मैंने अतीत में उपयोग किया है (Ansible playbooks एक agent में लपेटा गया है)

डॉकर १.१२ के साथ अब हमारे पास डॉक पर्यावरण और अच्छी तरह से स्थापित निर्माणों (यानी बाश / शेल तंत्र) का उपयोग करने की क्षमता है, जो एक निश्चित अवस्था को "प्रतीक्षा" करने के लिए है, जब तक कि हमारे कंटेनर स्वयं की स्वास्थ्य जांच नहीं करते हैं। । मुझे मंच की मूल क्षमताओं का लाभ उठाने और कंटेनर मालिकों को अपने स्वयं के स्वास्थ्य की जांच करने के लिए प्रोत्साहित करने के बजाय ऐतिहासिक बाहरी पर भरोसा करने के लिए (मैंने अपनी आवेदन प्रक्रिया शुरू कर दी है, यह अब मेरी समस्या नहीं है) दृष्टिकोण हमारे पास है। का सहारा।

संबंधित सादृश्य के रूप में AWS CloudFormation और ऑटोस्कोलिंग समूहों की अवधारणा और रोलिंग अपडेट को ऑर्केस्ट्रेट करने पर विचार करें। क्लाउडफार्म कैसे जानता है कि क्या एक नया उदाहरण "स्वस्थ" जाने के लिए तैयार है और हम एक पुराने उदाहरण को मार सकते हैं और किसी अन्य नए उदाहरण में रोल कर सकते हैं? क्या हम एक बाहरी स्वास्थ्य जांच लिखते हैं या क्या हम स्वास्थ्य पर संकेत देने के लिए उदाहरण पर निर्भर हैं? उत्तरार्द्ध उत्तरार्द्ध है, इसका मतलब है कि उदाहरण स्वामी अपने उदाहरण के लिए जो भी सफलता मानदंड निर्धारित कर सकता है, उसे सेट कर सकता है, और फिर ओवरचिंग ऑर्केस्ट्रेशन सिस्टम (यानी क्लाउडफ़ॉर्मेशन) को संकेत देता है कि उदाहरण "स्वस्थ" है।

डॉकर कम्पोज़ के बारे में आपकी टिप्पणियों के संबंध में - यह एक ऐसा उपकरण है जो आपके द्वारा उल्लिखित दोनों पहलुओं को प्रदान कर सकता है। docker-compose.yml हिस्सा वांछित राज्य संरचना पर्यावरण विनिर्देश है, जबकि विभिन्न docker-compose आदेश कई तरीकों से पर्यावरण के साथ बातचीत करने की क्षमता प्रदान करते हैं। अभी के लिए हमें बाहरी ऑर्केस्ट्रेशन टूल की आवश्यकता है क्योंकि मूल रूप से docker-compose सेवाओं के बीच निर्भरता प्रबंधन पर्याप्त रूप से नहीं करता है। जैसा कि docker-compose को मूल स्वास्थ्य जांच समर्थन जैसी सुविधाएँ मिलती हैं, एक एकल docker-compose up कमांड का लक्ष्य अधिक यथार्थवादी होगा, यह मानते हुए कि हम उदाहरण के लिए निर्दिष्ट करने में सक्षम होंगे एक सेवा को स्वस्थ से पहले चिह्नित किया जाना चाहिए। इसे "अप" माना जाता है, जिसका अर्थ है कि हमारी निर्भर सेवाएं तब तक प्रभावी रूप से प्रतीक्षा करती हैं जब तक कि निर्भरता स्वस्थ न हो।

@ मिक्सजा विस्तृत विवरण के लिए धन्यवाद। मुझे लगता है

मुझे मंच की मूल क्षमताओं का लाभ उठाने में अधिक मूल्य दिखाई देता है

एक अच्छा / मुख्य बिंदु है। बस Docker Compose के लिए प्रतीक्षा में Healthchecks का मूल रूप से या तो depend_on में या एक नई कुंजी का इंतजार कर रहा है। बस आश्चर्य होगा कि क्या इससे आगे भी एक कदम आगे बढ़ना चाहिए या नहीं और मूल रूप से लिंक किए गए कंटेनरों को नीचे लाया जाएगा यदि उदा --abort-on-container-exit सेट किया गया है और रनटाइम के दौरान एक स्वास्थ्य जांच स्वास्थ्यवर्धक लेबल _unhealthy_ पर सेट करती है।

आप में से उन लोगों के लिए संभव अस्थायी वर्कअराउंड जो परीक्षण चलाने के लिए delay फ़ंक्शन के लिए देख रहे हैं:

मेरे पास दो docker-compose yml फाइलें हैं। एक परीक्षण के लिए और दूसरा विकास के लिए है। अंतर सिर्फ sut कंटेनर में docker-compose.test.yml । sut कंटेनर pytest चलता है। मेरा लक्ष्य docker-compose टेस्ट चलाना था और यदि pytest कमांड sut कंटेनर में विफल रहता है, तो विकास docker-compose न चलाएँ। यहां वह है जो मैंने जुटाया:

# launch test docker-compose; note: I'm starting it with -p argument
docker-compose -f docker-compose.test.yml -p ci up --build -d
# simply get ID of sut container
tests_container_id=$(docker-compose -f docker-compose.test.yml -p ci ps -q sut)
# wait for sut container to finish (pytest will return 0 if all tests passed)
docker wait $tests_container_id
# get exit code of sut container
tests_status=$(docker-compose -f docker-compose.test.yml -p ci ps -q sut | xargs docker inspect -f '{{ .State.ExitCode  }}' | grep -v 0 | wc -l | tr -d ' ')
# print logs if tests didn't pass and return exit code
if [ $tests_status = "1" ] ; then
    docker-compose -f docker-compose.test.yml -p ci logs sut
    return 1
else
    return 0
fi

अब आप अपनी पसंद के किसी भी फंक्शन में ऊपर दिए गए कोड का उपयोग कर सकते हैं (खान को test कहा जाता है) और ऐसे करें:

test
test_result=$?
if [[ $test_result -eq 0 ]] ; then
    docker-compose -f docker-compose.yml up --build -d
fi

मेरे लिए अच्छी तरह से काम करता है, लेकिन मैं अभी भी docker-compose समर्थन को मूल रूप से देखने के लिए आगे देख रहा हूं :)

+1

शायद प्लगइन्स-रचना के मूल के बाहर मानी जाने वाली चीजों को प्लगइन्स की अनुमति के माध्यम से समर्थित किया जा सकता है? # 1341 अनुरोध के समान ही ऐसा लगता है कि अतिरिक्त कार्यक्षमता है जो कुछ उपयोगी होगी लेकिन जरूरी नहीं कि वर्तमान दृष्टि के साथ पूरी तरह से संरेखित हो। शायद एक प्लगइन सिस्टम का समर्थन करना, जैसे # 3905 द्वारा प्रस्तावित क्षमताओं का एक मुख्य सेट पर ध्यान केंद्रित करने की अनुमति देने का एक तरीका प्रदान करेगा और अगर यह एक नहीं है, तो जो लोग इसे अपने विशेष उपयोग के मामले में चाहते हैं वे up प्रदर्शन को संभालने के लिए एक प्लगइन लिख सकते हैं।

यह अच्छा होगा कि हम सभी परियोजनाओं में प्रवेश करने वाले के रूप में docker-compose कार्य कर सकें, हमारे पास स्थानीय रूप से docker env सेटअप है, बजाय सभी के सामने बैठे स्क्रिप्ट जोड़ने के लिए डिफ़ॉल्ट प्रविष्टि बिंदु के रूप में कार्य करने की आवश्यकता है लोगों को विषम मामलों के लिए स्क्रिप्ट चलाने के लिए याद रखने की आवश्यकता है।

यहाँ healthcheck और docker-compose 2.1+ साथ इसे करने का एक तरीका है:

version: "2.1"
services:
  db:
    image: mysql:5.7
    environment:
      MYSQL_ROOT_PASSWORD: password
    healthcheck:
      test: mysqladmin -uroot -ppassword ping
      interval: 2s
      timeout: 5s
      retries: 30
  web:
    image: nginx:latest # your image
    depends_on:
      db:
        condition: service_healthy

यहाँ docker-compose up db कंटेनर स्वस्थ होने के बाद ही वेब कंटेनर को शुरू करेगा।

क्षमा करें यदि यह पहले ही उल्लेख किया गया था, लेकिन मुझे नहीं लगता कि एक पूर्ण समाधान पोस्ट किया गया था।

यहाँ PostgreSQL के लिए एक तरीका है।

धन्यवाद @ सिलेक्स 👍

version: '2.1'
services:
  db:
    image: postgres:9.6.1
    healthcheck:
      test: "pg_isready -h localhost -p 5432 -q -U postgres"
      interval: 3s
      timeout: 5s
      retries: 5

@Silex संस्करण "3" और इस प्रारूप के साथ दुख की बात है:

    image: nginx:latest # your image
    depends_on:
      db:
        condition: service_healthy

मुझे ERROR: The Compose file './docker-compose.yml' is invalid because: depends_on contains an invalid type, it should be an array

2.1 इसे जारी रखने के लिए जारी है और इसे पदावनत नहीं किया जाएगा। 3.x मुख्य रूप से झुंड सेवा मोड (गैर स्थानीय) के लिए है।

  From: Vlad Filippov <[email protected]>

To: docker / रचना
Cc: mbdas [email protected] ; उल्लेख @@oreply.github.com पर करें
प्रेषित: बुधवार, 8 मार्च, 2017 11:45 पूर्वाह्न
विषय: Re: [docker / compose] क्या कंटेनर स्टार्टअप को विलंबित करने में लंबा स्टार्टअप समय (# ३ time४) के साथ निर्भर सेवाओं का समर्थन करने का एक तरीका है

@Silex "3" संस्करण के साथ दुख की बात है और यह प्रारूप: छवि: nginx: नवीनतम # आपकी छवि
निर्भर करता है:
db:
शर्त: service_healthy
मुझे ERROR: The Compose फ़ाइल './docker-compose.yml' अमान्य है क्योंकि: services.auth.depends_on में एक अमान्य प्रकार है, यह एक सरणी होना चाहिए-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का उत्तर सीधे दें, इसे GitHub पर देखें, या थ्रेड को म्यूट करें।

2.1 इसे जारी रखने के लिए जारी है और इसे पदावनत नहीं किया जाएगा। 3.x मुख्य रूप से झुंड सेवा मोड (गैर स्थानीय) के लिए है।

धन्यवाद!

@vladikoff : संस्करण 3 के बारे में अधिक जानकारी https://github.com/docker/compose/issues/4305 पर

मूल रूप से, इसका समर्थन नहीं किया जाएगा, आपको अपने कंटेनर को डॉकटर-कम्पोज़ पर भरोसा करने के बजाय दोष-सहिष्णु बनाना होगा।

मेरा मानना ​​है कि अब इसे बंद किया जा सकता है।

Unfortunatelly, हालत v3 में अब समर्थित नहीं है। यहाँ वर्कअराउंड है, जो मैंने पाया है:

website:
    depends_on:
      - 'postgres'
    build: .
    ports:
      - '3000'
    volumes:
      - '.:/news_app'
      - 'bundle_data:/bundle'
    entrypoint: ./wait-for-postgres.sh postgres 5432

  postgres:
    image: 'postgres:9.6.2'
    ports:
      - '5432'

wait-for-postgres.sh:

#!/bin/sh

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

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

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

# run the command
exec $cmd

@ स्लाव-निकुलिन कस्टम एंट्रीपॉइंट एक आम बात है, यह लगभग एकमात्र (डॉकटर देशी) तरीका है कि आप अपने ऐप को कंटेनर में रखने से पहले सभी शर्तों को कैसे परिभाषित और जांच सकते हैं।

सच्चाई बहुत बहस में थी और मुझे लगता है कि सशर्त समर्थन के लिए 2.x समर्थन मूल रूप से स्वास्थ्य जांच के साथ एकीकृत करने और स्टार्टअप को एक बहुत जरूरी समर्थन देने का आदेश था। डॉकटर स्थानीय रूप से कंटेनरों के स्थानीय फली का समर्थन नहीं करता है और जब ऐसा होता है तो उसे फिर से उसी तरह का समर्थन करना होगा जैसे कुबेरनेट्स उदाहरण के लिए शब्दार्थ प्रदान करता है।

Docker 3.x कंपोज़ में झुंड समर्थन लाने के लिए एक श्रृंखला है और इसलिए वितरित प्रकृति को ध्यान में रखते हुए विकल्पों का गुच्छा गिरा दिया गया है।

2.x श्रृंखला मूल रचना / स्थानीय टोपोलॉजी सुविधाओं को संरक्षित करती है।

डॉकर को यह पता लगाना है कि इन 2 संस्करणों को कैसे मर्ज किया जाए क्योंकि कंपोज़ की सुविधा सेट को कम करके कंपोज़ पर ज़ोर देना एक स्वागत योग्य दिशा नहीं है।

10 मई, 2017 को सुबह 8:15 बजे, स्लाव निकुलिन नोटिफिकेशन @github.com ने लिखा:

Unfortunatelly, हालत v3 में अब समर्थित नहीं है। यहाँ वर्कअराउंड है, जो मैंने पाया है:

वेबसाइट:
निर्भर करता है:
- 'पोस्टग्रेज'
बिल्ड:।
बंदरगाहों:
- '3000'
मात्रा:
- ':: / news_app'
- 'बंडल_धाता: / बंडल'
प्रविष्टि बिंदु: ./wait-for-postgres.sh पर पोस्ट किया गया 5432

postgres:
चित्र: ' पोस्टग्रेज: 9.6.2 '
बंदरगाहों:
- '5432'
wait-for-postgres.sh:

! / Bin / श

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

इंतजार कर रहे पोस्टगर्ल चल रहे हैं

जबकि ! pg_isready -h $ postgres_host -p $ postgres_port -q -U postgres; कर

& 2 प्रतिध्वनि "पोस्टग्रेज उपलब्ध नहीं है - सो रहा है"
सो जाओ १
किया हुआ

& 2 प्रतिध्वनि "पोस्टग्रेज है - कमांडिंग एग्जीक्यूटिव"

कमांड चलाएं

$ cmd निष्पादित करें
-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का उत्तर सीधे दें, इसे GitHub पर देखें, या थ्रेड को म्यूट करें।

मैं ऐसा कुछ करने में सक्षम था
// स्टार्ट.श

#!/bin/sh
set -eu

docker volume create --name=gql-sync
echo "Building docker containers"
docker-compose build
echo "Running tests inside docker container"
docker-compose up -d pubsub
docker-compose up -d mongo
docker-compose up -d botms
docker-compose up -d events
docker-compose up -d identity
docker-compose up -d importer
docker-compose run status
docker-compose run testing

exit $?

// स्थिति। श

#!/bin/sh

set -eu pipefail

echo "Attempting to connect to bots"
until $(nc -zv botms 3000); do
    printf '.'
    sleep 5
done
echo "Attempting to connect to events"
until $(nc -zv events 3000); do
    printf '.'
    sleep 5
done
echo "Attempting to connect to identity"
until $(nc -zv identity 3000); do
    printf '.'
    sleep 5
done
echo "Attempting to connect to importer"
until $(nc -zv importer 8080); do
    printf '.'
    sleep 5
done
echo "Was able to connect to all"

exit 0

// मेरे डॉकटर में फ़ाइल लिखें

  status:
    image: yikaus/alpine-bash
    volumes:
      - "./internals/scripts:/scripts"
    command: "sh /scripts/status.sh"
    depends_on:
      - "mongo"
      - "importer"
      - "events"
      - "identity"
      - "botms"

मैं एक समान समस्या है, लेकिन थोड़ा अलग है। मैं एक प्रतिकृति सेट शुरू करने और शुरू करने के लिए MongoDB का इंतजार करना होगा।
मैं docker में सभी प्रक्रिया कर रहा हूँ। यानी बनाने और प्रमाणीकरण प्रतिकृति सेट। लेकिन मेरे पास एक और अजगर स्क्रिप्ट है जिसमें मुझे प्रतिकृति सेट के प्राथमिक नोड से कनेक्ट करना है। मुझे वहाँ एक त्रुटि मिल रही है।

डोकर-compose.txt
Dockerfile.txt
और अजगर स्क्रिप्ट में इस तरह से कुछ करने की कोशिश कर रहा im
for x in range(1, 4): client = MongoClient(host='node' + str(x), port=27017, username='admin', password='password') if client.is_primary: print('the client.address is: ' + str(client.address)) print(dbName) print(collectionName) break

ऐसा करने में कठिनाई हो रही है, किसी को भी कोई विचार है?

@patrickml अगर मैं डॉकटर कंपोज़ का उपयोग नहीं करता, तो मैं इसे डॉकफाइल के साथ कैसे करूँ?
मुझे अपने build_all.cql को निष्पादित करने के लिए 'cqlsh' की आवश्यकता है। हालांकि, 'cllsh' तैयार नहीं है ... तैयार होने के लिए 60 सेकंड तक इंतजार करना होगा।

बिल्ली डॉकरफाइल

स्टोर / डाटास्टैक्स / डीएसई सर्वर से: 5.1.8

USER रूट

RUN एप-गेट अपडेट
RUN apt-get install -y vim

ADD db-script-2.1.33.2-RFT-01.tar / docker / cms /
COPY entrypoint.sh /entrypoint.sh

वर्कडाइडर / डॉकटर / सेमी / डीबी- स्क्रिप्ट्स-2.1.33.2/
RUN cqlsh -f build_all.cql

USER dse

=============

चरण 8/9: RUN cqlsh -f build_all.cql
--- --- 08c8a854ebf4 में चल रहा है
कनेक्शन त्रुटि: ('किसी भी सर्वर से कनेक्ट करने में असमर्थ', {'127.0.0.1': त्रुटि (111, "कनेक्ट करने की कोशिश [(127.0.0.1 ', 9042)]। अंतिम त्रुटि: कनेक्शन ने इनकार कर दिया")})
आदेश '/ bin / sh -c cqlsh -f build_all.cql' ने एक गैर-शून्य कोड लौटाया: 1

= Var-lib-libvirt.mount var-lib -irtvirt-images-ram.mount