Play with Docker: अपने ब्राउज़र में मुफ्त में कंटेनर चलाएँ

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

फिर मुझे Play with Docker मिला, और इसने कंटेनराइज़ेशन सिखाने और सीखने का मेरा तरीका पूरी तरह बदल दिया।

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

इस व्यापक ट्यूटोरियल में, मैं आपको पहले कंटेनर से लेकर Docker Compose के साथ मल्टी-कंटेनर ऑर्केस्ट्रेशन तक सब कुछ समझाऊंगा। अंत तक, आपके पास एक कंटेनराइज़्ड वेब सर्वर चल रहा होगा—वह भी बिना ब्राउज़र छोड़े।

यदि आप Docker और उसके कॉन्सेप्ट्स में नए हैं, तो मैं हमारा Introduction to Docker कोर्स करने या Containerization and Virtualization Concepts पढ़ने की सलाह देता हूँ।

Play With Docker क्या है?

Play with Docker (PWD) एक मुफ्त, अस्थायी Docker प्लेग्राउंड है जो सीधे आपके वेब ब्राउज़र में चलता है। Docker कैप्टेन्स Marcos Liljedhal और Jonathan Leibiusky द्वारा बनाया गया, PWD एक हैकाथॉन प्रोजेक्ट से उभरा और जल्दी ही Docker समुदाय के लिए एक अहम टूल बन गया।

मूल रूप से, PWD Docker-in-Docker (dind) तकनीक का उपयोग करता है, जहाँ Docker कंटेनर अन्य Docker कंटेनरों के अंदर चलते हैं। यह नेस्टेड आर्किटेक्चर सुनने में जटिल लग सकता है, लेकिन यही वह चीज़ है जो आपको पूरी Docker क्षमताओं—जैसे मल्टी-नोड Swarm क्लस्टर—के साथ प्रयोग करने देता है, वह भी आपकी लोकल मशीन को प्रभावित किए बिना। 

प्लेटफ़ॉर्म पर्दे के पीछे की सारी जटिलता संभाल लेता है और आपको एक साफ-सुथरा टर्मिनल इंटरफ़ेस देता है। यह Alpine Linux इंस्टेन्स उपलब्ध कराता है—हल्के-फुल्के Linux डिस्ट्रीब्यूशन्स जो कंटेनर वर्कलोड्स के लिए उपयुक्त हैं। Alpine जानबूझकर मिनिमल है, जिसका बेस इमेज आकार लगभग 5 MB है, जबकि Ubuntu का 100+ MB होता है। 

यह दक्षता तेज़ डाउनलोड और तेज़ स्टार्टअप समय का अर्थ है। प्रत्येक इंस्टेन्स एक पूर्ण टर्मिनल अनुभव के साथ आता है, जो आपको वही कमांड-लाइन शक्ति देता है जो आपको लोकल इंस्टॉलेशन पर मिलती—शेल, Docker CLI, और Docker Compose सहित।

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

Play With Docker बनाम Docker Desktop

PWD क्या देता है, यह समझने के बाद, आप शायद सोच रहे होंगे कि इसे कब उपयोग करें और कब Docker Desktop लोकल रूप से इंस्टॉल करें। किस स्थिति में Play with Docker और किसमें Docker Desktop का उपयोग करना है, यह समझना आपका समय और परेशानी दोनों बचाएगा।

Play with Docker बिना इंस्टॉलेशन के तुरंत ब्राउज़र एक्सेस देता है, आपके लोकल संसाधनों का इस्तेमाल शून्य होता है, और पूर्ण Docker Swarm सपोर्ट—यह सब बिल्कुल मुफ्त। हालाँकि, सेशन्स केवल दो घंटे तक चलते हैं और फिर सब कुछ डिलीट हो जाता है, प्रदर्शन सीमित होता है, और सेशन समाप्ति के बाद कोई स्थायी स्टोरेज नहीं रहता।

नोट: भले ही PWD प्रलेखन में सेशन अवधि चार घंटे बताई गई है, पर मेरे परीक्षण में यह वास्तव में केवल दो घंटे थी। लगता है कि प्रलेखन अपडेटेड नहीं है।

Docker Desktop आपकी मशीन पर लोकल रूप से चलता है, जो स्थायी स्टोरेज, बेहतर प्रदर्शन, और Visual Studio Code जैसे विकास टूल्स के साथ सहज इंटीग्रेशन देता है। आप लंबे समय तक चलने वाले प्रोजेक्ट्स पर काम कर सकते हैं, सेशन टाइमआउट्स के बिना।

Play With Docker कब उपयोग करें

निम्न परिस्थितियों में Play with Docker बेहतरीन साबित होता है: 

• एक-बारगी परीक्षण 
• ट्यूटोरियल्स को फॉलो करना
• लो-स्पेक लैपटॉप या Chromebook पर काम करना
• डीबगिंग या डेमो के लिए टीममेट्स के साथ लाइव सेशन URL साझा करना

Docker Desktop कब उपयोग करें

Docker Desktop आवश्यक हो जाता है 

• दैनिक विकास कार्य
• IDE इंटीग्रेशन
• सप्ताहों या महीनों तक चलने वाले स्थायी प्रोजेक्ट्स
• कस्टम नेटवर्क्स और वॉल्यूम्स की जरूरत वाले संसाधन-गहन वर्कलोड्स

Play With Docker के साथ शुरुआत

अब जब आप जान गए हैं कि आपकी ज़रूरतों के लिए PWD कब सही टूल है, तो आइए आपको सेटअप कराते हैं और आपका पहला सेशन चलाते हैं।

Play with Docker सेट करना

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

Play with Docker लॉगिन

Play with Docker वेबसाइट पर जाएँ और अपने Docker Hub क्रेडेंशियल्स से लॉग इन करें। ऑथेंटिकेशन के बाद, हरे रंग के "Start" बटन पर क्लिक करें ताकि आपका सेशन जेनरेट हो जाए। कुछ ही सेकंड में, PWD आपके ब्राउज़र में एक नया Alpine Linux वातावरण तैयार कर देता है, जिसमें दो घंटे के शेष सेशन समय का काउंटडाउन टाइमर दिखता है।

Play with Docker डैशबोर्ड में नेविगेट करना

PWD इंटरफ़ेस सरल लेकिन शक्तिशाली है। नए Alpine Linux कंटेनर बनाने के लिए "Add New Instance" पर क्लिक करें। आप मल्टी-नोड क्लस्टर्स के परीक्षण के लिए एक साथ अधिकतम 5 इंस्टेन्स चला सकते हैं। मुख्य टर्मिनल विंडो एक पूर्ण bash शेल प्रदान करती है, जिसमें Docker पहले से इंस्टॉल होता है। 

काउंटडाउन टाइमर पर नज़र रखें। जैसे ही यह शून्य पर पहुँचेगा, सब कुछ डिलीट हो जाएगा और सेशन बढ़ाने का कोई तरीका नहीं है।

Play with Docker में डैशबोर्ड

संकेत: मानक Ctrl+V पेस्ट ऑपरेशन अक्सर PWD में काम नहीं करते। कॉपी करने के लिए Ctrl+Insert और पेस्ट करने के लिए Shift+Insert का उपयोग करें। झुंझलाहट से बचने के लिए अपना पेस्ट शॉर्टकट तुरंत जाँच लें।

Play With Docker में मुख्य ऑपरेशंस

अब जब आपका PWD वातावरण तैयार है और इंटरफ़ेस परिचित हो गया है, तो अपना पहला कंटेनर चलाने और आवश्यक Docker कमांड्स सीखने का समय है।

अपना पहला कंटेनर चलाना

इमेज और कंटेनर समझने के लिए एक Nginx वेब सर्वर डिप्लॉय करते हैं। यह कमांड चलाएँ:

docker run -d -p 80:80 nginxसंचालित द्वारा

यह होता क्या है: docker run एक नया कंटेनर बनाकर स्टार्ट करता है। -d फ़्लैग इसे डिटैच्ड मोड (बैकग्राउंड) में चलाता है। -p 80:80 होस्ट के पोर्ट 80 को कंटेनर के पोर्ट 80 से मैप करता है। nginx Docker इमेज का नाम है।

Docker इमेज को एक रेसिपी की तरह समझें—यहाँ Nginx की रेसिपी। चल रहा कंटेनर उस रेसिपी से बेक किया गया केक है। आप एक रेसिपी (इमेज) से कई केक (कंटेनर) बना सकते हैं।

अपने कंटेनर को मैनेज करने के लिए:

docker ps              # चल रहे कंटेनर दिखाएँ
docker stop <id>       # कंटेनर रोकें
docker rm <id>         # रुके हुए कंटेनर हटाएँसंचालित द्वारा

आपको कंटेनर ID के शुरुआती कुछ अक्षरों की ही जरूरत होती है। Docker समझ जाता है कि आप किसका जिक्र कर रहे हैं।

Play with Docker में पोर्ट फॉरवर्डिंग

PWD में पोर्ट फॉरवर्डिंग लोकल पोर्ट फॉरवर्डिंग से अलग तरह से काम करती है। जैसे ही आप कोई पोर्ट एक्सपोज़ करते हैं, PWD एक्सेस के लिए एक डायनमिक URL अपने-आप बना देता है।

Nginx कंटेनर चलाने के बाद, अपनी PWD स्क्रीन के शीर्ष पर IP के नीचे देखें। "Open Port" पर क्लिक करें और “80” जोड़ें। यह एक नए ब्राउज़र टैब में एक यूनीक URL खोलेगा, जैसे http://ip<numbers>-<session-id>.direct.labs.play-with-docker.com।

Play with Docker में पोर्ट फॉरवर्डिंग

आप यहाँ localhost को एक्सेस नहीं कर रहे हैं। PWD ऐसे विशेष URLs बनाता है जो इंटरनेट ट्रैफिक को आपके विशेष कंटेनर तक रूट करते हैं। इसका मतलब है कि आप ये URLs सहकर्मियों के साथ साझा कर सकते हैं और उन्हें रियल-टाइम में अपना काम दिखा सकते हैं।

डीबगिंग और निरीक्षण

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

ट्रबलशूटिंग के दौरान, ये कमांड्स कंटेनर के अंदर झाँकने में मदद करते हैं:

docker logs <container-id>         # कंटेनर आउटपुट देखें
docker ps                          # चल रहे कंटेनर की स्थिति दिखाएँ  
docker inspect <container-id>      # विस्तृत JSON कॉन्फ़िगरेशन प्राप्त करेंसंचालित द्वारा

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

Play with Docker में Docker लॉग्स

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

Play With Docker में इमेज बनाना और डेटा मैनेज करना

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

एक बेसिक Dockerfile लिखना

Dockerfiles टेक्स्ट-आधारित निर्देशों के ज़रिए इमेज बिल्डिंग को ऑटोमेट करते हैं। हर बार कंटेनर को मैन्युअली कॉन्फ़िगर करने के बजाय, आप एक बार Dockerfile लिखते हैं और बाकी काम Docker संभाल लेता है। 

Play with Docker में Dockerfile बनाएँ

पहले, टर्मिनल में Dockerfile बनाएँ:

touch Dockerfileसंचालित द्वारा

फिर PWD में "Editor" बटन पर क्लिक करें और एक साधारण इमेज जोड़ें:

FROM alpine
CMD ["echo", "Hello DataCamp"]संचालित द्वारा

अंत में, Dockerfile को बिल्ड और रन करें। -t फ़्लैग आपकी इमेज का नाम (या "टैग") तय करता है, जिससे उसे संदर्भित करना आसान होता है। . Docker को बताता है कि बिल्ड कॉन्टेक्स्ट मौजूदा डायरेक्टरी है—यहीं Docker को Dockerfile और ज़रूरी फाइलें मिलेंगी। आप देखेंगे कि Docker हर निर्देश को निष्पादित करता है और लेयर IDs आउटपुट करता है।

docker build -t my-first-image .
docker run my-first-imageसंचालित द्वारा

Play with Docker में Docker इमेज बिल्ड करें

आप "Hello DataCamp" प्रिंट होता देखेंगे। बधाई हो! आपने अपनी पहली कस्टम इमेज बना ली है! यह सरल उदाहरण मुख्य वर्कफ़्लो दिखाता है: निर्देश लिखें, इमेज बिल्ड करें, कंटेनर चलाएँ।

लेकिन एक अहम चुनौती का सामना करना ज़रूरी है: जब कंटेनर रुकते या डिलीट होते हैं तो आपके डेटा का क्या होता है?

Play with Docker में डेटा पर्सिस्टेंस

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

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

पर जिस डेटा को संभालकर रखना है, उसका क्या? यहीं Docker वॉल्यूम्स काम आते हैं। वॉल्यूम Docker द्वारा मैनेज किया जाने वाला एक स्टोरेज क्षेत्र है जो कंटेनर फाइलसिस्टम के बाहर होता है। इसे एक USB ड्राइव की तरह समझें जिसे आप अलग-अलग कंटेनरों में प्लग कर सकते हैं। एक कंटेनर से अनप्लग कर दूसरे में प्लग करते समय भी डेटा उसी ड्राइव पर बना रहता है।

Docker कंटेनर बनाम Docker वॉल्यूम

देखते हैं यह व्यवहार में कैसे काम करता है। एक वॉल्यूम बनाएँ और उपयोग करें:

docker volume create mydata
docker run -it -v mydata:/data alpine shसंचालित द्वारा

-v mydata:/data फ्लैग कंटेनर के अंदर /data पथ पर mydata वॉल्यूम माउंट करता है। /data में जो भी लिखा जाता है, वह वास्तव में वॉल्यूम में स्टोर होता है। एक टेस्ट फ़ाइल बनाएँ:

echo "This data persists!" > /data/important.txt
echo "Container ID: $(hostname)" >> /data/important.txt
exitसंचालित द्वारा

कंटेनर रुक गया है और हट चुका है। अब उसी वॉल्यूम के साथ एक बिल्कुल नया कंटेनर शुरू करें:

docker run -it -v mydata:/data alpine sh
cat /data/important.txtसंचालित द्वारा

Docker वॉल्यूम्स के साथ डेटा परज़िस्टेंस

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

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

डेटा परज़िस्टेंस समझना ज़रूरी है, पर ज्यादातर वास्तविक एप्लिकेशन कई परस्पर जुड़े सर्विसेज़ से मिलकर बनते हैं। यहीं Docker Compose काम आता है।

Docker Compose के साथ कंटेनर ऑर्केस्ट्रेशन

जब आप अलग-अलग कंटेनरों पर पकड़ बना लें, तो अब बारी है वास्तविक एप्लिकेशन की—जो शायद ही कभी एकल सर्विस होते हैं। आधुनिक एप्लिकेशन आमतौर पर कई घटकों से मिलकर बनते हैं: एक वेब फ्रंटएंड, एक API बैकएंड, एक डेटाबेस, एक कैश, और संभवतः एक मैसेज क्यू। इन्हें अलग-अलग docker run कमांड्स से मैनेज करना समन्वय का बुरा सपना बन सकता है।

Docker Compose क्यों इस्तेमाल करें?

यह परिदृश्य सोचें: आप एक ऐसा एप्लिकेशन डिप्लॉय कर रहे हैं जिसे वेब सर्वर, PostgreSQL डेटाबेस, और Redis कैश चाहिए। 

Compose के बिना, आपको तीन अलग-अलग docker run कमांड चाहिए होंगे, जिनमें नेटवर्किंग, पोर्ट मैपिंग, वॉल्यूम माउंटिंग और एनवायरनमेंट वेरिएबल्स के कई फ्लैग्स होंगे। आपको उन्हें शुरू करने का सटीक क्रम याद रखना होगा (पहले डेटाबेस, फिर कैश, फिर वेब सर्वर), और अगर कुछ गड़बड़ हो जाए, तो डिबगिंग कई टर्मिनल विंडोज़ में खोजना-खंगालना बन जाती है।

Docker Compose इस ऑर्केस्ट्रेशन चुनौती को सुरुचिपूर्ण ढंग से हल करता है। कई कमांड्स से जूझने के बजाय, आप पूरा मल्टी-कंटेनर एप्लिकेशन एक YAML फ़ाइल docker-compose.yml में परिभाषित करते हैं। यह फ़ाइल आपकी एप्लिकेशन आर्किटेक्चर का एकल स्रोत बन जाती है, जिसमें सभी सर्विसेज़, उनकी कॉन्फ़िगरेशन, आपस में कनेक्शन और किन वॉल्यूम्स का उपयोग होता है—सब वर्णित होता है।

Compose के साथ, पूरा स्टैक डिप्लॉय करना एक कमांड बन जाता है: docker-compose up। इसे हटाना भी उतना ही सरल है: docker-compose down। यह डिक्लेरेटिव तरीका इन्फ्रास्ट्रक्चर को पुनरुत्पाद्य बनाता है। कोई भी आपका रिपॉज़िटरी क्लोन कर सकता है और एक ही कमांड से पूरा एप्लिकेशन स्टैक चला सकता है—चाहे उसका ऑपरेटिंग सिस्टम या लोकल कॉन्फ़िगरेशन कुछ भी हो।

Docker Compose फ़ाइल संरचना

आइए एक बेसिक Docker Compose फ़ाइल बनाते हैं।

पहले, टर्मिनल में touch docker-compose.yml से फ़ाइल बनाएँ, फिर PWD में "Editor" पर क्लिक करें और फ़ाइल में निम्न सामग्री जोड़ें:

services:
  web:
    image: nginx
    ports:
      - "80:80"
  redis:
    image: redisसंचालित द्वारा

services सेक्शन हर कंटेनर को परिभाषित करता है। सर्विस के नाम (जैसे web और redis) Docker नेटवर्क पर होस्टनेम बन जाते हैं। image कुंजी बताती है कि कौन-सी Docker Hub इमेज इस्तेमाल करनी है। इसे डिप्लॉय करें:

docker-compose up -dसंचालित द्वारा

अब जब दोनों कंटेनर चल रहे हैं, तो आप सोच सकते हैं: ये एक-दूसरे को ढूंढते और आपस में संवाद कैसे करते हैं?

नेटवर्किंग और सर्विस डिस्कवरी

Compose स्वतः एक नेटवर्क बनाता है जो सभी सर्विसेज़ को जोड़ता है और सर्विस डिस्कवरी सक्षम करता है। कंटेनर सर्विस नामों को होस्टनेम की तरह उपयोग करके संवाद करते हैं।

इसे web कंटेनर में जाकर Redis को पिंग करके परखें:

docker-compose exec web sh
apt-get update && apt-get install -y iputils-ping
ping redisसंचालित द्वारा

सफल पिंग यह साबित करते हैं कि कंटेनर आपस में संवाद कर सकते हैं! web कंटेनर बिना IP पता जाने redis तक पहुँचता है। Docker का आंतरिक DNS स्वतः सर्विस नामों को सही कंटेनर एड्रेस पर रेज़ॉल्व करता है।

Play with Docker में ट्रबलशूटिंग और सर्वोत्तम प्रथाएँ

जैसे-जैसे आप PWD के साथ काम करेंगे, कुछ आम चुनौतियाँ आएँगी। इन्हें प्रभावी ढंग से कैसे संभालें, यहाँ बताया गया है।

“Session expired”

दो घंटे की सीमा PWD की सबसे बड़ी पाबंदी है। जब टाइमर शून्य पर पहुँचता है, तो सब कुछ हट जाता है—इंस्टेंसेज़ और डेटा सहित। कुशलता से काम करें: PWD में पेस्ट करने से पहले कोड को लोकली तैयार रखें और बैकअप बनाए रखें। अपने कस्टम इमेजेज़ को सेशन समाप्त होने से पहले Docker Hub पर पुश करें:

docker tag my-first-image yourusername/my-first-image
docker push yourusername/my-first-imageसंचालित द्वारा

एक सेशन में एक ही कॉन्सेप्ट पर ध्यान दें, जटिल सिस्टम बनाने की बजाय। सीखने के लिए दो घंटे पर्याप्त हैं, इसलिए काम को अलग-अलग हिस्सों में बाँटें।

पोर्ट 80/443 त्रुटियाँ

लोकल Docker के विपरीत, जहाँ आप कंटेनरों को localhost से एक्सेस करते हैं, PWD डायनेमिक URLs उपयोग करता है। localhost:80 आज़माएँ नहीं। इसके बजाय, PWD इंटरफ़ेस के शीर्ष पर पोर्ट बैज पर क्लिक करें। यदि बैज तुरंत नहीं दिखते, तो कुछ सेकंड प्रतीक्षा करें या ब्राउज़र रिफ्रेश करें।

सर्वोत्तम प्रथाएँ

साथ ही, इन सर्वोत्तम प्रथाओं का ध्यान रखें:

• Alpine जैसी छोटी बेस इमेजेज़ का उपयोग करें (5 MB बनाम Ubuntu के 100+ MB) ताकि बैंडविड्थ बचे
• बिना आवश्यकता कंटेनरों को root के रूप में न चलाएँ
• PWD एक सार्वजनिक प्लेटफ़ॉर्म है—वास्तविक क्रेडेंशियल्स कभी उपयोग न करें
• स्पष्ट Dockerfiles लिखें और अपने चुनावों को समझाने वाली टिप्पणियाँ जोड़ें
• इमेजेज़ को एकल ज़िम्मेदारियों पर केंद्रित रखें।

निष्कर्ष

आपने इस ट्यूटोरियल में काफी कुछ कवर किया। आपने जाना कि Play with Docker क्या है, Docker Desktop के बजाय कब इसे उपयोग करना चाहिए, अपना पहला कंटेनर चलाया, पोर्ट फ़ॉरवर्डिंग समझी, और डिबगिंग कमांड्स का उपयोग किया। हमने Dockerfiles के साथ कस्टम इमेजेज़ बनाई, वॉल्यूम्स के साथ डेटा परज़िस्टेंस खोजी, और Docker Compose से मल्टी-कंटेनर एप्लिकेशन ऑर्केस्ट्रेट किए।

Play with Docker बिना लोकल इंस्टॉलेशन की बाध्यता के Docker की बुनियादी बातें सीखने के लिए एक जोखिम-मुक्त वातावरण देता है। जिन कौशलों का आपने अभ्यास किया—Dockerfiles लिखना, कंटेनर मैनेज करना, और नेटवर्क कॉन्फ़िगर करना—वे सीधे वास्तविक दुनिया में Docker उपयोग पर लागू होते हैं।

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

इस नींव पर आगे बढ़ते रहें। अलग-अलग बेस इमेजेज़ के साथ प्रयोग करें, Docker की नेटवर्किंग क्षमताओं का अन्वेषण करें, और प्रोडक्शन-रेडी Dockerfiles लिखने का अभ्यास करें। सीखते रहें, प्रयोग करते रहें, और बनाते रहें। 

हमारा Docker और Kubernetes के साथ कंटेनराइज़ेशन और वर्चुअलाइज़ेशन कंटेनरों के साथ काम करने के लिए एक उत्कृष्ट आधार देता है। सीखना जारी रखने के लिए, मैं निम्न संसाधनों को भी देखने की सलाह देता/देती हूँ:

• Docker Compose गाइड: मल्टी-कंटेनर डेवलपमेंट को सरल बनाएं

• Docker पोर्ट को एक्सपोज़ कैसे करें

• Docker for Beginners: कंटेनरों के लिए एक व्यावहारिक गाइड

• एक Docker इमेज को कंटेनर के रूप में चलाएँ: एक व्यावहारिक शुरुआती गाइड

• Ubuntu पर Docker इंस्टॉल करें: सेटअप से पहले कंटेनर तक