डॉकर का उपयोग करते समय, हम आधार छवि के साथ शुरू करते हैं। हम इसे बूट करते हैं, परिवर्तन बनाते हैं और उन परिवर्तनों को एक और छवि बनाने वाली परतों में सहेजा जाता है।
तो आखिरकार मेरे पास मेरी पोस्टग्रेक्यूएल आवृत्ति के लिए एक छवि है और मेरे वेब एप्लिकेशन के लिए एक छवि है, जिसमें परिवर्तन जारी है।
कंटेनर क्या है?
जवाबों:
एक छवि के एक उदाहरण को एक कंटेनर कहा जाता है। आपकी एक छवि है, जो आपके द्वारा वर्णित परतों का एक समूह है। यदि आप इस छवि को शुरू करते हैं, तो आपके पास इस छवि का एक चालू कंटेनर है। आपके पास एक ही छवि के कई चलने वाले कंटेनर हो सकते हैं।
आप अपनी सभी छवियों docker imagesको देख सकते हैं, जबकि आप अपने साथ चलने वाले कंटेनरों docker psको देख सकते हैं (और आप सभी कंटेनरों को देख सकते हैं docker ps -a)।
एक छवि का एक चल उदाहरण एक कंटेनर है।
स्वचालित डॉकटर नियोजन पर मेरे लेख से :
डॉकरलैंड में, चित्र हैं और कंटेनर हैं । दोनों बारीकी से संबंधित हैं, लेकिन अलग हैं। मेरे लिए, इस द्वंद्ववाद को लोभी ने डॉकटर को बेहद स्पष्ट किया है।
एक छवि एक निष्क्रिय, अपरिवर्तनीय, फ़ाइल है जो अनिवार्य रूप से एक कंटेनर का स्नैपशॉट है। छवियां बिल्ड कमांड के साथ बनाई गई हैं , और वे रन के साथ शुरू होने पर एक कंटेनर का उत्पादन करेंगे । छवियाँ जैसे एक डोकर रजिस्ट्री में जमा हो जाती है registry.hub.docker.com । क्योंकि वे काफी बड़े हो सकते हैं, छवियों को अन्य छवियों की परतों से बना होता है, जिससे नेटवर्क पर छवियों को स्थानांतरित करते समय कम से कम डेटा भेजा जा सकता है।
स्थानीय चित्रों को चलाकर सूचीबद्ध किया जा सकता है docker images:
REPOSITORY TAG IMAGE ID CREATED VIRTUAL SIZE
ubuntu 13.10 5e019ab7bf6d 2 months ago 180 MB
ubuntu 14.04 99ec81b80c55 2 months ago 266 MB
ubuntu latest 99ec81b80c55 2 months ago 266 MB
ubuntu trusty 99ec81b80c55 2 months ago 266 MB
<none> <none> 4ab0d9120985 3 months ago 486.5 MB
ध्यान देने योग्य कुछ बातें:
-tध्वज से आता है docker build, या docker tagकिसी मौजूदा छवि से। आप एक नामकरण का उपयोग करके छवियों को टैग करने के लिए स्वतंत्र हैं जो आपको समझ में आता है, लेकिन यह जान लें कि docker टैग का उपयोग रजिस्ट्री स्थान में docker pushया के रूप में करेगा docker pull।[REGISTRYHOST/][USERNAME/]NAME[:TAG]। के लिए ubuntuऊपर, REGISTRYHOST होने के लिए मान लिया जाता है registry.hub.docker.com। इसलिए यदि आप my-applicationरजिस्ट्री में अपनी छवि को स्टोर करने की योजना बनाते हैं docker.example.com, तो आपको उस छवि को टैग करना चाहिए docker.example.com/my-application।latestटैग, जादुई नहीं है यह बस डिफ़ॉल्ट टैग जब आप एक टैग निर्दिष्ट नहीं करते है।<none>TAG और REPOSITORY मिलेगी । उनके बारे में भूलना आसान है।छवियों पर अधिक जानकारी डॉकर प्रलेखन और शब्दावली से उपलब्ध है ।
एक प्रोग्रामिंग रूपक का उपयोग करने के लिए, यदि कोई छवि एक वर्ग है, तो एक कंटेनर एक वर्ग का एक उदाहरण है- एक रनटाइम ऑब्जेक्ट। कंटेनर उम्मीद कर रहे हैं कि आप डॉकर का उपयोग क्यों कर रहे हैं; वे अनुप्रयोगों को चलाने के लिए एक वातावरण के हल्के और पोर्टेबल encapsulations हैं।
इसके साथ स्थानीय रनिंग कंटेनर देखें docker ps:
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
f2ff1af05450 samalba/docker-registry:latest /bin/sh -c 'exec doc 4 months ago Up 12 weeks 0.0.0.0:5000->5000/tcp docker-registry
यहां मैं डॉकटर रजिस्ट्री का डॉक्यूमेंटेड संस्करण चला रहा हूं, ताकि मेरे पास अपनी छवियों को संग्रहीत करने के लिए एक निजी स्थान हो। फिर, कुछ बातों पर ध्यान दें:
docker psकेवल कंटेनरों को चलाने वाले आउटपुट । आप सभी कंटेनरों को ( रनिंग या रोका हुआ ) देख सकते हैं docker ps -a।--nameध्वज के माध्यम से प्रारंभ किए गए कंटेनर की पहचान करने के लिए किया जा सकता है ।डॉकर के साथ मेरी शुरुआती कुंठाओं में अनगढ़ इमेजेज और रुकने वाले कंटेनरों का निरंतर स्थिर निर्माण था । कुछ अवसरों पर इस बिल्डअप के कारण मेरे लैपटॉप की गति धीमी हो गई या मेरी स्वचालित बिल्ड पाइपलाइन को रोक दिया गया। "हर जगह कंटेनर" के बारे में बात करें!
हम docker rmiहाल की dangling=trueक्वेरी के साथ संयोजन करके सभी असंबद्ध छवियों को निकाल सकते हैं :
docker images -q --filter "dangling=true" | xargs docker rmi
डॉकर उन छवियों को हटाने में सक्षम नहीं होगा जो मौजूदा कंटेनरों के पीछे हैं, इसलिए आपको docker rmपहले बंद किए गए कंटेनरों को निकालना पड़ सकता है :
docker rm `docker ps --no-trunc -aq`
ये डॉकटर के साथ ज्ञात दर्द बिंदु हैं और भविष्य के रिलीज में संबोधित किए जा सकते हैं। हालांकि, छवियों और कंटेनरों की स्पष्ट समझ के साथ, इन स्थितियों को कुछ प्रथाओं के साथ टाला जा सकता है:
docker rm [CONTAINER_ID]।docker rmi [IMAGE_ID]।docker image pruneझूलने वाली छवियों को साफ करने के लिए उपयोग कर सकते हैं । प्र्यून ने अप्रयुक्त डॉकिंग ऑब्जेक्ट
docker system pruneसब साफ करने के लिए उपयोग करता हूं
आसान शब्दों में।
चित्र -
फ़ाइल सिस्टम और कॉन्फ़िगरेशन (केवल पढ़ने के लिए) एप्लिकेशन जो कंटेनर बनाने के लिए उपयोग किया जाता है। अधिक विस्तार ।
कंटेनर -
ये डॉकर चित्रों के उदाहरण हैं। कंटेनर वास्तविक अनुप्रयोग चलाते हैं। एक कंटेनर में एक एप्लिकेशन और उसकी सभी निर्भरताएं शामिल हैं। यह कर्नेल को अन्य कंटेनरों के साथ साझा करता है और होस्ट ओएस पर उपयोगकर्ता अंतरिक्ष में एक पृथक प्रक्रिया के रूप में चलता है। अधिक विस्तार ।
नोटिस करने के लिए अन्य महत्वपूर्ण शर्तें:
डॉकर डेमन -
मेज़बान पर चलने वाली पृष्ठभूमि सेवा जो डॉकर कंटेनरों के निर्माण, चलाने और वितरित करने का प्रबंधन करती है।
डॉकर क्लाइंट -
कमांड लाइन टूल जो उपयोगकर्ता को डॉकर डेमन के साथ बातचीत करने की अनुमति देता है।
डॉकर स्टोर -
स्टोर, अन्य चीजों के बीच, डॉकर चित्रों की एक रजिस्ट्री है। आप सभी उपलब्ध डॉकर चित्रों की निर्देशिका के रूप में रजिस्ट्री के बारे में सोच सकते हैं।
इस ब्लॉग पोस्ट की एक तस्वीर एक हजार शब्दों के लायक है।
(गहरी समझ के लिए पढ़ें यह ।)
सारांश:
docker run image_name:tag_name) => एक चल छवि देता है अर्थात कंटेनर (संपादन योग्य)हालांकि कंटेनर को एक रनिंग इमेज के रूप में समझना सबसे सरल है, यह बिल्कुल सटीक नहीं है ।
एक छवि वास्तव में एक टेम्पलेट है जिसे कंटेनर में बदल दिया जा सकता है। एक छवि को कंटेनर में बदलने के लिए, डॉकर इंजन छवि लेता है, शीर्ष पर एक रीड-राइट फाइलसिस्टम जोड़ता है और नेटवर्क पोर्ट, कंटेनर नाम, आईडी और संसाधन सीमा सहित विभिन्न सेटिंग्स को इनिशियलाइज़ करता है। एक चल रहे कंटेनर में वर्तमान में एक निष्पादन प्रक्रिया होती है, लेकिन एक कंटेनर को भी रोका जा सकता है (या डॉकर्स शब्दावली में बाहर रखा गया है)। एक बाहर निकलने वाला कंटेनर एक छवि के समान नहीं है, क्योंकि इसे फिर से शुरू किया जा सकता है और यह अपनी सेटिंग्स और किसी भी फाइल सिस्टम में बदलाव को बनाए रखेगा।
docker create।
शायद पूरे वर्कफ़्लो को समझाने से मदद मिल सकती है।
सब कुछ डोकरफाइल से शुरू होता है । Dockerfile छवि का स्रोत कोड है।
Dockerfile बन जाने के बाद, आप कंटेनर की छवि बनाने के लिए इसका निर्माण करते हैं । छवि "स्रोत कोड" का "संकलित संस्करण" है जो डॉकफाइल है।
एक बार जब आपके पास कंटेनर की छवि होती है, तो आपको रजिस्ट्री का उपयोग करके इसे फिर से वितरित करना चाहिए । रजिस्ट्री एक गिट रिपोजिटरी की तरह है - आप छवियों को धक्का और खींच सकते हैं।
अगला, आप कंटेनरों को चलाने के लिए छवि का उपयोग कर सकते हैं । एक वर्चुअल मशीन (लेकिन हाइपरविज़र के बिना ) कई पहलुओं में एक चालू कंटेनर बहुत समान है ।
यहां विभिन्न कमांड्स और उनसे जुड़े इनपुट्स और आउटपुट दिखाने वाले एंड-टू-एंड वर्कफ़्लो हैं। यह एक छवि और एक कंटेनर के बीच संबंध को स्पष्ट करना चाहिए।
+------------+ docker build +--------------+ docker run -dt +-----------+ docker exec -it +------+
| Dockerfile | --------------> | Image | ---------------> | Container | -----------------> | Bash |
+------------+ +--------------+ +-----------+ +------+
^
| docker pull
|
+--------------+
| Registry |
+--------------+
उन छवियों को सूचीबद्ध करने के लिए जिन्हें आप चला सकते हैं, निष्पादित करें:
docker image ls
उन कंटेनरों को सूचीबद्ध करने के लिए जिन पर आप कमांड निष्पादित कर सकते हैं:
docker ps
मैं यहां सभी प्रश्नों को पढ़ने के बावजूद छवि और परत की अवधारणा को समझ नहीं सका और फिर अंततः डॉकटर (डुह!) के इस उत्कृष्ट दस्तावेज पर ठोकर खाई ।
वहाँ उदाहरण वास्तव में पूरी अवधारणा को समझने की कुंजी है। यह एक लंबा पद है, इसलिए मैं उन प्रमुख बिंदुओं को संक्षेप में बता रहा हूं, जिन्हें स्पष्टता प्राप्त करने के लिए वास्तव में समझने की आवश्यकता है।
चित्र : एक डोकर छवि केवल पढ़ने वाली परतों की एक श्रृंखला से निर्मित है
परत : प्रत्येक परत छवि के डॉकरफाइल में एक निर्देश का प्रतिनिधित्व करती है।
Example: नीचे दिए गए डॉकरफाइल में चार कमांड होते हैं, जिनमें से प्रत्येक एक परत बनाता है।
Ubuntu से: 15.04
कॉपी करें। / ऐप्स
RUN मेक / एप
CMD पायथन /app/app.py
महत्वपूर्ण रूप से , प्रत्येक परत परत से पहले अंतर का एक सेट है।
इसलिए, एक कंटेनर और एक छवि के बीच मुख्य अंतर शीर्ष लिखने योग्य परत है । सभी कंटेनर में लिखते हैं जो नया जोड़ते हैं या मौजूदा डेटा को संशोधित करते हैं, इस योग्य परत में संग्रहीत होते हैं। जब कंटेनर हटा दिया जाता है, तो लिखने योग्य परत भी हटा दी जाती है। अंतर्निहित छवि अपरिवर्तित बनी हुई है।
छवियों को समझना cnd कंटेनरों को एक साइज़-ऑन-डिस्क परिप्रेक्ष्य से
एक चल रहे कंटेनर के अनुमानित आकार को देखने के लिए, आप docker ps -sकमांड का उपयोग कर सकते हैं । आप प्राप्त sizeऔर virtual sizeआउटपुट के दो रूप में:
आकार: डेटा की मात्रा (डिस्क पर) जिसका उपयोग प्रत्येक कंटेनर की लिखने योग्य परत के लिए किया जाता है
वर्चुअल साइज़: कंटेनर द्वारा उपयोग की जाने वाली रीड-ओनली इमेज डेटा के लिए उपयोग किए जाने वाले डेटा की मात्रा। एकाधिक कंटेनर कुछ या केवल पढ़ने के लिए केवल छवि डेटा साझा कर सकते हैं। इसलिए ये एडिटिव नहीं हैं। यानी आप इस बात की गणना करने के लिए सभी आभासी आकारों को नहीं जोड़ सकते कि डिस्क का आकार छवि द्वारा कितना उपयोग किया जाता है
एक अन्य महत्वपूर्ण अवधारणा कॉपी-ऑन-राइट रणनीति है
यदि कोई फ़ाइल या निर्देशिका छवि के भीतर एक निचली परत में मौजूद है, और दूसरी परत (लिखने योग्य परत सहित) को इसे पढ़ने की आवश्यकता है, तो यह मौजूदा फ़ाइल का उपयोग करती है। पहली बार किसी अन्य परत को फ़ाइल को संशोधित करने की आवश्यकता होती है (जब छवि का निर्माण या कंटेनर चलाना), फ़ाइल को उस परत में कॉपी किया जाता है और संशोधित किया जाता है।
मुझे उम्मीद है कि मेरी तरह किसी और की मदद करेगा।
Dockerfile → (बिल्ड) → इमेज → (रन) → कंटेनर ।
Dockerfile : में Docker निर्देशों का एक सेट होता है जो आपके ऑपरेटिंग सिस्टम को आपके पसंद के अनुसार व्यवस्थित करता है, और आपके सभी सॉफ़्टवेयर को स्थापित / कॉन्फ़िगर करता है।
चित्र : संकलित Dockerfile। हर बार जब आप एक कंटेनर को चलाने की आवश्यकता होती है, तो आप डॉकरफाइल के पुनर्निर्माण से समय बचाता है। और यह आपके प्रावधान कोड को छिपाने का एक तरीका है।
कंटेनर : वर्चुअल ऑपरेटिंग सिस्टम ही। आप इसमें ssh कर सकते हैं और अपनी इच्छानुसार कोई भी कमांड चला सकते हैं, जैसे कि यह एक वास्तविक वातावरण हो। आप एक ही Image से 1000+ कंटेनर चला सकते हैं।
एक कंटेनर सिर्फ एक निष्पादन योग्य बाइनरी है जो होस्ट ओएस द्वारा प्रतिबंधों के एक सेट के तहत चलाया जाना है जो एक एप्लिकेशन (जैसे, डॉकर) का उपयोग करके पूर्व निर्धारित है जो जानता है कि ओएस को कैसे बताया जाए कि कौन से प्रतिबंध लागू होते हैं।
विशिष्ट प्रतिबंध प्रक्रिया-अलगाव से संबंधित हैं, सुरक्षा संबंधी (जैसे SELinux सुरक्षा का उपयोग करके ) और सिस्टम-संसाधन संबंधी (मेमोरी, डिस्क, सीपीयू और नेटवर्किंग)।
कुछ समय पहले तक, यूनिक्स-आधारित प्रणालियों में केवल गुठली ने सख्त प्रतिबंधों के तहत निष्पादन को चलाने की क्षमता का समर्थन किया था। यही कारण है कि आज ज्यादातर कंटेनर टॉक्स में ज्यादातर लिनक्स या अन्य यूनिक्स वितरण शामिल हैं।
डॉकर उन अनुप्रयोगों में से एक है, जो जानता है कि ओएस (लिनक्स ज्यादातर) को कैसे बताया जाए कि किस निष्पादन योग्य के तहत प्रतिबंध लगाया जाए। निष्पादन योग्य डॉकर छवि में निहित है, जो सिर्फ एक टारफाइल है। निष्पादन योग्य आमतौर पर लिनक्स वितरण (उबंटू, CentOS, डेबियन, आदि) का एक छीन-डाउन संस्करण है जो एक या अधिक अनुप्रयोगों को चलाने के लिए पूर्वनिर्मित है।
यद्यपि अधिकांश लोग लिनक्स बेस को निष्पादन योग्य के रूप में उपयोग करते हैं, यह किसी अन्य बाइनरी एप्लिकेशन के रूप में हो सकता है जब तक होस्ट ओएस इसे चला सकता है ( खरोंच का उपयोग करके एक सरल आधार छवि बनाना देखें )। क्या डॉकर छवि में बाइनरी एक ओएस है या बस एक एप्लिकेशन है, ओएस होस्ट के लिए यह सिर्फ एक और प्रक्रिया है, एक पूर्व निर्धारित ओएस सीमाओं द्वारा शासित प्रक्रिया है।
अन्य एप्लिकेशन जो डॉकर की तरह, होस्ट ओएस को बता सकते हैं कि कौन सी प्रक्रिया चल रही है, जबकि LXC , libvirt , और systemd शामिल हैं । Docker इन अनुप्रयोगों का उपयोग अप्रत्यक्ष रूप से Linux OS के साथ इंटरैक्ट करने के लिए करता था, लेकिन अब Docker लिनक्स के साथ सीधे अपनी लाइब्रेरी का उपयोग करके " libcontainer " कहलाता है ।
इसलिए कंटेनर केवल एक प्रतिबंधित मोड में चलने वाली प्रक्रियाएं हैं, जो कि चिरोट क्या करते थे, के समान है।
IMO, जो डॉकटर को किसी अन्य कंटेनर तकनीक से अलग करता है, वह इसकी रिपॉजिटरी (डॉकटर हब) और उनके प्रबंधन उपकरण हैं जो कंटेनरों के साथ काम करना बहुत आसान बनाते हैं।
डॉकर (सॉफ्टवेयर) देखें ।
डॉकर की मुख्य अवधारणा "मशीनें" बनाना आसान है जो इस मामले में कंटेनरों को माना जा सकता है। पुन: प्रयोज्य में कंटेनर सहायता, आपको आसानी से कंटेनर बनाने और छोड़ने की अनुमति देता है।
छवियाँ हर समय एक कंटेनर की स्थिति को दर्शाती हैं। तो मूल वर्कफ़्लो है:
जैसा कि कई जवाबों में कहा गया है: आप एक छवि पाने के लिए डॉकरफाइल का निर्माण करते हैं और एक कंटेनर पाने के लिए आप छवि चलाते हैं ।
हालांकि, निम्नलिखित चरणों ने मुझे डॉकटर छवि और कंटेनर के लिए एक बेहतर अनुभव प्राप्त करने में मदद की:
1) डॉकफेराइल बनाएँ:
docker build -t my_image dir_with_dockerfile
2) .tarफाइल करने के लिए इमेज को सेव करें
docker save -o my_file.tar my_image_id
my_file.tarछवि संग्रहीत करेगा। इसके साथ खोलें tar -xvf my_file.tar, और आपको सभी परतें देखने को मिलेंगी। यदि आप प्रत्येक परत में गहराई से गोता लगाते हैं, तो आप देख सकते हैं कि प्रत्येक परत में क्या बदलाव जोड़े गए थे। (वे डॉकरीफाइल में कमांडों के बहुत करीब होने चाहिए)।
3) एक कंटेनर के अंदर देखने के लिए, आप कर सकते हैं:
sudo docker run -it my_image bash
और आप देख सकते हैं कि यह एक OS की तरह है।
छवि OOP में एक वर्ग परिभाषा के समतुल्य है और परतें उस वर्ग के विभिन्न तरीके और गुण हैं।
कंटेनर छवि की वास्तविक तात्कालिकता है जैसे कोई वस्तु एक तात्कालिकता या किसी वर्ग की आवृत्ति कैसे होती है।
मुझे लगता है कि शुरुआत में समझाना बेहतर है।
मान लीजिए आप कमांड चलाते हैं docker run hello-world। क्या होता है?
यह डॉकर सीएलआई को कॉल करता है जो डॉकर कमांड लेने के लिए जिम्मेदार है और डॉकर सर्वर कमांड को कॉल करने के लिए बदल देता है। जैसे ही Docker सर्वर को इमेज चलाने के लिए एक कमांड मिलती है , यह मौसम की जांच करता है कि इमेज कैश इस तरह के नाम के साथ एक इमेज रखती है ।
मान लीजिए कि हैलो-वर्ल्ड मौजूद नहीं है। Docker सर्वर Docker Hub में जाता है (Docker Hub छवियों का एक नि: शुल्क भंडार है) और पूछता है, हे हब, क्या आपके पास एक छवि है hello-world? हब प्रतिक्रियाएं - हां, मैं करता हूं। तो मुझे दे दो, कृपया। और डाउनलोड प्रक्रिया शुरू होती है। जैसे ही Docker इमेज डाउनलोड हो जाती है, Docker सर्वर इसे इमेज कैश में डाल देता है ।
तो इससे पहले कि हम यह बताएं कि डॉकरों की छवियां और डॉकटर कंटेनर क्या हैं, चलो अपने कंप्यूटर पर ऑपरेशन सिस्टम के बारे में एक परिचय के साथ शुरू करते हैं और सॉफ्टवेयर कैसे चलाते हैं।
जब आप चलाते हैं, उदाहरण के लिए, आपके कंप्यूटर पर क्रोम, यह ऑपरेटिंग सिस्टम को कॉल करता है, ऑपरेटिंग सिस्टम खुद कर्नेल को कॉल करता है और पूछता है, अरे मैं इस प्रोग्राम को चलाना चाहता हूं। कर्नेल आपकी हार्ड डिस्क से फ़ाइलों को चलाने का प्रबंधन करता है।
अब कल्पना करें कि आपके पास दो कार्यक्रम हैं, Chrome और Node.js. Chrome को चलाने के लिए Python संस्करण 2 और Node.js को चलाने के लिए Python संस्करण 3 की आवश्यकता है। यदि आपने केवल अपने कंप्यूटर पर Python v2 स्थापित किया है, तो केवल Chrome चलाया जाएगा।
दोनों ही मामलों में काम करने के लिए, किसी तरह आपको नामस्थान के रूप में ज्ञात ऑपरेटिंग सिस्टम सुविधा का उपयोग करने की आवश्यकता होती है। एक नाम स्थान एक विशेषता है जो आपको प्रक्रियाओं, हार्ड ड्राइव, नेटवर्क, उपयोगकर्ताओं, होस्टनाम और इतने पर अलग करने का अवसर देता है।
इसलिए, जब हम एक छवि के बारे में बात करते हैं तो हम वास्तव में एक फाइल सिस्टम स्नैपशॉट के बारे में बात करते हैं। एक छवि एक भौतिक फ़ाइल है जिसमें विशिष्ट बनाने के लिए निर्देश और मेटाडेटा शामिल हैं कंटेनर शामिल हैं । कंटेनर अपने आप में एक का एक उदाहरण है छवि ; यह नेमस्पेसिंग का उपयोग करके हार्ड ड्राइव को अलग करता है जो केवल इस कंटेनर के लिए उपलब्ध है । तो एक कंटेनर एक प्रक्रिया या प्रक्रियाओं का समूह है जो विभिन्न संसाधनों को समूह को सौंपा गया है।
एक डॉकर छवि एप्लिकेशन और पर्यावरण को चलाने के लिए एप्लिकेशन द्वारा आवश्यक पैक करती है, और एक कंटेनर छवि का एक चालू उदाहरण है।
छवियाँ डॉकर का पैकिंग हिस्सा हैं, जो "स्रोत कोड" या "प्रोग्राम" के अनुरूप हैं। कंटेनर डॉकर का निष्पादन भाग हैं, जो एक "प्रक्रिया" के अनुरूप है।
प्रश्न में, केवल "प्रोग्राम" भाग को संदर्भित किया जाता है और यह छवि है। डॉकर का "चल रहा" भाग कंटेनर है। जब एक कंटेनर चलाया जाता है और उसमें बदलाव किए जाते हैं, तो ऐसा लगता है कि यह प्रक्रिया अपने स्वयं के स्रोत कोड में बदलाव करती है और इसे नई छवि के रूप में सहेजती है।
प्रोग्रामिंग पहलू में,
छवि स्रोत कोड है।
जब स्रोत कोड संकलित और निर्माण किया जाता है, तो इसे एक एप्लिकेशन कहा जाता है।
इसके समान "जब छवि के लिए एक उदाहरण बनाया जाता है", तो इसे " कंटेनर " कहा जाता है ।
एक छवि एक कंटेनर का "स्नैपशॉट" है । आप एक कंटेनर (नए "स्नैपशॉट") से छवियां बना सकते हैं, और आप एक छवि से नए कंटेनर भी शुरू कर सकते हैं ("स्नैपशॉट" को तुरंत टाइप करें)।
उदाहरण के लिए, आप एक आधार छवि से एक नए कंटेनर को तुरंत निकाल सकते हैं, कंटेनर में कुछ कमांड चला सकते हैं, और फिर एक नई छवि के रूप में स्नैपशॉट कर सकते हैं। फिर आप उस नई छवि से 100 कंटेनर चला सकते हैं।
अन्य बातों पर विचार:
docker images।मैं यहाँ docker imagesऔर बीच के लापता भाग को भरना चाहूँगा containers। डॉकटर कंटेनरों के लिए एक यूनियन फाइल सिस्टम ( यूएफएस ) का उपयोग करता है , जो कई फाइल सिस्टम को पदानुक्रम में माउंट करने और एकल फाइलसिस्टम के रूप में प्रदर्शित करने की अनुमति देता है। छवि से फाइलसिस्टम को एक read-onlyपरत के रूप में माउंट किया गया है , और चल रहे कंटेनर में कोई भी बदलाव इसके read-writeऊपर स्थित एक परत पर बना है । इस वजह से, डॉकर को केवल रनिंग सिस्टम में किए गए परिवर्तनों को खोजने के लिए सबसे ऊपरी रीड-राइट परत को देखना होगा।
डमी प्रोग्रामिंग सादृश्यता के लिए, आप सोच सकते हैं कि डॉकर में एक अमूर्त ImageFactory है जो ImageFactories रखता है जो वे स्टोर से आते हैं ।
फिर एक बार जब आप उस इमेजफैक्ट से बाहर एक ऐप बनाना चाहते हैं, तो आपके पास एक नया कंटेनर होगा, और आप इसे अपनी इच्छानुसार संशोधित कर सकते हैं। DotNetImageFactory अपरिवर्तनीय होगा, क्योंकि यह एक अमूर्त कारखाना वर्ग के रूप में कार्य करता है, जहाँ यह केवल आपकी इच्छा के उदाहरण देता है।
IContainer newDotNetApp = ImageFactory.DotNetImageFactory.CreateNew(appOptions);
newDotNetApp.ChangeDescription("I am making changes on this instance");
newDotNetApp.Run();
संक्षेप में:
कंटेनर एक कर्नेल में एक विभाजन (आभासी) है जो एक सामान्य ओएस साझा करता है और एक छवि (डॉकर छवि) चलाता है।
एक कंटेनर एक स्व-टिकाऊ अनुप्रयोग है जिसमें कोड चलाने के लिए पैकेज और सभी आवश्यक निर्भरताएँ एक साथ होंगी।
एक डॉक कंटेनर एक छवि का एक उदाहरण चल रहा है। आप एक कार्यक्रम के साथ एक छवि और एक प्रक्रिया के साथ एक कंटेनर से संबंधित कर सकते हैं :)