कुबेरनेट्स गाइड, भाग 1: अनुप्रयोग, माइक्रोसर्विस, और कंटेनर

हमारे अनुरोध पर, हैबर ने कुबेरनेट्स हब बनाया और हम इसमें पहला प्रकाशन पोस्ट करने के लिए प्रसन्न हैं। सदस्यता लें!

कुबेरनेट्स आसान है। बैंक मुझे इस क्षेत्र में काम के लिए बहुत सारे पैसे क्यों देते हैं, जबकि कोई भी इस तकनीक को केवल कुछ घंटों में मास्टर कर सकता है?



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

कुबेरनेट्स के क्रमिक दृष्टिकोण के साथ ऐसा दृष्टिकोण, एक साधारण व्यक्ति को समझने की गहराई देगा ताकि यह समझने के लिए कि कुबेरनेट्स में सब कुछ कितना सरल है। Kubernetes, ज़ाहिर है, एक सरल तकनीक है, बशर्ते कि जो कोई भी इसे सीखना चाहता है वह जानता है कि इसका उपयोग कहाँ और कैसे किया जाता है।

अब, आगे की हलचल के बिना, चलो काम करते हैं और उस एप्लिकेशन के बारे में बात करते हैं जिसके साथ हम काम करेंगे।

प्रायोगिक अनुप्रयोग

हमारा आवेदन केवल एक ही कार्य करेगा। यह इनपुट के रूप में स्वीकार करता है, एक वाक्य, और फिर, पाठ विश्लेषण के साधनों का उपयोग करते हुए, इस वाक्य के भावना विश्लेषण का विश्लेषण करता है, एक निश्चित वस्तु के लिए वाक्य के लेखक के भावनात्मक दृष्टिकोण का अनुमान प्राप्त करता है।

यह इस एप्लिकेशन की मुख्य विंडो जैसा दिखता है।


पाठ भावना विश्लेषण के लिए वेब अनुप्रयोग

तकनीकी दृष्टिकोण से, एप्लिकेशन में तीन माइक्रोसर्विसेज शामिल हैं, जिनमें से प्रत्येक कार्य का एक निश्चित समूह हल करता है:

• SA-Frontend एक Nginx वेब सर्वर है जो रिएक्ट स्टैटिक फाइल्स परोसता है।
• SA-WebApp एक जावा-आधारित वेब अनुप्रयोग है जो फ्रंट-एंड से अनुरोधों को संसाधित करता है।
• SA-Logic एक पायथन एप्लिकेशन है जो टेक्स्ट सेंटिमेंट विश्लेषण करता है।

यह ध्यान रखना महत्वपूर्ण है कि माइक्रोसोर्सेज अलगाव में मौजूद नहीं हैं। वे "कर्तव्यों को अलग करने" के विचार को लागू करते हैं, लेकिन उन्हें, एक दूसरे के साथ बातचीत करने की आवश्यकता होती है।


अनुप्रयोग डेटा स्ट्रीम

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

1. ब्राउज़र सर्वर से index.html फ़ाइल का अनुरोध करता है (जो बदले में, प्रतिक्रिया एप्लिकेशन पैकेज डाउनलोड करता है)।
2. उपयोगकर्ता एप्लिकेशन के साथ इंटरैक्ट करता है, इससे स्प्रिंग पर आधारित वेब एप्लिकेशन पर कॉल आती है।
3. वेब एप्लिकेशन पायथन एप्लिकेशन को टेक्स्ट विश्लेषण के अनुरोध को पुनर्निर्देशित करता है।
4. पायथन एप्लिकेशन पाठ की टन क्षमता का विश्लेषण करता है और अनुरोध के जवाब के रूप में परिणाम देता है।
5. स्प्रिंग एप्लिकेशन रिएक्ट एप्लिकेशन को एक प्रतिक्रिया भेजता है (और यह बदले में, उपयोगकर्ता को पाठ विश्लेषण का परिणाम दिखाता है)।

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

एक स्थानीय कंप्यूटर पर एक microservice- आधारित अनुप्रयोग शुरू करना

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

स्थानीय विकास के लिए .Configuring प्रतिक्रिया

रिएक्ट एप्लिकेशन को चलाने के लिए, आपको अपने कंप्यूटर पर Node.js और NPM प्लेटफ़ॉर्म स्थापित करने की आवश्यकता है। यह सब स्थापित करने के बाद, टर्मिनल के माध्यम से sa-frontend प्रोजेक्ट फ़ोल्डर में जाएं और निम्न कमांड चलाएँ:

 npm install 

इस आदेश के निष्पादन के लिए धन्यवाद, प्रतिक्रिया-आवेदन की निर्भरता, प्रविष्टियां जिनके बारे में node_modules फ़ाइल में हैं, उन्हें node_modules फ़ोल्डर में लोड किया जाएगा। निर्भरताएँ एक ही फ़ोल्डर में डाउनलोड होने के बाद, निम्न कमांड चलाएँ:

 npm start 

वह सब है। अब रिएक्ट एप्लिकेशन चल रहा है, इसे एक्सेस करने के लिए ब्राउज़र में localhost:3000 एड्रेस पर जाकर प्राप्त किया जा सकता है। आप उसके कोड में कुछ बदल सकते हैं। आप तुरंत ब्राउज़र में इन परिवर्तनों का प्रभाव देखेंगे। मॉड्यूल के तथाकथित "गर्म" प्रतिस्थापन के लिए यह संभव है। इसके लिए धन्यवाद, फ्रंट-एंड डेवलपमेंट एक सरल और सुखद कार्य में बदल जाता है।

उत्पादन के लिए उत्पादन के लिए एक प्रतिक्रिया आवेदन की ationPreparation

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

रिएक्ट एप्लिकेशन का निर्माण करने के लिए, फिर से, टर्मिनल का उपयोग करके, sa-frontend फ़ोल्डर में जाएं और निम्न कमांड चलाएं:

 npm run build 

यह प्रोजेक्ट फ़ोल्डर में एक build डायरेक्टरी बनाएगा। इसमें रिएक्ट एप्लिकेशन के काम करने के लिए जरूरी सभी स्टैटिक फाइलें होंगी।

X Nginx टूल्स का उपयोग करके स्थिर फाइल्स को सेव करना

सबसे पहले आपको Nginx वेब सर्वर को स्थापित करने और चलाने की आवश्यकता है। यहां आप इसे डाउनलोड कर सकते हैं और इंस्टॉलेशन और स्टार्टअप निर्देश पा सकते हैं। फिर आपको sa-frontend/build folder की सामग्री को [your_nginx_installation_dir]/html फ़ोल्डर में कॉपी करने की आवश्यकता है।

इस दृष्टिकोण के साथ, प्रतिक्रिया आवेदन के निर्माण के दौरान उत्पन्न index.html फ़ाइल [your_nginx_installation_dir]/html/index.html पर उपलब्ध होगी। यह वह फ़ाइल है जो डिफ़ॉल्ट रूप से, Nginx सर्वर इसे एक्सेस करते समय जारी करता है। सर्वर को पोर्ट 80 पर सुनने के लिए कॉन्फ़िगर किया गया है, लेकिन आप इसे जिस तरह से फाइल [your_nginx_installation_dir]/conf/nginx.conf संपादित करके कॉन्फ़िगर कर सकते हैं।

अब अपना ब्राउज़र खोलें और localhost:80 । आपको रिएक्ट एप्लिकेशन पेज दिखाई देगा।


Nginx सर्वर द्वारा भेजा गया रिएक्ट एप्लिकेशन

यदि आप Type your sentence क्षेत्र में अब कुछ Type your sentence हैं और Send बटन पर क्लिक करते हैं, तो कुछ भी नहीं होगा। लेकिन, यदि आप कंसोल को देखते हैं, तो आप वहां त्रुटि संदेश देख सकते हैं। यह त्रुटियां कहां होती हैं, यह समझने के लिए, आइए एप्लिकेशन कोड का विश्लेषण करें।

Front फ्रंट-एंड एप्लीकेशन कोड का एनलिसिस

App.js फ़ाइल के कोड को देखने के बाद, हम यह देख सकते हैं कि Send बटन पर क्लिक करने से analyzeSentence() विधि का पता analyzeSentence() । इस विधि का कोड नीचे दिया गया है। उसी समय, इस तथ्य पर ध्यान दें कि प्रत्येक पंक्ति के लिए जिसके लिए फॉर्म # की टिप्पणी है, कोड के नीचे एक स्पष्टीकरण दिया गया है। उसी तरह, हम कोड के अन्य टुकड़ों को पार्स करेंगे।

 analyzeSentence() {   fetch('http://localhost:8080/sentiment', {  // #1       method: 'POST',       headers: {           'Content-Type': 'application/json'       },       body: JSON.stringify({                      sentence: this.textField.getValue()})// #2   })       .then(response => response.json())       .then(data => this.setState(data));  // #3 } 

1. वह URL जिस पर POST अनुरोध निष्पादित किया गया है। यह समझा जाता है कि इस पते में एक एप्लिकेशन है जो इस तरह के अनुरोधों की प्रतीक्षा कर रहा है।

2. आवेदन के लिए भेजा गया अनुरोध निकाय। यहाँ एक उदाहरण अनुरोध निकाय है:

 {   sentence: "I like yogobella!" } 

3. अनुरोध पर प्रतिक्रिया मिलने पर, घटक स्थिति अपडेट की जाती है। यह घटक को पुन: रेंडर करने का कारण बनता है। यदि हम डेटा प्राप्त करते हैं (अर्थात, एक JSON ऑब्जेक्ट जिसमें दर्ज डेटा और परिकलित पाठ स्कोर है), तो हम Polarity घटक को आउटपुट करेंगे, क्योंकि संबंधित स्थितियां मिलेंगी। इस तरह से हम घटक का वर्णन करते हैं:

 const polarityComponent = this.state.polarity !== undefined ?   <Polarity sentence={this.state.sentence}             polarity={this.state.polarity}/> :   null; 

लगता है कि कोड काफी अच्छा काम कर रहा है। यहाँ आखिर गलत क्या है? यदि आप यह मानते हैं कि जिस स्थान पर एप्लिकेशन POST अनुरोध भेजने का प्रयास कर रहा है, वहां अब तक ऐसा कुछ नहीं है जो इस अनुरोध को स्वीकार कर सके और संसाधित कर सके, तो आप बिल्कुल सही होंगे। अर्थात्, पता http://localhost:8080/sentiment पर आने वाले अनुरोधों को संसाधित करने के लिए, हमें स्प्रिंग पर आधारित एक वेब एप्लिकेशन चलाने की आवश्यकता है।


हमें एक स्प्रिंग एप्लिकेशन की आवश्यकता है जो POST अनुरोध को स्वीकार कर सके।

स्प्रिंग-आधारित वेब एप्लिकेशन सेट करें

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

File एप्लिकेशन को जार फ़ाइल में बदलना

जाओ, टर्मिनल का उपयोग करके, sa-webapp फ़ोल्डर में और निम्न कमांड दर्ज करें:

 mvn install 

इस कमांड को क्रियान्वित करने के बाद, target निर्देशिका sa-webapp फ़ोल्डर में बनाई जाएगी। sentiment-analysis-web-0.0.1-SNAPSHOT.jar द्वारा प्रस्तुत एक जार फ़ाइल में पैक किया गया एक जावा अनुप्रयोग होगा।

▍Start जावा अनुप्रयोग

target फ़ोल्डर में जाएं और निम्न कमांड के साथ एप्लिकेशन लॉन्च करें:

 java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar 

इस आदेश के निष्पादन के दौरान एक त्रुटि होगी। इसे ठीक करना शुरू करने के लिए, हम स्टैक ट्रेस डेटा में अपवाद जानकारी का विश्लेषण कर सकते हैं:

 Error creating bean with name 'sentimentController': Injection of autowired dependencies failed; nested exception is java.lang.IllegalArgumentException: Could not resolve placeholder 'sa.logic.api.url' in value "${sa.logic.api.url}" 

हमारे लिए, यहाँ सबसे महत्वपूर्ण बात sa.logic.api.url का अर्थ पता लगाने की sa.logic.api.url का sa.logic.api.url । उस कोड का विश्लेषण करते हैं जिसमें त्रुटि होती है।

Analysis जावा एप्लिकेशन कोड विश्लेषण

यहां कोड स्निपेट है जहां त्रुटि होती है।

 @CrossOrigin(origins = "*") @RestController public class SentimentController {   @Value("${sa.logic.api.url}")    // #1   private String saLogicApiUrl;   @PostMapping("/sentiment")   public SentimentDto sentimentAnalysis(       @RequestBody SentenceDto sentenceDto)   {       RestTemplate restTemplate = new RestTemplate();       return restTemplate.postForEntity(               saLogicApiUrl + "/analyse/sentiment",    // #2               sentenceDto, SentimentDto.class)               .getBody();   } } 

1. एस entimentController एक saLogicApiUrl क्षेत्र है। इसका मान sa.logic.api.url संपत्ति द्वारा निर्धारित किया गया है।
2. स्ट्रिंग saLogicApiUrl मान /analyse/sentiment साथ saLogicApiUrl । साथ में वे पाठ विश्लेषण करने वाले एक microservice तक पहुँचने के लिए एक पता बनाते हैं।

संपत्ति का मूल्य निर्धारित करें

वसंत में, संपत्ति के मूल्यों का मानक स्रोत application.properties है। application.properties फ़ाइल, जिसे sa-webapp/src/main/resources पर पाया जा सकता है। लेकिन इसका उपयोग संपत्ति मूल्यों को निर्धारित करने का एकमात्र तरीका नहीं है। आप निम्न की तरह एक कमांड के साथ ऐसा कर सकते हैं:

 java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar --sa.logic.api.url=WHAT.IS.THE.SA.LOGIC.API.URL 

इस संपत्ति का मूल्य हमारे पायथन एप्लिकेशन के पते को इंगित करना चाहिए।

इसे कॉन्फ़िगर करके, हम स्प्रिंग वेब एप्लिकेशन को बताते हैं जहां उसे टेक्स्ट विश्लेषण अनुरोधों को निष्पादित करने के लिए जाना पड़ता है।

हमारे जीवन को जटिल नहीं करने के लिए, हम तय करते हैं कि पायथन एप्लिकेशन localhost:5000 पर उपलब्ध होगा और इसके बारे में न भूलने की कोशिश करेंगे। नतीजतन, स्प्रिंग एप्लिकेशन लॉन्च करने की कमांड इस तरह दिखाई देगी:

 java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar --sa.logic.api.url=http://localhost:5000 

हमारे सिस्टम में पायथन एप्लिकेशन का अभाव है

अब हमें सिर्फ पायथन एप्लिकेशन को शुरू करना है और सिस्टम उम्मीद के मुताबिक काम करेगा।

On एक अजगर आवेदन की पुष्टि करें

पायथन एप्लिकेशन को चलाने के लिए, आपके पास पायथन 3 और पिप स्थापित होना चाहिए, और आपको उचित वातावरण चर को सही ढंग से सेट करने की आवश्यकता है।

Depend आश्रितों की स्थापना

प्रोजेक्ट फ़ोल्डर sa-logic/sa और निम्न कमांड चलाएं:

 python -m pip install -r requirements.txt python -m textblob.download_corpora 

ApplicationStart आवेदन

निर्भरता स्थापित करने के बाद, हम एप्लिकेशन लॉन्च करने के लिए तैयार हैं:

 python sentiment_analysis.py 

इस आदेश को निष्पादित करने के बाद, हमें निम्नलिखित के बारे में सूचित किया जाएगा:

 * Running on http://0.0.0.0:5000/ (Press CTRL+C to quit) 

इसका मतलब है कि एप्लिकेशन चल रहा है और localhost:5000/ पर अनुरोधों की प्रतीक्षा कर रहा है localhost:5000/

▍ कोड अनुसंधान

यह समझने के लिए कि यह कैसे अनुरोधों का जवाब देता है, पायथन एप्लिकेशन कोड पर विचार करें:

 from textblob import TextBlob from flask import Flask, request, jsonify app = Flask(__name__)                                   #1 @app.route("/analyse/sentiment", methods=['POST'])      #2 def analyse_sentiment():   sentence = request.get_json()['sentence']           #3   polarity = TextBlob(sentence).sentences[0].polarity #4   return jsonify(                                     #5       sentence=sentence,       polarity=polarity   ) if __name__ == '__main__':   app.run(host='0.0.0.0', port=5000)                #6 

1. एक Flask ऑब्जेक्ट को इनिशियलाइज़ करना।
2. इसके लिए POST अनुरोध निष्पादित करने के लिए पता सेट करना।
3. अनुरोध निकाय से sentence संपत्ति को वापस लेना।
4. अनाम TextBlob ऑब्जेक्ट को प्रारंभ करना और अनुरोध निकाय में पहले वाक्य के लिए polarity मान प्राप्त करना (हमारे मामले में, यह विश्लेषण के लिए पारित एकमात्र वाक्य है)।
5. प्रतिक्रिया की वापसी, जिसके शरीर में प्रस्ताव का पाठ और इसके लिए गणना की गई polarity सूचकांक शामिल हैं।
6. फ्लास्क एप्लिकेशन लॉन्च करना, जो 0.0.0.0:5000 ( 0.0.0.0:5000 पर उपलब्ध होगा (आप इसे एक 0.0.0.0:5000 localhost:5000 निर्माण का उपयोग करके भी एक्सेस कर सकते हैं)।

अब एप्लिकेशन बनाने वाले माइक्रोसर्विसेज चल रहे हैं। वे एक दूसरे के साथ बातचीत करने के लिए कॉन्फ़िगर किए गए हैं। यह वही है जो काम के इस चरण में एप्लिकेशन आरेख जैसा दिखता है।


आवेदन करने वाले सभी माइक्रोसर्विसेज को स्वस्थ अवस्था में लाया जाता है।

अब, जारी रखने से पहले, ब्राउज़र में रिएक्ट एप्लिकेशन खोलें और इसका उपयोग करके कुछ सुझाव का विश्लेषण करने का प्रयास करें। यदि सब कुछ सही ढंग से किया गया है, तो Send बटन पर क्लिक करने के बाद, आपको टेक्स्ट बॉक्स के तहत विश्लेषण परिणाम दिखाई देंगे।

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

डॉकटर कंटेनर

Kubernetes , कंटेनरीकृत अनुप्रयोगों की तैनाती, स्केलिंग और प्रबंधन को स्वचालित करने के लिए एक प्रणाली है। इसे "कंटेनर ऑर्केस्ट्रेटर" भी कहा जाता है। यदि कुबेरनेट कंटेनर के साथ काम करते हैं, तो हमें इस प्रणाली का उपयोग करने से पहले इन कंटेनरों का अधिग्रहण करना चाहिए। लेकिन पहले, आइए बात करते हैं कि कंटेनर क्या हैं। डॉकर के लिए प्रलेखन में क्या पाया जा सकता है, इस सवाल का शायद सबसे अच्छा जवाब:

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

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

कंटेनरों की विशेषताओं का पता लगाने और अनुप्रयोगों को लॉन्च करने के अन्य तरीकों से उनकी तुलना करने के लिए, वर्चुअल मशीन और कंटेनर का उपयोग करके रिएक्ट एप्लिकेशन की सेवा करने के एक उदाहरण पर विचार करें।

वर्चुअल मशीन का उपयोग करके रिएक्ट एप्लिकेशन स्टैटिक फाइल्स को सॉल्व करना

आभासी मशीनों के माध्यम से स्थिर फ़ाइलों के रखरखाव को व्यवस्थित करने की कोशिश करते हुए, हम निम्नलिखित नुकसान का सामना करेंगे:

1. संसाधनों का अकुशल उपयोग, क्योंकि प्रत्येक वर्चुअल मशीन एक पूर्ण विकसित ऑपरेटिंग सिस्टम है।
2. मंच पर निर्भर एक निश्चित स्थानीय कंप्यूटर पर जो काम करता है वह किसी प्रोडक्शन सर्वर पर काम नहीं कर सकता।
3. वर्चुअल मशीन-आधारित समाधान का धीमा और संसाधन-गहन स्केलिंग।

वर्चुअल मशीन पर चलने वाला Nginx static server वेब सर्वर

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

1. संसाधनों का कुशल उपयोग: डॉकर का उपयोग कर ऑपरेटिंग सिस्टम के साथ काम करना।
2. मंच की स्वतंत्रता। एक कंटेनर जो एक डेवलपर अपने कंप्यूटर पर चला सकता है वह कहीं भी काम करेगा।
3. छवि परतों के उपयोग के माध्यम से हल्के तैनाती।

एक कंटेनर में चलने वाला नंगेक्स स्टैटिक सर्वर वेब सर्वर

हमने केवल कुछ बिंदुओं पर आभासी मशीनों और कंटेनरों की तुलना की, लेकिन यह भी कंटेनरों की ताकत को महसूस करने के लिए पर्याप्त है। यहां डॉकटर कंटेनरों के बारे में अधिक जानकारी प्राप्त करें।

▍ रिएक्ट एप्लिकेशन के लिए कंटेनर इमेज को असेंबल करना

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

इससे पहले कि हम Dockerfile साथ काम करने के लिए नीचे Dockerfile , हमें याद रखें कि हमने Nginx सर्वर पर अपलोड करने के लिए रिएक्ट एप्लिकेशन फ़ाइलों को तैयार करने के लिए क्या किया था:

1. रिएक्ट एप्लिकेशन पैकेज ( npm run build ) बनाएं।
2. Nginx सर्वर शुरू करना।
3. build निर्देशिका की सामग्री को sa-frontend प्रोजेक्ट फ़ोल्डर से nginx/html सर्वर फ़ोल्डर में कॉपी करें।

नीचे आप कंटेनर बनाने और स्थानीय कंप्यूटर पर किए गए उपरोक्त कार्यों के बीच समानताएं देख सकते हैं।

Front SA-Frontend के लिए एक Dockerfile बनाना

SA-Frontend एप्लिकेशन के लिए जो निर्देश Dockerfile में Dockerfile होंगे, उनमें केवल दो कमांड होंगे। तथ्य यह है कि Nginx विकास टीम ने Nginx के लिए एक मूल छवि तैयार की, जिसका उपयोग हम अपनी छवि बनाने के लिए करेंगे। यहाँ दो चरणों का वर्णन करने की आवश्यकता है:

1. छवि का आधार आपको नाइजेक्स छवि बनाने की आवश्यकता है।
2. sa-frontend/build फ़ोल्डर की सामग्री को nginx/html छवि फ़ोल्डर में कॉपी किया जाना चाहिए।

यदि हम इस विवरण से Dockerfile में Dockerfile , तो यह इस तरह दिखेगा:

 FROM nginx COPY build /usr/share/nginx/html 

जैसा कि आप देख सकते हैं, यहां सब कुछ बहुत सरल है, जबकि फ़ाइल की सामग्री भी काफी पठनीय और समझने योग्य है। यह फ़ाइल उस सिस्टम को बताती है जो nginx छवि को हर उस चीज़ के साथ लेता है जो उसके पास पहले से ही है और build निर्देशिका की सामग्री को nginx/html निर्देशिका में कॉपी करता है।

यहाँ आपके पास एक प्रश्न हो सकता है कि मैं बिलकुल सही जानता हूं कि build फोल्डर की फाइलों को कहां से कॉपी किया जाता है, यानी पथ /usr/share/nginx/html कहां से आया है। वास्तव में, और जटिल कुछ भी नहीं है। तथ्य यह है कि प्रासंगिक जानकारी छवि के विवरण में पाई जा सकती है।

Image एक छवि बनाना और उसे रिपॉजिटरी में अपलोड करना

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

1. डॉकर स्थापित करें।
2. डॉकर हब वेबसाइट पर रजिस्टर करें।
3. टर्मिनल में निम्नलिखित कमांड चलाकर खाते में प्रवेश करें:
   
   

    docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD" 

अब आपको sa-frontend डायरेक्टरी में जाने के लिए टर्मिनल का उपयोग करने की आवश्यकता है और वहां निम्नलिखित कमांड को चलाना होगा:

 docker build -f Dockerfile -t $DOCKER_USER_ID/sentiment-analysis-frontend . 

इसके बाद इसी तरह के आदेशों में, डॉकर हब पर आपके उपयोगकर्ता नाम के साथ $DOCKER_USER_ID को $DOCKER_USER_ID आवश्यकता है। उदाहरण के लिए, कमांड का यह भाग इस तरह दिख सकता है: rinormaloku/sentiment-analysis-frontend ।

उसी समय, इस कमांड को -f Dockerfile से -f Dockerfile को हटाकर छोटा किया जा सकता है, क्योंकि यह फ़ाइल उस फ़ोल्डर में पहले से मौजूद है जिसमें हम इस कमांड को निष्पादित करते हैं।

तैयार छवि को रिपॉजिटरी में भेजने के लिए, हमें निम्नलिखित कमांड की आवश्यकता है:

 docker push $DOCKER_USER_ID/sentiment-analysis-frontend 

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

▍Start कंटेनर

अब कोई भी $DOCKER_USER_ID/sentiment-analysis-frontend रूप में जानी जाने वाली छवि को डाउनलोड और चला सकता है। ऐसा करने के लिए, आपको निम्न अनुक्रम चलाने की आवश्यकता है:

 docker pull $DOCKER_USER_ID/sentiment-analysis-frontend docker run -d -p 80:80 $DOCKER_USER_ID/sentiment-analysis-frontend 

अब कंटेनर लॉन्च किया गया है, और हम काम करना जारी रख सकते हैं, जिससे हमें अन्य छवियों की आवश्यकता होती है। लेकिन, जारी रखने से पहले, आइए 80:80 निर्माण को देखें, जो छवि लॉन्च कमांड में पाया जाता है और समझ से बाहर हो सकता है।

• पहला नंबर 80 होस्ट पोर्ट नंबर (यानी स्थानीय कंप्यूटर) है।
• दूसरा नंबर 80 कंटेनर का बंदरगाह है, जिसमें अनुरोध को पुनर्निर्देशित किया जाना चाहिए।

निम्नलिखित दृष्टांत पर विचार करें।


पोर्ट अग्रेषण

सिस्टम <hostPort> पोर्ट से <hostPort> पोर्ट पर रिडायरेक्ट करता है। यही है, कंटेनर के 80 पोर्ट 80 कंप्यूटर के पोर्ट 80 तक पहुंच को पुनर्निर्देशित किया 80 ।

चूंकि पोर्ट 80 स्थानीय कंप्यूटर पर खुला है, इसलिए आप इस कंप्यूटर से localhost:80 पर एप्लिकेशन को एक्सेस कर सकते हैं। यदि आपका सिस्टम डॉकर का समर्थन नहीं करता है, तो आप एप्लिकेशन को डॉकर वर्चुअल मशीन पर चला सकते हैं, जिसका पता <docker-machine ip>:80 जैसा लगेगा। डॉकर वर्चुअल मशीन के आईपी पते का पता लगाने के लिए, आप docker-machine ip उपयोग कर सकते हैं।

इस स्तर पर, फ्रंटएंड एप्लिकेशन कंटेनर को सफलतापूर्वक लॉन्च करने के बाद, आपको ब्राउज़र में इसके पृष्ठ को खोलने में सक्षम होना चाहिए।

▍ .dockerignore फ़ाइल

SA-Frontend एप्लिकेशन की छवि एकत्र करना, हम देख सकते हैं कि यह प्रक्रिया बेहद धीमी है। यह इस तथ्य के कारण होता है कि छवि का निर्माण संदर्भ डॉकर डेमन को भेजा जाना चाहिए। बिल्ड संदर्भ का प्रतिनिधित्व करने वाली निर्देशिका docker build के अंतिम तर्क द्वारा निर्दिष्ट की जाती है। हमारे मामले में, इस आदेश के अंत में एक अवधि है। यह निम्न संरचना में विधानसभा संदर्भ में शामिल किया जा रहा है:

 sa-frontend: |   .dockerignore |   Dockerfile |   package.json |   README.md +---build +---node_modules +---public \---src 

लेकिन यहां मौजूद सभी फोल्डर में, हमें केवल build फोल्डर की जरूरत है। किसी और चीज को डाउनलोड करना समय की बर्बादी है। डॉकर को यह बताकर बिल्ड किया जा सकता है कि कौन सी निर्देशिका को अनदेखा करना है। ऐसा करने के लिए हमें एक .dockerignore फ़ाइल की आवश्यकता है। यदि आप .gitignore फ़ाइल से परिचित हैं, तो इस फ़ाइल की संरचना निश्चित रूप से परिचित होगी। यह उन निर्देशिकाओं को सूचीबद्ध करता है जो छवि असेंबली प्रणाली की अनदेखी कर सकती हैं। हमारे मामले में, इस फ़ाइल की सामग्री इस तरह दिखती है:

 node_modules src public 

.dockerignore फ़ाइल .dockerignore के समान फ़ोल्डर में होनी चाहिए। अब इमेज असेंबल करने में कुछ सेकंड का समय लगेगा।

अब जावा एप्लिकेशन पर एक नज़र डालते हैं।

▍ Java-

, . .

Dockerfile , sa-webapp . , , ENV EXPOSE :

 ENV SA_LOGIC_API_URL http://localhost:5000 … EXPOSE 8080 

ENV Docker. , URL API , .

EXPOSE Docker , . . , Dockerfile SA-Frontend . , , , Dockerfile .

, . — README.md sa-webapp .

▍ Python-

Dockerfile sa-logic , . , , , README.md sa-logic .

▍

- , ? . .

1. sa-logic 5050 :
   
   

    docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic 

2. sa-webapp 8080 . , , Python- Java-, SA_LOGIC_API_URL :
   
   

    $ docker run -d -p 8080:8080 -e SA_LOGIC_API_URL='http://<container_ip or docker machine ip>:5000' $DOCKER_USER_ID/sentiment-analysis-web-app 

, IP- Docker — README .

sa-frontend :

 docker run -d -p 80:80 $DOCKER_USER_ID/sentiment-analysis-frontend 

, localhost:80 .

, sa-webapp , Docker, App.js sa-frontend , IP- analyzeSentence() , . .

.

: Kubernetes?

Dockerfile , , Docker. , , .dockerignore . Docker. , Kubernetes. . :
, - . . , sa-webapp sa-logic . , ?