Docker ENTRYPOINT समझाया गया: उपयोग, वाक्य-विन्यास, और सर्वोत्तम प्रथाएँ

Docker ENTRYPOINT एक Dockerfile निर्देश है जो आपके कंटेनर के शुरू होते ही चलने वाले डिफ़ॉल्ट कमांड को परिभाषित और नियंत्रित करता है। ENTRYPOINT में महारत हासिल करने से ऐसे कंटेनर बनाना सरल हो जाता है जो पूर्वानुमेय, पुनरुत्पाद्य, और अनुरक्षित हों तथा अपेक्षित व्यवहार करें। 

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

यदि आप Docker में नए हैं, तो हमारा Docker ट्यूटोरियल देखें, क्योंकि यह ट्यूटोरियल Docker की कुछ समझ मानकर चलता है। Docker के साथ हाथ-से-हाथ काम करने के लिए हमारा Introduction to Docker कोर्स देखें। 

Docker ENTRYPOINT क्या है?

ENTRYPOINT वह कमांड परिभाषित करता है जो हर बार आपके Docker कंटेनर के लॉन्च होने पर डिफ़ॉल्ट रूप से निष्पादित होता है। CMD के विपरीत, ENTRYPOINT निर्देश यह सुनिश्चित करता है कि कंटेनर शुरू होने पर हर बार वही कमांड चले, जिससे स्थिरता बनी रहती है।

Docker ENTRYPOINT कैसे काम करता है?

Dockerfile में ENTRYPOINT उस मुख्य कमांड को परिभाषित करता है जो इमेज से कंटेनर स्टार्ट करते समय हमेशा चलता है। यह मानो कहता है: “उपयोगकर्ता रन करते समय चाहे जो भी आर्ग्युमेंट पास करे, इस कमांड से ही शुरुआत होनी चाहिए।”

हम How to Containerize an Application Using Docker ट्यूटोरियल में Dockerfiles के बारे में विस्तार से बताते हैं। 

उदाहरण के लिए, एक Dockerfile में:

ENTRYPOINT ["python", "app.py"]संचालित द्वारा

अब, जब आप चलाते हैं:

docker run myimageसंचालित द्वारा

यह हमेशा यह चलाएगा:

python app.pyसंचालित द्वारा

यहाँ ENTRYPOINT के काम करने का एक फ्लो डायग्राम है:

+---------------------------+

|       Dockerfile          |

+---------------------------+

|                           |

|  ENTRYPOINT ["app"]       |

|  CMD ["--default-arg"]    |

+---------------------------+

             |

             v

+---------------------------+

|   Build Docker Image      |

+---------------------------+

             |

             v

+---------------------------+

|    Run Container          |

|   (docker run image)      |

+---------------------------+

             |

             v

+---------------------------+

| Executed Command:         |

|   app --default-arg       |

+---------------------------+

Override CMD at Runtime:

(docker run image --custom-arg)

             |

             v

+---------------------------+

| Executed Command:         |

|   app --custom-arg        |

+---------------------------+

Override ENTRYPOINT at Runtime:

(docker run --entrypoint /bin/bash image)

             |

             v

+---------------------------+

| Executed Command:         |

|   /bin/bash               |

+---------------------------+संचालित द्वारा

Docker ENTRYPOINT की बुनियाद

इन बुनियादी बातों को समझना ENTRYPOINT का प्रभावी उपयोग करने में आपका आत्मविश्वास काफी बढ़ा देगा।

वैचारिक ढांचा

ENTRYPOINT उस executable या स्क्रिप्ट को निर्दिष्ट करता है जो कंटेनर स्टार्ट होते ही स्वतः चलता है। यह आपके कंटेनर की मुख्य प्रक्रिया है, जो उसके व्यवहार को पूर्वानुमेय ढंग से संचालित करती है।

मुख्य वाक्य-विन्यास

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

ENTRYPOINT जैसे Docker कॉन्सेप्ट समझना डेटा साइंस इंटरव्यू में सफल होने के लिए महत्वपूर्ण है। हमारे Top 26 Docker Interview Questions and Answers for 2025 में सामान्य प्रश्नों का अन्वेषण करें। 

ENTRYPOINT के सिंटैक्स रूप

Docker ENTRYPOINT दो अलग-अलग रूपों में आता है: shell और exec फॉर्म। इनके अंतर जानना आपको समझदारी से चयन करने में मदद करता है।

Shell फॉर्म

उदाहरण सिंटैक्स: 

ENTRYPOINT /usr/bin/ping -c 3 localhost

Shell फॉर्म शेल की सुविधाओं (वेरिएबल सब्स्टिट्यूशन, एनवायरनमेंट मैनीपुलेशन) के आसान एकीकरण को सुनिश्चित करता है।

हालाँकि, यह सिग्नल हैंडलिंग को कमजोर कर सकता है; यह सीधे PID 1 के रूप में चलने के बजाय मध्यवर्ती /bin/sh प्रक्रिया के अंदर चलता है, जिससे कंटेनरों को रोकने और पुनः शुरू करने में समस्याएँ आ सकती हैं।

PID 1 वह पहली प्रक्रिया है जो सिस्टम बूट के दौरान शुरू होती है। Docker में, PID 1 प्रक्रिया कंटेनर के अंदर सभी अन्य प्रक्रियाओं का प्रबंधन करती है। 

Exec फॉर्म

उदाहरण सिंटैक्स: 

ENTRYPOINT ["/usr/bin/ping", "-c", "3"]

Exec फॉर्म कमांड को सीधे PID 1 के रूप में निष्पादित करता है, जिससे सिग्नल हैंडलिंग और नियंत्रण विश्वसनीय हो जाता है।

हालाँकि, इसमें सीधे शेल सपोर्ट या स्वतः एनवायरनमेंट वेरिएबल एक्सपैंशन नहीं होता; शेल-जैसे व्यवहार के लिए अतिरिक्त स्क्रिप्टिंग की आवश्यकता होती है।

ENTRYPOINT बनाम CMD: मुख्य अंतर और उपयोग के मामले

ENTRYPOINT को CMD से अलग पहचानना भ्रम से बचाता है और पूर्वानुमेय कंटेनर व्यवहार सक्षम करता है।

निष्पादन प्राथमिकता

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

उपयोग परिदृश्य

ENTRYPOINT तब उपयोग करें जब हर लॉन्च पर सुसंगत, अनिवार्य निष्पादन चाहिए, जैसे सिंगल-कमांड कंटेनर या लेगेसी अनुप्रयोगों के चारों ओर रैपर स्क्रिप्ट। इसके विपरीत, CMD डिफ़ॉल्ट आर्ग्युमेंट बताने के लिए उपयुक्त है, जिससे रनटाइम ओवरराइड के साथ अधिक लचीलापन मिलता है।

हमारा Top 18 Docker Commands to Build, Run, and Manage Containers कंटेनर की बुनियाद से लेकर वॉल्यूम और नेटवर्किंग तक के आवश्यक Docker कमांड कवर करता है, ताकि आप विभिन्न वातावरणों में अनुप्रयोगों का आत्मविश्वास से प्रबंधन कर सकें।

व्यावहारिक उदाहरण

यह Dockerfile ENTRYPOINT और CMD के एक सामान्य संयोजन को दर्शाता है:

FROM ubuntu
ENTRYPOINT ["/usr/bin/ping", "-c", "3"]
CMD ["localhost"]संचालित द्वारा

यह Docker कंटेनर डिफ़ॉल्ट रूप से localhost पर तीन पिंग भेजता है। उपयोगकर्ता रनटाइम पर अन्य होस्ट देकर इस डिफ़ॉल्ट टार्गेट को आसानी से ओवरराइड कर सकते हैं, जबकि ENTRYPOINT का पूर्वानुमेय निष्पादन व्यवहार बना रहता है:

docker run ping-container google.comसंचालित द्वारा

आप Docker के साथ एप्लिकेशन डिप्लॉय करने के बारे में और जान सकते हैं हमारे Containerization and Virtualization with Docker and Kubernetes कोर्स से। 

ENTRYPOINT और CMD का संयोजन

ENTRYPOINT और CMD का सही संयोजन सुसंगतता से समझौता किए बिना लचीलापन देता है।

CMD रूप में डिफ़ॉल्ट आर्ग्युमेंट

ENTRYPOINT सेट करना मुख्य कमांड को विश्वसनीय बनाता है; CMD डिफ़ॉल्ट पैरामीटर देता है जिन्हें इमेज दोबारा बनाए बिना आसानी से ओवरराइड किया जा सकता है।

रनटाइम आर्ग्युमेंट ओवरराइड

docker run के दौरान दिए गए आर्ग्युमेंट केवल CMD-परिभाषित डिफ़ॉल्ट को ओवरराइट करते हैं। ENTRYPOINT यथावत रहता है, जिससे उपयोगकर्ताओं का अनुभव सरल होता है।

रनटाइम पर ENTRYPOINT ओवरराइड करना

Docker रनटाइम पर सीधे ENTRYPOINT को ओवरराइड करने देता है, जिससे आप अपने Dockerfile इमेज को दोबारा बनाए बिना डिबग कर सकते हैं।

Entrypoint फ़्लैग का उपयोग

Docker एक सरल फ़्लैग --entrypoint देता है जो अस्थायी रूप से कंटेनर के व्यवहार को बदल देता है।

docker run -it --entrypoint /bin/bash my-containerसंचालित द्वारा

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

ENTRYPOINT व्यवहार को कस्टमाइज़ करना

जब ENTRYPOINT को अधिक उन्नत कस्टमाइज़ेशन की आवश्यकता हो, तो Docker लचीलापन प्रदान करता है।

रनटाइम पर ENTRYPOINT ओवरराइड करना

आप docker run --entrypoint का उपयोग कर रनटाइम पर गतिशील रूप से ENTRYPOINT कमांड ओवरराइड कर सकते हैं—डिबगिंग या संदर्भ को जल्दी बदलने के लिए—बिना Dockerfile को बार-बार संशोधित किए।

आर्ग्युमेंट्स के साथ ENTRYPOINT

कंटेनरों में पास किए गए आर्ग्युमेंट रनटाइम पर ENTRYPOINT के पैरामीटर बन जाते हैं; सर्वोत्तम प्रथाएँ अधिकतम स्पष्टता और नियंत्रण के लिए CMD के साथ न्यूनतम ENTRYPOINT जटिलता सुझाती हैं।

रैपर स्क्रिप्ट

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

वास्तविक दुनिया के उदाहरण और पैटर्न

व्यावहारिक ENTRYPOINT अनुप्रयोग सामान्य, यथार्थवादी उपयोग दर्शा सकते हैं। आइए कुछ देखें।

सिंगल-कमांड कंटेनर 

एक Flask एप्लिकेशन सेटअप के लिए:

FROM python:3.11-alpine
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
ENTRYPOINT ["python", "app.py"]
CMD ["--port", "8080"]संचालित द्वारा

ऊपर दिए Dockerfile में:

• ENTRYPOINT ["python", "app.py"]  डिफ़ॉल्ट executable सेट करता है। यही कंटेनर शुरू होने पर चलता है।
• CMD ["--port", "8080"]  ENTRYPOINT कमांड के लिए डिफ़ॉल्ट आर्ग्युमेंट (--port 8080) प्रदान करता है।

पूरा डिफ़ॉल्ट कमांड जो निष्पादित होगा:

python app.py --port 8080संचालित द्वारा

 यदि आप कंटेनर रन करते समय CMD को ओवरराइड करते हैं (जैसे, docker run myimage --port 9090), तो यह --port 8080 को बदल देगा।

स्क्रिप्ट को ENTRYPOINT के रूप में 

यह सशर्त लॉजिक सेट करने के लिए उपयोग होता है: 

entrypoint.sh:

#!/bin/sh
until nc -z db_host 5432; do
  echo "Waiting for database to become available."
  sleep 2
done
exec python app.py "$@"संचालित द्वारा

Dockerfile:

FROM python:3.11-alpine
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
COPY entrypoint.sh .
RUN chmod +x entrypoint.sh
ENTRYPOINT ["./entrypoint.sh"]
CMD ["--port", "8080"]संचालित द्वारा

उपरोक्त फ़ाइलों में:

• entrypoint.sh डेटाबेस कनेक्शन का इंतज़ार करने के लिए उपयोग होता है।
• exec python app.py "$@"  चालू शेल प्रक्रिया को python app.py से बदल देता है और कोई भी अतिरिक्त आर्ग्युमेंट पास करता है। "$@" CMD या docker run पैरामीटर से आता है।
• COPY entrypoint.sh  entrypoint.sh स्क्रिप्ट को कंटेनर की /app डायरेक्टरी में कॉपी करता है।
• ENTRYPOINT ["./entrypoint.sh"] कंटेनर रन होने पर entrypoint.sh को डिफ़ॉल्ट स्टार्टअप स्क्रिप्ट के रूप में सेट करता है।
• CMD ["--port", "8080"] डिफ़ॉल्ट आर्ग्युमेंट देता है जो entrypoint.sh और अंततः python app.py को पास होंगे। अंतिम निष्पादित कमांड इस तरह होगा: python app.py --port 8080. 

सिग्नल हैंडलिंग और PID 1

ENTRYPOINT का फॉर्म PID 1 के महत्व के कारण Docker की सिग्नल हैंडलिंग क्षमता को काफी प्रभावित करता है। आइए इसे विस्तार से समझें: 

Exec फॉर्म और PID 1

Exec फॉर्म कमांड्स को सीधे Docker के PID 1 के रूप में चलाता है, जिससे सिग्नल फ़ॉरवर्डिंग की विश्वसनीयता और सही ढंग से रुकना/रीस्टार्ट होना बेहतर होता है।

Shell फॉर्म की सीमाएँ

Shell फॉर्म एक मध्यवर्ती शेल प्रक्रिया जोड़ता है। यह टर्मिनेशन सिग्नल को एप्लिकेशन प्रक्रियाओं तक पहुँचने से रोक सकता है, जिससे कंटेनरों के अटक जाने या अनुत्तरदायी होने का जोखिम बढ़ता है।

ENTRYPOINT व्यवहार का डिबगिंग

entrypoint कॉन्फ़िगरेशन का ट्रबलशूटिंग कुछ तकनीकों और तरकीबों से आसान हो जाता है। आइए उन्हें नीचे जानें। 

डिबगिंग के लिए --entrypoint का उपयोग

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

ENTRYPOINT लॉग देखना

docker logs से आउटपुट लॉग जाँचना निष्पादन इतिहास को ट्रेस करना और कॉन्फ़िगरेशन समस्याएँ स्पष्ट व शीघ्रता से ढूँढना आसान बनाता है।

अस्थायी परीक्षण के लिए Dockerfile संशोधित करने से बचें

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

ऑप्टिमाइज़ेशन तकनीकें और सर्वोत्तम प्रथाएँ

नीचे ENTRYPOINT की विश्वसनीयता और अनुरक्षणीयता बढ़ाने के लिए कुछ अनुशंसित ऑप्टिमाइज़ेशन दिए गए हैं।

सिग्नल हैंडलिंग के लिए exec फॉर्म का उपयोग करें

उचित टर्मिनेशन सिग्नल और बेहतर समग्र कंटेनर विश्वसनीयता व प्रबंधन के लिए हमेशा exec फॉर्म को प्राथमिकता दें।

ENTRYPOINT और CMD का प्रभावी संयोजन

अपने executable (ENTRYPOINT) को डिफ़ॉल्ट रनटाइम आर्ग्युमेंट (CMD) से अलग रखें और अधिकतम लचीलेपन व आसान प्रबंधन के लिए रनटाइम ओवरराइड का उपयोग करें।

ENTRYPOINT में जटिलता कम रखें

ENTRYPOINT को सरल रखें; जटिल स्टार्टअप लॉजिक या शर्तों को अलग स्क्रिप्ट में सौंपें ताकि जटिलता का सही प्रबंधन हो और स्पष्टता बढ़े।

उन्नत उपयोग के मामले और पैटर्न

आइए कुछ उन्नत ENTRYPOINT उपयोग के मामले और पैटर्न खोजें।

ENTRYPOINT के साथ मल्टी-स्टेज बिल्ड

अंतिम Docker स्टेज में ENTRYPOINT विश्वसनीय निष्पादन लागू करता है, जिससे CI/CD वर्कफ़्लो में विशेषतः प्रोडक्शन कार्यों के लिए साफ-सुथरी बिल्ड मिलती है।

डायनामिक ENTRYPOINT स्क्रिप्ट

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

CI/CD पाइपलाइन के लिए ENTRYPOINT

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

अन्य अनुप्रयोगों में शामिल हैं: 

• एक ENTRYPOINT जो डेटाबेस का इंतज़ार करता है, फिर माइग्रेशन चलाता है, और अंत में app स्टार्ट करता है।
• एक ENTRYPOINT जो स्वचालित रूप से एसेट्स को कंपाइल करता है, कोड लिंट करता है, या कॉन्फ़िगरेशन वैलिडेट करता है।
• ENTRYPOINT स्क्रिप्ट वातावरण (dev, staging, production) का पता लगा सकती हैं और कंटेनर स्टार्टअप पर अनुसार सेटिंग्स ट्यून कर सकती हैं। 

यहाँ एक उदाहरण है जिसमें Docker इमेज स्वतः टेस्ट चलाती है:

FROM python:3.11
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
ENTRYPOINT ["pytest"]संचालित द्वारा

.gitlab-ci.yml ऐसा दिखेगा:

build-test:
  image: docker:latest
  services:
    - docker:dind
  script:
    - docker build -t myapp-test .
    - docker run myapp-test  # <-- No need to specify 'pytest', ENTRYPOINT does itसंचालित द्वारा

जब docker run निष्पादित होता है, तो यह कंटेनर के अंदर स्वतः pytest ट्रिगर करता है। इससे सुनिश्चित होगा कि सभी टेस्ट तुरंत मिलें और चलें। 

CI/CD में ENTRYPOINT इस्तेमाल करने के कई फायदे हैं:

• हर कंटेनर एक ही तरह से शुरू होता है और व्यवहार करता है। 
• CI/CD स्क्रिप्ट सरल होती हैं क्योंकि आपको हर बार पूरा कमांड पास नहीं करना पड़ता। 
• प्री-स्टार्ट चेक, टेस्ट रन, और माइग्रेशन स्वतः होते हैं, जिससे मानवीय त्रुटि घटती है। 

आम गलतियाँ और ट्रबलशूटिंग

ENTRYPOINT में कुछ ऐसी गलतियाँ हैं जिनसे अपने वर्कफ़्लो में बचना चाहिए।

Shell फॉर्म का गलत उपयोग

Shell फॉर्म सिग्नलों और कंटेनर मैनेजर्स में बाधा डालता है; उचित सिग्नल हैंडलिंग, कंटेनर एक्ज़िट, और साफ़-सुथरे स्टॉप के लिए हमेशा exec फॉर्म को प्राथमिकता दें।

ENTRYPOINT को अनावश्यक रूप से जटिल बनाना

ऐसी जटिल स्क्रिप्ट जो स्पष्टता या विश्वसनीयता से रहित हों, डिबगिंग या रखरखाव के दौरान और खराब हो जाती हैं। सरल ENTRYPOINT सेटअप ट्रबलशूटिंग को काफी आसान बनाते हैं।

निष्कर्ष

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

हमारे Docker कोर्स देखें और इन विषयों को और जानें:

• Introduction to Docker
• Containerization and Virtualization Concepts 
• Containerization and Virtualization with Docker and Kubernetes
• Intermediate Docker