Dockerfile में CMD और ENTRYPOINT में क्या अंतर है?

Question

Dockerfiles में दो कमांड हैं जो मेरे समान दिखते हैं: CMDऔर ENTRYPOINT। लेकिन मुझे लगता है कि उनके बीच एक (सूक्ष्म?) अंतर है - अन्यथा यह बहुत ही बात के लिए दो आज्ञाओं का कोई मतलब नहीं होगा।

प्रलेखन राज्यों के लिए CMD

एक सीएमडी का मुख्य उद्देश्य एक निष्पादित कंटेनर के लिए चूक प्रदान करना है।

और इसके लिए ENTRYPOINT:

एक प्रवेश आपको एक कंटेनर को कॉन्फ़िगर करने में मदद करता है जिसे आप एक निष्पादन योग्य के रूप में चला सकते हैं।

तो, उन दो आदेशों के बीच अंतर क्या है?

Comments

इस ब्लॉग पोस्ट में मतभेदों का अच्छा विवरण है और उन्हें एक साथ कैसे भी उपयोग किया जा सकता है: crosbymichael.com/dockerfile-best-practices.html ।

— SLM

^ यह! धन्यवाद @ एसएलएम यहां एक और ऐसा ही संदर्भ है जो थोड़ा और अधिक हो सकता है: docs.docker.com/reference/builder/#entrypoint

— एडम

के रूप में भ्रमित कर के रूप में के बीच का अंतर ADDऔरCOPY

— Raedwald

यह लिंक RUN, CMD और ENTRYPOINT के बीच अंतर प्रदान करता है: goinbigdata.com/docker-run-vs-cmd-vs-entrypoint

— prafi

बस ध्यान दें कि CMDऔर ENTRYPOINTदोनों के लिखित, निष्पादन और खोल के रूप में अलग-अलग रूप हैं। तो अपने आप को एक एहसान बनाओ और उपयोग किए जा रहे फॉर्म के आधार पर व्यवहार में सूक्ष्म अंतर को समझें। इसके बाद docs.docker.com/engine/reference/builder/… पढ़ें ।

— Jaime Hablutzel

Answer 1

डॉकर में एक डिफ़ॉल्ट एंट्रीपॉइंट होता है जो /bin/sh -cकि एक डिफ़ॉल्ट कमांड नहीं है।

जब आप इस तरह docker run -i -t ubuntu bash डॉक करते हैं: एंट्रीपॉइंट डिफ़ॉल्ट है /bin/sh -c, छवि है ubuntuऔर कमांड है bash।

एंट्रीपॉइंट के माध्यम से कमांड चलाया जाता है। यानी, निष्पादित होने वाली वास्तविक चीज है /bin/sh -c bash। इसने डॉकर को RUNशेल के पार्सर पर भरोसा करके जल्दी से लागू करने की अनुमति दी ।

बाद में, लोगों ने इसे अनुकूलित करने में सक्षम होने के लिए कहा, इसलिए ENTRYPOINTऔर --entrypointइसे पेश किया गया।

ubuntuऊपर दिए गए उदाहरण में सब कुछ कमांड है और एंट्रीपॉइंट को पास किया गया है। CMDनिर्देश का उपयोग करते समय , यह बिल्कुल ऐसा है जैसे आप कर रहे थे docker run -i -t ubuntu <cmd>। <cmd>एंट्रीपॉइंट का पैरामीटर होगा।

यदि आप इस आदेश को टाइप करते हैं तो आपको भी वही परिणाम मिलेगा docker run -i -t ubuntu। आप अभी भी कंटेनर में एक बैश शेल शुरू करेंगे क्योंकि ubuntu Dockerfile की डिफ़ॉल्ट सीएमडी निर्दिष्ट की गई है:CMD ["bash"]

जैसा कि सब कुछ एंट्रीपॉइंट को पारित किया गया है, आप अपनी छवियों से बहुत अच्छा व्यवहार कर सकते हैं। @ जिरी का उदाहरण अच्छा है, यह दिखाता है कि एक छवि को "बाइनरी" के रूप में कैसे उपयोग किया जाए। ["/bin/cat"]एंट्रीपॉइंट के रूप में उपयोग करने और फिर करने के बाद docker run img /etc/passwd, आप इसे प्राप्त करते हैं, यह /etc/passwdकमांड है और एंट्रीपॉइंट पर जाता है, इसलिए अंतिम परिणाम निष्पादन बस है /bin/cat /etc/passwd।

एक और उदाहरण होगा एंट्रीपॉइंट के रूप में कोई क्ली। उदाहरण के लिए, यदि आपके पास लाल रंग की छवि है, तो चलाने के बजाय docker run redisimg redis -H something -u toto get key, आप बस कर सकते हैं ENTRYPOINT ["redis", "-H", "something", "-u", "toto"]और फिर उसी परिणाम के लिए इस तरह से दौड़ सकते हैं docker run redisimg get key:।

Comments

हर्गिज नहीं। ENTRYPOINT एक मेटाडेटा सेट करता है (जो ओवरराइड किया जा सकता है), इसलिए यदि आप कुछ भी नहीं बदलते हैं, तो अपना कंटेनर शुरू करने के बाद, परिणाम समान होगा, हालांकि, RUN का निर्माण समय पर किया जाएगा और इससे कोई फर्क नहीं पड़ता कि आप क्या कर रहे हैं रनटाइम पर, यह यहाँ होगा।

— क्रेक

डिफ़ॉल्ट रूप से नहीं है ENTRYPOINT; क्या शेल का उपयोग किया जाता है, CMDकमांड के प्रयुक्त रूप पर निर्भर करता है ( docs.docker.com/engine/reference/builder/#cmc )।

— ब्लेसबोर्लेड

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

— ashirley

यह एक शानदार जवाब है। मुझे लगता है कि डॉकर प्रलेखन को CMDबनाम नामक एक खंड के तहत इसे जोड़ना चाहिए ENTRYPOINT।

— तारिक

@Webman No. वे दो अलग निर्देश हैं। यदि वे दोनों मौजूद हैं, तो CMD को ENTRYPOINT के मापदंडों के रूप में माना जाएगा।

— लाइट.जी

Answer 2

ENTRYPOINTनिर्दिष्ट एक आदेश है कि हमेशा जब कंटेनर शुरू होता है निष्पादित किया जाएगा।

CMDनिर्दिष्ट तर्क को खिलाया जा जाएगा ENTRYPOINT।

यदि आप किसी विशिष्ट कमांड के लिए एक छवि समर्पित करना चाहते हैं जो आप उपयोग करेंगे ENTRYPOINT ["/path/dedicated_command"]

अन्यथा, यदि आप सामान्य उद्देश्य के लिए एक छवि बनाना चाहते हैं, तो आप ENTRYPOINTअनिर्दिष्ट छोड़ सकते हैं और उपयोग कर सकते हैं CMD ["/path/dedicated_command"]क्योंकि आप तर्क की आपूर्ति करके सेटिंग को ओवरराइड कर पाएंगे docker run।

उदाहरण के लिए, यदि आपका डॉकरीफाइल है:

FROM debian:wheezy
ENTRYPOINT ["/bin/ping"]
CMD ["localhost"]

बिना किसी तर्क के छवि को चलाना लोकलहोस्ट को पिंग करेगा:

$ docker run -it test
PING localhost (127.0.0.1): 48 data bytes
56 bytes from 127.0.0.1: icmp_seq=0 ttl=64 time=0.096 ms
56 bytes from 127.0.0.1: icmp_seq=1 ttl=64 time=0.088 ms
56 bytes from 127.0.0.1: icmp_seq=2 ttl=64 time=0.088 ms
^C--- localhost ping statistics ---
3 packets transmitted, 3 packets received, 0% packet loss
round-trip min/avg/max/stddev = 0.088/0.091/0.096/0.000 ms

अब, एक तर्क के साथ छवि को चलाने से तर्क पिंग होगा:

$ docker run -it test google.com
PING google.com (173.194.45.70): 48 data bytes
56 bytes from 173.194.45.70: icmp_seq=0 ttl=55 time=32.583 ms
56 bytes from 173.194.45.70: icmp_seq=2 ttl=55 time=30.327 ms
56 bytes from 173.194.45.70: icmp_seq=4 ttl=55 time=46.379 ms
^C--- google.com ping statistics ---
5 packets transmitted, 3 packets received, 40% packet loss
round-trip min/avg/max/stddev = 30.327/36.430/46.379/7.095 ms

तुलना के लिए, यदि आपका डॉकफाइल है:

FROM debian:wheezy
CMD ["/bin/ping", "localhost"]

बिना किसी तर्क के छवि को चलाना लोकलहोस्ट को पिंग करेगा:

$ docker run -it test
PING localhost (127.0.0.1): 48 data bytes
56 bytes from 127.0.0.1: icmp_seq=0 ttl=64 time=0.076 ms
56 bytes from 127.0.0.1: icmp_seq=1 ttl=64 time=0.087 ms
56 bytes from 127.0.0.1: icmp_seq=2 ttl=64 time=0.090 ms
^C--- localhost ping statistics ---
3 packets transmitted, 3 packets received, 0% packet loss
round-trip min/avg/max/stddev = 0.076/0.084/0.090/0.000 ms

लेकिन छवि को तर्क के साथ चलाने से तर्क चलेगा:

docker run -it test bash
root@e8bb7249b843:/#

और भी अधिक विवरणों के लिए ब्रायन डे वोनर के इस लेख को देखें: https://www.ctl.io/developers/blog/post/dockerfile-entrypoint-vs-cmd/

Comments

The ENTRYPOINT specifies a command that will always be executed when the container starts. The CMD specifies arguments that will be fed to the ENTRYPOINT.एक अच्छा-से-बिंदु सारांश है।

— जिंगुगो याओ

ENTRYPOINT को भी --entrypoint ध्वज का उपयोग करके ओवरराइड किया जा सकता है। उदाहरण के लिए docker run -it --entrypoint bash test

— sawimurugan

मुझे आपके उदाहरण पसंद हैं, यह वास्तव में मददगार है!

— चौ ० ग्यांग

@ झिंगुओ याओ: क्या होगा अगर सीएमडी में एक कमांड होती है जैसे - सीएमडी ["नेगनेक्स", "- जी", "डेमन", "ऑफ"]? क्या यह जंजीर होगी?

— केएमसी

@KMC CMD ENTRYPOINT का डिफ़ॉल्ट तर्क है, आप छवि को चलाते समय एक नया arg पास करके इसे ओवरराइड करते हैं।

— एमजीपी 15

Answer 3

डॉकर डॉक्स के अनुसार ,

CMD और ENTRYPOINT निर्देश दोनों परिभाषित करते हैं कि कंटेनर चलाते समय कौन सी कमांड निष्पादित होती है। कुछ नियम हैं जो उनके सहयोग का वर्णन करते हैं।

1. Dockerfile को कम से कम CMDया किसी एक ENTRYPOINTकमांड को निर्दिष्ट करना चाहिए ।
2. ENTRYPOINT कंटेनर को एक निष्पादन योग्य के रूप में उपयोग करते समय परिभाषित किया जाना चाहिए।
3. CMDENTRYPOINTकमांड के लिए डिफॉल्ट तर्कों को परिभाषित करने या कंटेनर में एड-हॉक कमांड निष्पादित करने के तरीके के रूप में उपयोग किया जाना चाहिए ।
4. CMD वैकल्पिक तर्कों के साथ कंटेनर चलाते समय ओवरराइड किया जाएगा।

नीचे दी गई तालिकाएं बताती हैं कि विभिन्न ENTRYPOINT/ CMDसंयोजनों के लिए कौन सी कमांड निष्पादित होती है :

- No ENTRYPOINT

╔════════════════════════════╦═════════════════════════════╗
║ No CMD                     ║ error, not allowed          ║
╟────────────────────────────╫─────────────────────────────╢
║ CMD [“exec_cmd”, “p1_cmd”] ║ exec_cmd p1_cmd             ║
╟────────────────────────────╫─────────────────────────────╢
║ CMD [“p1_cmd”, “p2_cmd”]   ║ p1_cmd p2_cmd               ║
╟────────────────────────────╫─────────────────────────────╢
║ CMD exec_cmd p1_cmd        ║ /bin/sh -c exec_cmd p1_cmd  ║
╚════════════════════════════╩═════════════════════════════╝

- ENTRYPOINT exec_entry p1_entry

╔════════════════════════════╦══════════════════════════════════╗
║ No CMD                     ║ /bin/sh -c exec_entry p1_entry   ║
╟────────────────────────────╫──────────────────────────────────╢
║ CMD [“exec_cmd”, “p1_cmd”] ║ /bin/sh -c exec_entry p1_entry   ║
╟────────────────────────────╫──────────────────────────────────╢
║ CMD [“p1_cmd”, “p2_cmd”]   ║ /bin/sh -c exec_entry p1_entry   ║
╟────────────────────────────╫──────────────────────────────────╢
║ CMD exec_cmd p1_cmd        ║ /bin/sh -c exec_entry p1_entry   ║
╚════════════════════════════╩══════════════════════════════════╝

- ENTRYPOINT [“exec_entry”, “p1_entry”]

╔════════════════════════════╦═════════════════════════════════════════════════╗
║ No CMD                     ║ exec_entry p1_entry                             ║
╟────────────────────────────╫─────────────────────────────────────────────────╢
║ CMD [“exec_cmd”, “p1_cmd”] ║ exec_entry p1_entry exec_cmd p1_cmd             ║
╟────────────────────────────╫─────────────────────────────────────────────────╢
║ CMD [“p1_cmd”, “p2_cmd”]   ║ exec_entry p1_entry p1_cmd p2_cmd               ║
╟────────────────────────────╫─────────────────────────────────────────────────╢
║ CMD exec_cmd p1_cmd        ║ exec_entry p1_entry /bin/sh -c exec_cmd p1_cmd  ║
╚════════════════════════════╩═════════════════════════════════════════════════╝

Comments

Px_cmd और exec_entry क्या हैं? जब वे एक ही निष्पादन रेखा पर होते हैं, तो इसका क्या मतलब है? उन्हें एक-दूसरे के तर्क के रूप में पारित किया जाता है? यहां तक कि जब /bin/sh -cशामिल है?

— डैनियलो 515

@ डैनियलो 515 'px_cmd' और 'exec_entry' दोनों ही यहाँ डमी स्ट्रिंग्स हैं। आप बस नोटिस कर सकते हैं कि /bin/sh -cसीएमडी को उपसर्ग के रूप में जोड़ा जाएगा जबकि सीएमडी निष्पादन योग्य सिंटैक्स (सूची सिंटैक्स नहीं) में लिखा गया है।

— लाइट.जी

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

— डोनरोडैडॉन

ENTRYPOINT exec_entry p1_entगलत तरीके से समझाया गया था। शेल फॉर्म किसी भी सीएमडी या कमांड लाइन तर्क को इस्तेमाल होने से रोकता है - docs.docker.com/engine/reference/builder/#entrypoint

— Mariusz Miesiak

@MariuszMiesiak अब इसे अपडेट किया गया है। आपकी प्रतिक्रिया के लिए धन्यवाद।

— रफफ तहसीन

Answer 4

हां, यह एक अच्छा सवाल है। मैं इसे अभी तक पूरी तरह से नहीं समझता, लेकिन:

मैं समझता हूं कि ENTRYPOINTयह बाइनरी है जिसे निष्पादित किया जा रहा है। आप एंट्रीपॉइंट को --entrypoint = "" से निकाल सकते हैं।

docker run -t -i --entrypoint="/bin/bash" ubuntu

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

# no entrypoint
docker run ubuntu /bin/cat /etc/passwd

# with entry point, emulating cat command
docker run --entrypoint="/bin/cat" ubuntu /etc/passwd

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

# Dockerfile
FROM ubuntu
ENTRYPOINT ["/bin/cat"]

तथा

docker build -t=cat .

तो आप उपयोग कर सकते हैं:

docker run cat /etc/passwd
#              ^^^^^^^^^^^
#                   CMD
#          ^^^      
#          image (tag)- using the default ENTRYPOINT

Comments

@Blauhirn आपके मामले में, आपको सूची सिंटैक्स में CMD में तर्क जोड़ना होगा, और सुनिश्चित करें कि आपके द्वारा जब्त किया गया प्रविष्टि सीएमडी में आपके तर्क को पार्स कर सकता है। आमतौर पर, मैं एंट्रीपॉइंट के लिए '-h' तर्क जोड़ता हूं। तब मैं docker run image_name -hइस छवि की कुछ मदद जानकारी दिखाने के लिए निष्पादित कर सकता हूं ।

— लाइट.जी

यह सबसे सरल और स्पष्ट उत्तर है।

— एरिक वांग

Answer 5

अंतर्ज्ञान द्वारा CMD और ENTRYPOINT के बीच अंतर :

• ENTRYPOINT: कंटेनर शुरू होने पर चलाने के लिए कमांड।
• CMD: कंटेनर शुरू होने पर चलाने के लिए कमांड या निर्दिष्ट होने पर ENTRYPOINT का तर्क।

हाँ, यह मिश्रण है।

जब आप डॉक रन करते हैं तो आप उनमें से किसी को भी ओवरराइड कर सकते हैं।

उदाहरण के लिए CMD और ENTRYPOINT के बीच अंतर :

docker run -it --rm yourcontainer /bin/bash            <-- /bin/bash overrides CMD
                                                       <-- /bin/bash does not override ENTRYPOINT
docker run -it --rm --entrypoint ls yourcontainer      <-- overrides ENTRYPOINT with ls
docker run -it --rm --entrypoint ls yourcontainer  -la  <-- overrides ENTRYPOINT with ls and overrides CMD with -la

अंतर के बारे में अधिक के बीच CMDऔर ENTRYPOINT:

docker runइस तरह के / बिन / बैश का तर्क किसी भी सीएमडी कमांड को ओवरराइड करता है, जिसे हमने डॉकफेराइल में लिखा था।

ENTRYPOINT को सामान्य समय जैसे कि सामान्य समय के साथ नहीं चलाया जा सकता है docker run [args]। argsअंत में की docker run [args]ENTRYPOINT को तर्क के रूप में प्रदान की जाती हैं। इस तरह हम containerएक सामान्य बाइनरी की तरह बना सकते हैं जैसे कि ls।

तो CMD ENTRYPOINT में डिफ़ॉल्ट मापदंडों के रूप में कार्य कर सकता है और फिर हम CMD को [args] से ओवरराइड कर सकते हैं।

ENTRYPOINT के साथ ओवरराइड किया जा सकता है --entrypoint।

Answer 6

संक्षेप में:

• सीएमडी डिफॉल्ट कमांड और / या पैरामीटर सेट करता है, जिसे कमांड लाइन से ओवरराइट किया जा सकता है जब डॉक कंटेनर चलता है।
• ENTRYPOINT कमांड और मापदंडों को कमांड लाइन से अधिलेखित नहीं किया जाएगा। इसके बजाय, ENTRYPOINT मापदंडों के बाद सभी कमांड लाइन तर्क जोड़े जाएंगे।

यदि आपको अधिक विवरणों की आवश्यकता है या उदाहरण पर अंतर देखना चाहते हैं, तो एक ब्लॉग पोस्ट है जो सीएमडी और एनटीआरपीपीओएनटी की तुलना बहुत सारे उदाहरणों के साथ करता है - http://goinbigdata.com/docker-run-vs-cmd-vs-entrypoint/

Answer 7

मैं अपने उत्तर को उदाहरण ^{1 के} रूप में जोड़ूंगा जोड़ूंगा जो आपको अंतर को बेहतर ढंग से समझने में मदद कर सकता है।

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

FROM ubuntu
CMD sleep 10

अब, हम छवि बनाते हैं:

docker build -t custom_sleep .
docker run custom_sleep
# sleeps for 10 seconds and exits

क्या होगा अगर हम सेकंड की संख्या बदलना चाहते हैं? हमें Dockerfileमान बदलना होगा क्योंकि मूल्य वहां हार्डकोड किया गया है, या एक अलग प्रदान करके कमांड को ओवरराइड करता है:

docker run custom_sleep sleep 20

जबकि यह काम करता है, यह एक अच्छा समाधान नहीं है, क्योंकि हमारे पास एक अनावश्यक "नींद" कमांड है (कंटेनर का उद्देश्य सोना है , इसलिए स्पष्ट रूप से sleepकमांड को निर्दिष्ट करना एक अच्छा अभ्यास नहीं है)।

अब ENTRYPOINTअनुदेश का उपयोग करके देखें :

FROM ubuntu
ENTRYPOINT sleep

यह निर्देश उस प्रोग्राम को निर्दिष्ट करता है जो कंटेनर शुरू होने पर चलाया जाएगा ।

अब हम चला सकते हैं:

docker run custom_sleep 20

डिफ़ॉल्ट मान के बारे में क्या? ठीक है, आपने अनुमान लगाया कि यह सही है:

FROM ubuntu
ENTRYPOINT ["sleep"]
CMD ["10"]

ENTRYPOINTप्रोग्राम है जो चलाया जाएगा है, और कंटेनर को भेजे गए मान इसे करने के लिए जोड़ दिया जाएगा।

ENTRYPOINTएक निर्दिष्ट द्वारा अधिरोहित जा सकता है --entrypointझंडा, नया प्रवेश बिंदु आप उपयोग करना चाहते द्वारा पीछा किया।

^{मेरा नहीं, मैंने एक बार एक ट्यूटोरियल देखा जो इस उदाहरण को प्रदान करता है}

Comments

यहाँ ट्यूटोरियल के लिए एक लिंक है: youtu.be/OYbEWUbmk90 । यह भविष्य के उपयोगकर्ताओं के लिए उपयोगी हो सकता है।

— ChiPlusPlus

Answer 8

इतिहास को समझाने में स्वीकृत उत्तर शानदार है। मुझे लगता है कि यह तालिका आधिकारिक डॉक पर 'सीएमडी और एन्ट्रायपइंट इंटरेक्शन' से इसे बहुत अच्छी तरह समझाती है :

Answer 9

कोड में EntryPoint फ़ंक्शन पर टिप्पणियां

// ENTRYPOINT / usr / sbin / nginx।

// एंट्रीपॉइंट (जो डिफॉल्ट टू श-सी) / usr / sbin / nginx पर सेट करें।

// सीएमडी को / usr / sbin / nginx के तर्क के रूप में स्वीकार करेगा।

दस्तावेजों से एक और संदर्भ

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

उदाहरण:

FROM ubuntu:14.04.3
ENTRYPOINT ["/bin/ping"]
CMD ["localhost", "-c", "2"]

बिल्ड : sudo docker बिल्ड -t ent_cmd।

CMD arguments are easy to override.

NO argument (sudo docker -it ent_cmd)                :  ping localhost 
argument    (sudo docker run -it ent_cmd google.com) :  ping google.com

।

To override EntryPoint argument, you need to supply entrypoint
sudo docker run -it --entrypoint="/bin/bash" ent_cmdd

ps: एंट्रीपॉइंट की उपस्थिति में, सीएमडी एंट्रीपॉइंट को खिलाए जाने के लिए तर्क रखेगा। एंट्रीपॉइंट की अनुपस्थिति में, सीएमडी कमांड होगा जिसे चलाया जाएगा।

Answer 10

CMDDockerfileफ़ाइल के अंदर बताई गई कमांड को docker runकमांड के माध्यम से ओवरराइड किया जा सकता है जबकि ENTRYPOINTऐसा नहीं किया जा सकता है।

Comments

docker run --helpकमांड अन्यथा कहती है:--entrypoint string Overwrite the default ENTRYPOINT of the image

— iomv

Answer 11

मैंने सभी उत्तर पढ़ लिए हैं और मैं निम्नलिखित की तरह पहली नज़र में बेहतर समझ के लिए संक्षेप में प्रस्तुत करना चाहता हूं:

सबसे पहले, पूरे कमांड को कंटेनर में निष्पादित किया जाता है, जिसमें दो भाग शामिल होते हैं: कमांड और तर्क

• ENTRYPOINT कंटेनर को चालू करने पर कमांड के लिए निष्पादित निष्पादन योग्य को परिभाषित करता है

• सीएमडी उन तर्कों को निर्दिष्ट करता है जो एनट्रायपंट को पास हो जाते हैं (तर्कों के लिए)

में Kubernetes में कार्रवाई पुस्तक इसके बारे में एक महत्वपूर्ण नोट इंगित करता है। (अध्याय 7)

यद्यपि आप छवि को चलाने के दौरान जिस कमांड को निष्पादित करना चाहते हैं, उसे निर्दिष्ट करने के लिए आप CMD निर्देश का उपयोग कर सकते हैं , सही तरीका यह है कि आप ENTRYPOINT निर्देश के माध्यम से करें और केवल CMD को निर्दिष्ट करें यदि आप डिफ़ॉल्ट तर्कों को परिभाषित करना चाहते हैं।

आप इस लेख को सरल तरीके से महान विवरण के लिए भी पढ़ सकते हैं

Answer 12

अध्यक्ष एवं प्रबंध निदेशक:

• CMD ["executable","param1","param2"]: ["executable","param1","param2"]पहली प्रक्रिया है।
• CMD command param1 param2: /bin/sh -c CMD command param1 param2पहली प्रक्रिया है। CMD command param1 param2पहली प्रक्रिया से कांटा है।
• CMD ["param1","param2"]: इस फ़ॉर्म का उपयोग इसके लिए डिफ़ॉल्ट तर्क प्रदान करने के लिए किया जाता है ENTRYPOINT।

ENTRYPOINT (निम्नलिखित सूची उस मामले पर विचार नहीं करती है जहाँ CMD और ENTRYPOINT का एक साथ उपयोग किया जाता है):

• ENTRYPOINT ["executable", "param1", "param2"]: ["executable", "param1", "param2"]पहली प्रक्रिया है।
• ENTRYPOINT command param1 param2: /bin/sh -c command param1 param2पहली प्रक्रिया है। command param1 param2पहली प्रक्रिया से कांटा है।

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

Answer 13

अधिकांश लोग इसे पूरी तरह से यहाँ समझाते हैं, इसलिए मैं सभी उत्तरों को नहीं दोहराऊंगा। लेकिन एक अच्छी भावना पाने के लिए मैं कंटेनर में होने वाली प्रक्रियाओं को देखकर खुद इसका परीक्षण करने का सुझाव दूंगा।

फॉर्म का एक छोटा डॉकफाइल बनाएं:

FROM ubuntu:latest
CMD /bin/bash

इसे बनाएं, इसे कंटेनर में docker run -it theimageचलाएं और चलाएं ps -eo ppid,pid,args। उपयोग करते समय पीएस से प्राप्त आउटपुट की तुलना इस आउटपुट से करें:

• docker run -it theimage bash
• छवि को फिर से बनाना लेकिन ENTRYPOINT /bin/bashइसे दोनों तरीकों से चलाना और चलाना
• का उपयोग करते हुए CMD ["/bin/bash"]
• ...

इस तरह आप आसानी से अपने लिए सभी संभावित तरीकों के बीच अंतर देख पाएंगे।

Answer 14

Dockerfile सर्वोत्तम प्रथाओं का आधिकारिक प्रलेखन मतभेदों को समझाते हुए एक महान कार्य करता है। Dockerfile सर्वोत्तम प्रथाओं

अध्यक्ष एवं प्रबंध निदेशक:

सीएमडी निर्देश का उपयोग आपकी छवि में निहित सॉफ़्टवेयर को किसी भी तर्क के साथ चलाने के लिए किया जाना चाहिए। CMD का उपयोग लगभग हमेशा के रूप में किया जाना चाहिए CMD ["executable", "param1", "param2"…]। इस प्रकार, यदि छवि एक सेवा के लिए है, जैसे कि अपाचे और रेल, तो आप कुछ इस तरह से चलेंगे CMD ["apache2","-DFOREGROUND"]। वास्तव में, निर्देश का यह रूप किसी भी सेवा-आधारित छवि के लिए अनुशंसित है।

प्रवेश बिंदु:

ENTRYPOINT के लिए सबसे अच्छा उपयोग छवि के मुख्य कमांड को सेट करना है, जिससे उस छवि को चलाया जा सके क्योंकि यह उस कमांड था (और फिर डिफ़ॉल्ट झंडे के रूप में CMD का उपयोग करें)।