कस्टम NGINX Docker इमेज कैसे बनाएँ

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

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

यदि आप Docker में नए हैं, तो हमारी Docker for Beginners गाइड ज़रूर देखें और सभी बुनियादी बातें सीखें। 

Docker NGINX क्या है?

Docker NGINX का अर्थ है NGINX वेब सर्वर को हल्के कंटेनर के अंदर चलाना। Docker कंटेनर छोटे पैकेज जैसे होते हैं जो किसी एप्लिकेशन और उसकी सभी निर्भरताओं को साथ रखते हैं। 

NGINX एक लोकप्रिय वेब सर्वर है, जो उच्च प्रदर्शन, आसान कॉन्फ़िगरेशन और HTTP ट्रैफ़िक की लचीली हैंडलिंग के लिए जाना जाता है। NGINX और Docker को साथ लाना आकर्षक है क्योंकि यह वातावरण को स्थिर रखता है। चाहे आप macOS, Windows, या Linux पर डिप्लॉय करें, कंटेनर की सामग्री एक जैसी रहती है। यानी यह होस्ट ऑपरेटिंग सिस्टम के बावजूद एक जैसा व्यवहार करता है।

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

एप्लिकेशन को कंटेनराइज़ करने के बारे में और जानने के लिए हमारा How to Containerize an Application Using Docker ट्यूटोरियल देखें। यह शुरुआती-अनुकूल तरीके से Docker के साथ मशीन लर्निंग एप्लिकेशंस को कंटेनराइज़ करने का विस्तार से वर्णन करता है। 

पूर्वापेक्षाएँ

NGINX कंटेनर चलाने से पहले, सुनिश्चित करें कि Docker इंस्टॉल है। Docker के macOS, Windows और विभिन्न Linux डिस्ट्रीब्यूशंस के लिए आधिकारिक इंस्टॉलर्स हैं। Docker दस्तावेज़ीकरण प्रत्येक ऑपरेटिंग सिस्टम के लिए चरण-दर-चरण प्रक्रिया प्रदान करता है। 

शुरू करने की संपूर्ण मार्गदर्शिका के लिए हमारा Introduction to Docker कोर्स देखें। 

अपनी इंस्टॉलेशन को किसी त्वरित कमांड से जाँचें, जैसे:

docker version
derrickmwiti@Derricks-MacBook-Pro% docker version
Client:
 Version:           28.0.1
 API version:       1.48
 Go version:        go1.23.6
 Git commit:        068a01e
 Built:             Wed Feb 26 10:38:16 2025
 OS/Arch:           darwin/arm64
 Context:           desktop-linux
Server: Docker Desktop 4.39.0 (184744)
 Engine:
  Version:          28.0.1
  API version:      1.48 (minimum version 1.24)
  Go version:       go1.23.6
  Git commit:       bbd0a17
  Built:            Wed Feb 26 10:40:57 2025
  OS/Arch:          linux/arm64
  Experimental:     false
 containerd:
  Version:          1.7.25
  GitCommit:        bcc810d6b9066471b0b6fa75f557a15a1cbf31bb
 runc:
  Version:          1.2.4
  GitCommit:        v1.2.4-0-g6c52b3f
 docker-init:
  Version:          0.19.0
  GitCommit:        de40ad0संचालित द्वारा

यदि आपको संस्करण विवरण दिखते हैं, तो इसका मतलब Docker तैयार है। Docker के अलावा, आपको Docker Hub से NGINX इमेज खींचने के लिए इंटरनेट एक्सेस की आवश्यकता होगी। यदि आप अपनी इमेज बनाना चाहते हैं, तो Dockerfile लिखने के लिए एक टेक्स्ट एडिटर चाहिए। कोई भी टेक्स्ट एडिटर चलेगा, बस जो आपको सुविधाजनक लगे उसे चुनें।

Docker कंटेनर में NGINX सेट अप करना

तैयार इमेज से NGINX चलाना आमतौर पर सबसे तेज़ तरीका है। आप इसे कुछ ही सेकंड में Docker Hub से खींच सकते हैं और फिर एक कंटेनर लॉन्च कर सकते हैं। इसके बाद, आप अपने ब्राउज़र में डिफ़ॉल्ट पेज देखेंगे। यह छोटा-सा प्रोसेस कई Docker-आधारित सर्वर सेटअप्स में पहला कदम होता है।

NGINX Docker इमेज खींचना

आधिकारिक NGINX इमेज Docker Hub पर nginx नाम से सार्वजनिक रूप से उपलब्ध है। 

इसे इस तरह खींचें:

docker pull nginx
derrickmwiti@Derricks-MacBook-Pro % docker pull nginx
Using default tag: latest
latest: Pulling from library/nginx
4c7c1a5bd3af: Download complete 
bef2ee7fab45: Download complete 
d9b636547744: Downloading [======================>                            ]  12.58MB/28.04MB
0994e771ba34: Downloading [===>                                               ]  3.146MB/40.56MB
589701e352f8: Download complete 
13f89c653285: Download complete 
8e77214beb25: Download complete संचालित द्वारा

यह रजिस्ट्री से नवीनतम संस्करण लाता है। सब कुछ पूर्ण होने पर, आप यह जाँच सकते हैं कि यह आपकी मशीन पर मौजूद है:

docker images
derrickmwiti@Derricks-MacBook-Pro% docker images
REPOSITORY                                                                     TAG                                                                           IMAGE ID       CREATED         SIZE

nginx                                                                          latest                                                                        124b44bfc9cc   6 weeks ago     280MB
keras-custom-training-container                                                latest                                                                                                                                     <none>                                                                        7de0f04013e5   7                                                  संचालित द्वारा

यह कमांड आपकी लोकल लाइब्रेरी में मौजूद इमेजेज़ की सूची दिखाती है। आपको तालिका में nginx इमेज दिखनी चाहिए। इसका अर्थ है कि आप इससे कंटेनर बनाने के लिए तैयार हैं। अपने डेटा साइंस प्रोजेक्ट्स के लिए ज़रूरी इमेजेज़ की सूची हमारे Top 12 Docker Container Images for Machine Learning and AI ट्यूटोरियल से खोजें। 

NGINX कंटेनर चलाना

एक बार NGINX इमेज सिस्टम पर होने पर, आप एक ही कमांड से कंटेनर शुरू कर सकते हैं:

docker run --name mynginx -p 8080:80 -d nginx
derrickmwiti@Derricks-MacBook-Pro % docker run --name mynginx -p 8080:80 -d nginx
ec44d1a43016e9684b602437b967c0ed8e11c933a8a76b341b68c25168d2af70संचालित द्वारा

यह कमांड कई काम करती है। यह mynginx नाम का कंटेनर बैकग्राउंड में चलाती है (-d विकल्प के कारण)। यह आपके होस्ट पर पोर्ट 8080 को कंटेनर के अंदर पोर्ट 80 से मैप करती है। इस पोर्ट मैपिंग का मतलब है कि आप अपने ब्राउज़र में http://localhost:8080 पर जाएँ और डिफ़ॉल्ट NGINX पेज देखें। कंटेनर Docker Hub से खींची गई nginx इमेज का उपयोग करता है।

नया कंटेनर चलता रहना चाहिए क्योंकि NGINX सक्रिय है। यदि आप लॉग्स देखें:

docker logs mynginx
derrickmwiti@Derricks-MacBook-Pro % docker logs mynginx
/docker-entrypoint.sh: /docker-entrypoint.d/ is not empty, will attempt to perform configuration
/docker-entrypoint.sh: Looking for shell scripts in /docker-entrypoint.d/
/docker-entrypoint.sh: Launching /docker-entrypoint.d/10-listen-on-ipv6-by-default.sh
10-listen-on-ipv6-by-default.sh: info: Getting the checksum of /etc/nginx/conf.d/default.conf
10-listen-on-ipv6-by-default.sh: info: Enabled listen on IPv6 in /etc/nginx/conf.d/default.conf
/docker-entrypoint.sh: Sourcing /docker-entrypoint.d/15-local-resolvers.envsh
/docker-entrypoint.sh: Launching /docker-entrypoint.d/20-envsubst-on-templates.sh
/docker-entrypoint.sh: Launching /docker-entrypoint.d/30-tune-worker-processes.sh
/docker-entrypoint.sh: Configuration complete; ready for start up
2025/03/20 04:33:10 [notice] 1#1: using the "epoll" event method
2025/03/20 04:33:10 [notice] 1#1: nginx/1.27.4
2025/03/20 04:33:10 [notice] 1#1: built by gcc 12.2.0 (Debian 12.2.0-14) 
2025/03/20 04:33:10 [notice] 1#1: OS: Linux 6.10.14-linuxkit
2025/03/20 04:33:10 [notice] 1#1: getrlimit(RLIMIT_NOFILE): 1048576:1048576
2025/03/20 04:33:10 [notice] 1#1: start worker processes
2025/03/20 04:3संचालित द्वारा

आप देख सकते हैं कि NGINX ने क्या संदेश लिखे हैं। 

NGINX के साथ कस्टम सामग्री सर्व करना

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

कस्टम HTML पेज बनाना

अपनी लोकल मशीन पर एक सुविधाजनक स्थान चुनें। संभवतः आपके होम डायरेक्टरी में html_content नाम का फ़ोल्डर। वहाँ एक index.html फ़ाइल बनाएँ। वह कुछ इस तरह दिख सकती है:

<html>
<head>
    <title>My NGINX Page</title>
</head>
<body>
    <h1>Hello from my Docker NGINX setup!</h1>
    <p>This is a custom page served from a local folder.</p>
</body>
</html>संचालित द्वारा

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

HTML पेज को NGINX कंटेनर में माउंट करना

आधिकारिक NGINX इमेज डिफ़ॉल्ट रूप से /usr/share/nginx/html से सामग्री सर्व करती है। आप अपने लोकल फ़ोल्डर को कंटेनर के अंदर उस लोकेशन पर मैप कर सकते हैं। यह Docker में -v (वॉल्यूम) फ़्लैग से होता है। पोर्ट कॉन्फ्लिक्ट से बचने के लिए mynginx नाम के किसी मौजूदा कंटेनर को बंद करें:

docker stop mynginx
docker rm mynginxसंचालित द्वारा

फिर एक नया कंटेनर शुरू करें:

docker run --name mynginx -p 8080:80 -d \
    -v /Users/derrickmwiti/Documents/html_content:/usr/share/nginx/html \
    nginx
6f68085733eeac418c3302e5c580a4f7c5c0c36d3591d8e2a7f35f69f6308d18संचालित द्वारा

अपने कंप्यूटर पर वास्तविक पथ से /path/to/html_content को बदलें। इस तरह, जब भी आप http://localhost:8080 पर ब्राउज़ करेंगे, कंटेनर html_content में रखी आपकी HTML फ़ाइल सर्व करेगा। डिफ़ॉल्ट रूप से, यदि आप फ़ाइल का नाम index.html रखते हैं, तो NGINX उसे अपने आप लोड कर लेगा।

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

यदि आपको परमिशन से संबंधित चेतावनी दिखे, तो सुनिश्चित करें कि आपका लोकल यूज़र और Docker उस फ़ोल्डर को पढ़ सकते हैं। 

Linux पर, इसका मतलब ओनरशिप या फ़ाइल परमिशन्स समायोजित करना हो सकता है। Windows या macOS पर, इसका मतलब Docker को आपके ड्राइव तक पहुँच देने की अनुमति प्रदान करना हो सकता है।

कस्टम NGINX Docker इमेज बनाना

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

Docker एक छोटा-सा रेसिपी फ़ाइल बनाना आसान करता है, जिसे Dockerfile कहा जाता है, जो कंटेनर को बिलकुल आपकी जरूरत के मुताबिक सेट अप करता है। इसके बाद आपके पास एक इमेज होगी जिसे आप दूसरों के साथ साझा कर सकते हैं या किसी रजिस्ट्री पर पुश कर सकते हैं। यह लोगों से ढेर सारे लोकल फ़ाइलें माउंट करने को कहने से अधिक सुविधाजनक हो सकता है।

Dockerfile बनाना

Dockerfile एक सादा टेक्स्ट फ़ाइल है। आप इसका नाम Dockerfile रख सकते हैं या चाहें तो कोई और नाम दें। इसे एक नई डायरेक्टरी में रखें। यहाँ एक सरल उदाहरण है:

FROM nginx:latest

COPY index.html /usr/share/nginx/html/index.htmlसंचालित द्वारा

यह आधिकारिक nginx:latest इमेज को बेस के रूप में उपयोग करता है। फिर यह लोकल index.html फ़ाइल को कंटेनर के डिफ़ॉल्ट वेब कंटेंट फ़ोल्डर में कॉपी करता है। यदि ज़रूरत हो तो आप और पंक्तियाँ शामिल कर सकते हैं। उदाहरण के लिए, आप कस्टम nginx.conf कॉपी कर सकते हैं या इंस्टॉल करने वाले मॉड्यूल जोड़ सकते हैं। यह आपकी ज़रूरतों पर निर्भर है। यदि सिर्फ़ एक स्टैटिक पेज रखना है, तो ऊपर का स्निपेट काफ़ी है।

जब आपके पास Dockerfile तैयार हो, तो उसी फ़ोल्डर में कस्टम index.html जोड़ें। फिर आप बिल्ड कर सकते हैं। सामान्य कमांड है:

docker build -t mynginximage .
[+] Building 2.6s (7/7) FINISHED                                                                                                                                                       docker:desktop-linux
 => [internal] load build definition from Dockerfile                                                                                                                                                   0.0s
 => => transferring dockerfile: 245B                                                                                                                                                                   0.0s
 => [internal] load metadata for docker.io/library/nginx:latest                                                                                                                                        0.0s
 => [internal] load .dockerignore                                                                                                                                                                      0.0s
 => => transferring context: 2B                                                                                                                                                                        0.0s
 => [internal] load build context                                                                                                                                                                      0.0s
 => => transferring context: 365B                                                                                                                                                                      0.0s
 => [1/2] FROM docker.io/library/nginx:latest@sha256:124b44bfc9ccd1f3cedf4b592d4d1e8bddb78b51ec2ed5056c52d3692baebc19                                                                                  2.3s
 => => resolve docker.io/library/nginx:latest@sha256:124b44bfc9ccd1f3cedf4b592d4d1e8bddb78b51ec2ed5056c52d3692baebc19                                                                                  2.3s
 => [2/2] COPY index.html /usr/share/nginx/html/index.html                                                                                                                                             0.0s
 => exporting to image                                                                                                                                                                                 0.1s
 => => exporting layers                                                                                                                                                                                0.0s
 => => exporting manifest sha256:19dd719772fd7ac839fadb7d49862f84422f4571a442994ffaca152e9674553a                                                                                                      0.0s
 => => exporting config sha256:e974f3ab92a0278e419f0fe4c5a6fc43fafb4a75da27895d90c4f2d5d385daa1                                                                                                        0.0s
 => => exporting attestation manifest sha256:e391b0212e5a100bd9132fbbd6cb4052e288dbbcba093839b55f8b197131372b                                                                                          0.0s
 => => exporting manifest list sha256:d35c2bbe10ab0b7e46d1ef8fba6c6cb28628eb9c283db02607e32e95b62e14d5                                                                                                 0.0s
 => => naming to docker.io/library/mynginximage:latest                                                                                                                                                 0.0s
 => => unpacking to docker.io/library/mynginximage:latest                                                                                                                                              0.0sसंचालित द्वारा

अंत में लगा डॉट वर्तमान डायरेक्टरी को बिल्ड कॉन्टेक्स्ट बताता है। Docker उस डायरेक्टरी में Dockerfile पढ़ता है। आपके लोकल सिस्टम पर mynginximage नाम की इमेज बन जाएगी। इसे जाँचें:

docker images
mynginximage                                                                   latest                                                                        d35c2bbe10ab   36 seconds ago   281MBसंचालित द्वारा

आपको सूची में नया नाम दिखना चाहिए। इस तरीके का मतलब है कि आपका Dockerfile और HTML एक ही इमेज में समाहित हो जाते हैं। रनटाइम पर कुछ माउंट करने की ज़रूरत नहीं।

कस्टम इमेज बनाना और चलाना

अब जब mynginximage बन चुकी है, तो आप इसे चला सकते हैं:

docker run --name mycustomnginx -p 8080:80 -d mynginximageसंचालित द्वारा

पोर्ट कॉन्फ्लिक्ट से बचने के लिए पहले वाले कंटेनर को ज़रूर बंद करें। 

यह कंटेनर अपने आप वही पेज सर्व करेगा जो आपने Dockerfile में रखा था। यदि आप ब्राउज़र में http://localhost:8080 खोलें, तो आपको वही HTML टेक्स्ट दिखेगा। 

आप अपना Dockerfile दूसरों के साथ साझा कर सकते हैं या बनी हुई इमेज को किसी रजिस्ट्री पर पुश कर सकते हैं। तब आपके टीममेट्स या सहकर्मी बिना लोकल फ़ोल्डर्स कॉपी किए इसे चला पाएँगे।

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

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

इन 10 Docker Project Ideas की खोज करें और डेटा साइंस एप्लिकेशंस बनाने व ऑप्टिमाइज़ करने पर केंद्रित प्रोजेक्ट्स के साथ Docker सीखें।

रिवर्स प्रॉक्सी के रूप में NGINX सेट करना

NGINX आने वाले अनुरोधों को उसी सिस्टम पर चल रही अन्य सेवाओं या अलग मशीनों पर चल रही सेवाओं तक भेज सकता है। इसे आमतौर पर रिवर्स प्रॉक्सी सेटअप कहा जाता है। आप NGINX को कई एप्लिकेशंस के आगे रख सकते हैं ताकि अनुरोध एक ही एंट्री पॉइंट से होकर गुजरें। 

यह तब आम है जब आपके पास अलग-अलग पोर्ट्स पर सुनने वाले कई Docker कंटेनर हों और आप सबके लिए एक ही डोमेन नाम चाहते हों। NGINX 80 या 443 जैसे मानक पोर्ट पर सुनता है, फिर पाथ, होस्टनेम, या अन्य कारकों के आधार पर ट्रैफ़िक को सही सेवा तक रूट करता है।

रिवर्स प्रॉक्सी को समझना

जब NGINX इस तरह कॉन्फ़िगर होता है, क्लाइंट को बैकग्राउंड संचार का पता नहीं चलता। NGINX सार्वजनिक चेहरा बनकर अनुरोध प्राप्त और अग्रेषित करता है, और फिर प्रतिक्रियाएँ क्लाइंट को वापस भेजता है। 

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

एक सामान्य परिदृश्य में पोर्ट 80 पर NGINX चलाने वाला कंटेनर हो सकता है, जो अनुरोधों को पोर्ट 3000 पर चल रहे एप्लिकेशन कंटेनर को भेजता है। जबकि क्लाइंट http://yourdomain.com पर आता है, ट्रैफ़िक पर्दे के पीछे किसी अलग कंटेनर तक पहुँचाया जाता है। 

इससे आपका एप्लिकेशन कंटेनर अपना डिफ़ॉल्ट पोर्ट रख सकता है और उपयोगकर्ता के लिए ओवरहेड न्यूनतम रहता है। एक और कारण यह हो सकता है कि आप अपनी सेवाओं के आंतरिक विवरण छिपाना चाहते हों या एक समान URL संरचना प्रस्तुत करना चाहते हों।

रिवर्स प्रॉक्सी के लिए NGINX कॉन्फ़िगर करना

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

server {
    listen 80;

    location / {
        proxy_pass http://myapp:3000/;
    }
}संचालित द्वारा

ऊपर दिए स्निपेट में, आपके NGINX कंटेनर पर पोर्ट 80 पर आने वाला कोई भी अनुरोध myapp:3000 को भेज दिया जाता है। myapp नाम संकेत देता है कि उस नाम से पहुँचा जा सकने वाला कोई दूसरा कंटेनर है, जो Docker नेटवर्किंग में आम बात है। 

यदि आप स्टैंडअलोन कंटेनर्स उपयोग कर रहे हैं, तो आप कंटेनर का IP पता मैप कर सकते हैं या होस्ट का IP उपयोग कर सकते हैं। आप अधिक उन्नत सेटिंग्स भी जोड़ सकते हैं, जैसे proxy_set_header Host $host, या अपने एप्लिकेशन के अनुसार टाइमआउट मान समायोजित कर सकते हैं।

यदि आप इस फ़ाइल को रनटाइम पर माउंट करना चाहें, तो कुछ इस तरह कर सकते हैं:

docker run --name nginxproxy -p 8080:80 -d \
    -v /path/to/nginx.conf:/etc/nginx/conf.d/default.conf \
    --network mynetwork \
    nginxसंचालित द्वारा

यह कमांड NGINX कंटेनर चलाती है और आपकी लोकल nginx.conf को डिफ़ॉल्ट कॉन्फ़िगरेशन के रूप में माउंट करती है। यह कंटेनर को mynetwork नामक Docker नेटवर्क से भी जोड़ती है, जहाँ आपका दूसरा कंटेनर (myapp) मौजूद है। यदि आप कॉन्फ़िगरेशन को कंटेनर के बाहर रखना चाहते हैं, तो यह अक्सर सबसे सरल तरीका है। 

यदि आप स्थिर व्यवस्था चाहते हैं, तो इस फ़ाइल को Dockerfile में भी रख सकते हैं। कोई भी तरीका काम करेगा, बशर्ते संदर्भ आपके कंटेनर्स और नेटवर्क्स के नामों से मेल खाते हों।

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

NGINX डिप्लॉयमेंट के लिए Docker Compose का उपयोग

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

Docker Compose का परिचय

Docker Compose आपको कंटेनर्स के सेट मैनेज करने देता है। आप प्रत्येक सेवा का विवरण लिखते हैं, कौन सी इमेज उपयोग करनी है, कौन से पोर्ट पब्लिश करने हैं, कौन से वॉल्यूम्स माउंट करने हैं, और किन नेटवर्क्स से जोड़ना है। फिर एक सरल कमांड (docker compose up -d) सब कुछ एक साथ शुरू कर देता है। 

यह तरीका लोकल डेवलपमेंट या स्टेजिंग वातावरणों में सुविधाजनक है, जहाँ कई Docker कंटेनर्स का तालमेल ज़रूरी होता है। सामान्य फ़ाइल फ़ॉर्मेट YAML होता है।

हालाँकि Docker Compose विभिन्न ऑपरेटिंग सिस्टम्स पर काम कर सकता है, सुनिश्चित करें कि यह इंस्टॉल और मान्य है। आधुनिक Docker Desktop इंस्टॉलेशन्स में यह अक्सर डिफ़ॉल्ट रूप से शामिल होता है। अपना संस्करण इस प्रकार जाँचें:

docker compose version
Docker Compose version v2.33.1-desktop.1संचालित द्वारा

यदि आपको संस्करण विवरण दिखते हैं, तो आप आगे बढ़ने के लिए तैयार हैं। यदि नहीं, तो Docker दस्तावेज़ देखें कि Docker Compose कैसे सक्षम या इंस्टॉल करें।

docker-compose.yml फ़ाइल बनाना

फ़ाइल में आमतौर पर services सेक्शन होता है। नीचे docker-compose.yml फ़ाइल का एक सरल उदाहरण है जो स्टैटिक सामग्री सर्व करने के लिए एकल NGINX कंटेनर सेट अप करता है: 

services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"
    volumes:
      - ./html:/usr/share/nginx/htmlसंचालित द्वारा

फ़ाइल को इस तरह समझें:

• services: आपकी एप्लिकेशन बनाने वाली सेवाओं (कंटेनर्स) को परिभाषित करता है।

• web: यह सेवा नवीनतम NGINX इमेज का उपयोग करती है।
• ports: कंटेनर के अंदर पोर्ट 80 को आपके होस्ट मशीन पर पोर्ट 8080 से मैप करता है। इससे आप http://localhost:8080 के जरिए वेब सर्वर तक पहुँच सकते हैं।
• volumes: लोकल html डायरेक्टरी को कंटेनर के अंदर NGINX की डिफ़ॉल्ट कंटेंट डायरेक्टरी (/usr/share/nginx/html) से माउंट करता है। यह सेटअप NGINX को आपकी कस्टम स्टैटिक सामग्री सर्व करने में सक्षम बनाता है।

Docker Compose के साथ सेवाएँ डिप्लॉय करना

अपनी docker-compose.yml फ़ाइल वाली डायरेक्टरी में, html नाम की एक सबडायरेक्टरी बनाएँ।

अपनी स्टैटिक HTML फ़ाइलें (जैसे index.html) इस html डायरेक्टरी में रखें। इस डेमो के लिए मैंने एक साधारण Bootstrap-स्टाइल्ड पेज बनाया है। 

एक टर्मिनल खोलें और अपने प्रोजेक्ट डायरेक्टरी पर जाएँ जिसमें docker-compose.yml फ़ाइल है।

सेवा शुरू करने के लिए निम्न कमांड चलाएँ:

docker compose up -d
[+] Running 1/1
 ✔ Container html_content-web-1  Started संचालित द्वारा

-d फ़्लैग कंटेनर को डिटैच्ड मोड में चलाता है, जिससे वह बैकग्राउंड में चलता रहता है।

Docker Compose वर्तमान डायरेक्टरी में मौजूद docker-compose.yml फ़ाइल देखता है। यह कोई भी अनुपस्थित इमेज खींचता है और फिर प्रत्येक कंटेनर लॉन्च करता है। 

अपना वेब ब्राउज़र खोलें और http://localhost:8080 पर जाएँ।

आपको NGINX द्वारा सर्व की गई अपनी स्टैटिक सामग्री दिखनी चाहिए।

आप अपने चल रहे सेवाओं की स्थिति इस तरह जाँच सकते हैं:

docker compose psसंचालित द्वारा

यदि आपको सब कुछ हटाना हो, तो एक ही कमांड कंटेनर्स को हटा सकती है:

docker compose downसंचालित द्वारा

यह सबको एक साथ रोककर हटा देता है। यदि आप पूरे वातावरण की प्रतिकृति बनाना चाहते हैं, तो केवल Docker Compose फ़ाइल और संबंधित कोड नई मशीन पर कॉपी करें, और वही कमांड्स चलाएँ। इससे न्यूनतम मैनुअल चरणों के साथ सुसंगत परिणाम सुनिश्चित होते हैं।

NGINX कंटेनर्स मैनेज करना

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

ये हाउसकीपिंग के लिए ज़रूरी हैं, खासकर यदि आप कई NGINX कंटेनर्स या बार-बार होने वाले बिल्ड्स के साथ प्रयोग कर रहे हैं।

चल रहे कंटेनर्स देखना

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

docker ps
CONTAINER ID   IMAGE          COMMAND                  CREATED         STATUS         PORTS                  NAMES
2d386c085129   mynginximage   "/docker-entrypoint.…"   4 minutes ago   Up 4 minutes   0.0.0.0:8080->80/tcp   mycustomnginxसंचालित द्वारा

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

docker ps -aसंचालित द्वारा

यह आपके सिस्टम पर मौजूद हर कंटेनर दिखाता है, यहाँ तक कि जो बाहर निकल चुके हों। यह देखना अक्सर मददगार होता है कि पुराने रन से कौन से कंटेनर अभी भी मौजूद हैं। यदि आपने कई इमेजेज़ के साथ प्रयोग किया है, तो आपके पास mynginx, mycustomnginx या अन्य नाम के कंटेनर हो सकते हैं।

कंटेनर्स को रोकना और हटाना

जब आप किसी कंटेनर के साथ काम पूरा कर लें, तो उसे नाम से रोक सकते हैं:

docker stop mynginxसंचालित द्वारा

यह Docker को कंटेनर तक स्टॉप सिग्नल भेजने के लिए कहता है, जिससे NGINX सुव्यवस्थित रूप से बंद हो जाना चाहिए। यदि आप तुरंत बाद कंटेनर हटाना चाहें, तो यह करें:

docker rm mynginxसंचालित द्वारा

यदि आप एक ही बार में रोकना और हटाना चाहते हैं, तो यह आज़माएँ:

docker rm -f mynginxसंचालित द्वारा

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

यदि आपको कुछ इमेजेज़ की ज़रूरत नहीं और स्पेस खाली करना है, तो यह मददगार है। हालाँकि, Docker केवल उन इमेजेज़ को हटाता है जिन्हें कोई चल रहा कंटेनर उपयोग नहीं कर रहा।

निष्कर्ष

Docker में NGINX वेब पेज सर्व करने या ट्रैफ़िक को अन्य सेवाओं तक रूट करने का सुविधाजनक तरीका है। आप आधिकारिक इमेज चला सकते हैं या एक साधारण Dockerfile से अपनी इमेज बना सकते हैं। Docker Compose कई कंटेनर्स का समन्वय कर सकता है, जिससे जटिल सेटअप्स सँभालना आसान हो जाता है। 

इन तरीकों से, आप सामग्री वितरित कर सकते हैं, फ़ॉरवर्डिंग संभाल सकते हैं, और वेब प्रोजेक्ट्स के लिए एक भरोसेमंद वातावरण बनाए रख सकते हैं। 

यदि आपको Docker सीखने के लिए अधिक हैंड्स-ऑन तरीका चाहिए, तो हमारा Introduction to Docker Course देखें और डेटा प्रोफेशनल के टूलकिट में इसकी महत्ता जानें।