🥇कुबेरनेट्स ट्यूटोरियल भाग 1: एप्लिकेशन, माइक्रोसर्विसेज और कंटेनर

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

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

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

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

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

प्रायोगिक ऐप

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

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

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

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

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

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

एप्लिकेशन में डेटा प्रवाहित होता है

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

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

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

स्थानीय मशीन पर माइक्रोसर्विसेज पर आधारित एप्लिकेशन चलाना

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

▍स्थानीय विकास के लिए रिएक्ट की स्थापना

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

npm install

इस कमांड को फोल्डर में निष्पादित करके node_modules रिएक्ट एप्लिकेशन की निर्भरताएँ लोड की जाएंगी, जिनके रिकॉर्ड फ़ाइल में हैं package.json. निर्भरताओं को उसी फ़ोल्डर में डाउनलोड करने के बाद, निम्न आदेश चलाएँ:

npm start

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

▍उत्पादन के लिए एक रिएक्ट ऐप तैयार करना

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

रिएक्ट ऐप बनाने के लिए, फिर से टर्मिनल का उपयोग करके फ़ोल्डर पर नेविगेट करें sa-frontend और निम्न आदेश चलाएँ:

npm run build

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

▍Nginx के साथ स्थिर फ़ाइलें परोसना

सबसे पहले आपको Nginx वेब सर्वर को इंस्टॉल और चलाना होगा। यहां आप इसे डाउनलोड कर सकते हैं और इसे स्थापित करने और चलाने के लिए निर्देश पा सकते हैं। फिर आपको फ़ोल्डर की सामग्री को कॉपी करना होगा sa-frontend/build एक फ़ोल्डर में [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 और बटन दबाएँ Send - कुछ न होगा। लेकिन, यदि आप कंसोल को देखें, तो आप वहां त्रुटि संदेश देख सकते हैं। यह समझने के लिए कि ये त्रुटियाँ कहाँ होती हैं, आइए एप्लिकेशन कोड का विश्लेषण करें।

फ्रंट-एंड एप्लिकेशन के कोड का विश्लेषण

फ़ाइल के कोड को देख रहे हैं App.js, हम इसे बटन पर क्लिक करके देख सकते हैं Send एक विधि को कॉल करता है 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 और Maven और उचित रूप से कॉन्फ़िगर किए गए पर्यावरण चर की आवश्यकता है। यह सब इंस्टॉल करने के बाद, आप हमारे प्रोजेक्ट पर काम करना जारी रख सकते हैं।

▍एप्लिकेशन को जार फ़ाइल में पैक करना

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

mvn install

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

▍जावा एप्लिकेशन लॉन्च करना

फोल्डर पर जाएं 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. आइए उस कोड का विश्लेषण करें जहां त्रुटि होती है।

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

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

@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();
    }
}

एस मेंentimentController वहाँ एक मैदान है saLogicApiUrl. इसका मूल्य संपत्ति द्वारा निर्धारित किया जाता है sa.logic.api.url.
रेखा saLogicApiUrl मूल्य के साथ जुड़ता है /analyse/sentiment. साथ में वे पाठ विश्लेषण करने वाली माइक्रोसर्विस को कॉल करने के लिए एक पता बनाते हैं।

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

स्प्रिंग में, संपत्ति मूल्यों का डिफ़ॉल्ट स्रोत एक फ़ाइल है 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

हमारे सिस्टम में पाइथॉन एप्लिकेशन की कमी है

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

▍पायथन एप्लिकेशन सेट करना

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

▍निर्भरताएं स्थापित करें

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

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

▍ऐप लॉन्च

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

python sentiment_analysis.py

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

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

इसका मतलब है कि एप्लिकेशन चल रहा है और अनुरोधों की प्रतीक्षा कर रहा है 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

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

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

एप्लिकेशन बनाने वाली सभी माइक्रोसर्विसेज को स्वस्थ स्थिति में लाया जाता है

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

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

डोकर कंटेनर

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

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

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

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

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

वर्चुअल मशीनों का उपयोग करके स्थिर फ़ाइलों के रखरखाव को व्यवस्थित करने का प्रयास करते समय, हमें निम्नलिखित नुकसान का सामना करना पड़ेगा:

संसाधनों का अकुशल उपयोग, क्योंकि प्रत्येक वर्चुअल मशीन एक पूर्ण ऑपरेटिंग सिस्टम है।
प्लेटफ़ॉर्म निर्भरता. कुछ स्थानीय कंप्यूटर पर जो काम करता है वह उत्पादन सर्वर पर काम नहीं कर सकता है।
वर्चुअल मशीन समाधान की धीमी और संसाधन गहन स्केलिंग।

Nginx वेब सर्वर वर्चुअल मशीन में चल रही स्थिर फ़ाइलों की सेवा करता है

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

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

Nginx वेब सर्वर एक कंटेनर में चल रही स्थिर फ़ाइलों की सेवा करता है

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

▍रिएक्ट ऐप के लिए एक कंटेनर छवि बनाना

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

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

एक रिएक्ट ऐप पैकेज बनाना (npm run build).
Nginx सर्वर प्रारंभ करना.
किसी निर्देशिका की सामग्री की प्रतिलिपि बनाना build प्रोजेक्ट फ़ोल्डर से sa-frontend सर्वर फ़ोल्डर में nginx/html.

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

▍एसए-फ्रंटेंड एप्लिकेशन के लिए डॉकरफाइल तैयार करना

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

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

यदि हम इस विवरण से फ़ाइल की ओर जाते हैं Dockerfile, तो यह इस तरह दिखेगा:

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

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

यहां आपके मन में यह सवाल हो सकता है कि मुझे कैसे पता चलेगा कि फ़ोल्डर से फ़ाइलों को वास्तव में कहां कॉपी करना है build, यानी रास्ता कहां से आया /usr/share/nginx/html. दरअसल, यहां कुछ भी जटिल नहीं है। तथ्य यह है कि प्रासंगिक जानकारी यहां पाई जा सकती है विवरण छवि।

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

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

स्थापित करने के लिए डाक में काम करनेवाला मज़दूर.
डॉकर हब साइट पर रजिस्टर करें।
टर्मिनल में निम्नलिखित कमांड चलाकर अपने खाते में लॉग इन करें:
```
docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
```

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

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

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

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

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

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

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

▍एक कंटेनर शुरू करना

अब कोई भी उस छवि को डाउनलोड और चला सकता है जिसे कहा जाता है $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> प्रति पोर्ट <containerPort>. यानी पोर्ट तक पहुंच 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 फ़ाइल के समान फ़ोल्डर में होना चाहिए Dockerfile. अब छवि के संयोजन में कुछ सेकंड लगेंगे।

आइए अब जावा एप्लिकेशन के लिए छवि से निपटें।

▍जावा एप्लिकेशन के लिए एक कंटेनर छवि बनाना

आप जानते हैं क्या, और आपने कंटेनर छवियां बनाने के लिए आवश्यक सभी चीजें पहले ही सीख ली हैं। इसलिए यह भाग बहुत छोटा होगा.

फ़ाइल खोलें Dockerfile, जो प्रोजेक्ट फ़ोल्डर में स्थित है sa-webapp. यदि आप इस फ़ाइल का पाठ पढ़ते हैं, तो इसमें आपको केवल दो नए निर्माण मिलेंगे जो कीवर्ड से शुरू होते हैं ENV и EXPOSE:

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

कीवर्ड ENV आपको डॉकर कंटेनरों के अंदर पर्यावरण चर घोषित करने की अनुमति देता है। विशेष रूप से, हमारे मामले में, यह आपको टेक्स्ट विश्लेषण करने वाले एप्लिकेशन के एपीआई तक पहुंचने के लिए एक यूआरएल सेट करने की अनुमति देता है।

कीवर्ड EXPOSE आपको डॉकर को पोर्ट खोलने के लिए कहने की अनुमति देता है। एप्लिकेशन के साथ काम करते समय हम इस पोर्ट का उपयोग करने जा रहे हैं। यहां आप उसे देख सकते हैं Dockerfile आवेदन के लिए SA-Frontend ऐसा कोई आदेश नहीं है. यह केवल दस्तावेज़ीकरण प्रयोजनों के लिए है, दूसरे शब्दों में, यह रचना पाठक के लिए है Dockerfile.

छवि बनाना और उसे रिपॉजिटरी में भेजना बिल्कुल पिछले उदाहरण जैसा दिखता है। यदि आप अभी तक अपनी क्षमताओं में आश्वस्त नहीं हैं, तो संबंधित आदेश फ़ाइल में पाए जा सकते हैं README.md फ़ोल्डर में sa-webapp.

▍पायथन एप्लिकेशन के लिए एक कंटेनर छवि बनाना

यदि आप फ़ाइल की सामग्री पर एक नज़र डालें Dockerfile फ़ोल्डर में sa-logicआपको वहां कुछ भी नया नहीं मिलेगा. छवि बनाने और उसे रिपॉजिटरी में भेजने के आदेश आपको पहले से ही परिचित होने चाहिए, लेकिन, हमारे अन्य अनुप्रयोगों की तरह, वे फ़ाइल में पाए जा सकते हैं README.md फ़ोल्डर में sa-logic.

▍कंटेनरीकृत अनुप्रयोगों का परीक्षण

क्या आप किसी ऐसी चीज़ पर भरोसा कर सकते हैं जिसका आपने परीक्षण नहीं किया है? मैं भी नहीं कर सकता. आइए हमारे कंटेनरों का परीक्षण करें।

आइए एप्लिकेशन कंटेनर शुरू करें sa-logic और इसे पोर्ट पर सुनने के लिए कॉन्फ़िगर करें 5050:
```
docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic
```
आइए एप्लिकेशन कंटेनर शुरू करें sa-webapp और इसे पोर्ट पर सुनने के लिए कॉन्फ़िगर करें 8080. इसके अलावा, हमें उस पोर्ट को सेट करने की आवश्यकता है जिस पर पायथन एप्लिकेशन पर्यावरण चर को पुन: असाइन करके जावा एप्लिकेशन के अनुरोधों को सुनेगा। 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
```

किसी कंटेनर या डॉकर वीएम का आईपी पता कैसे पता करें, यह जानने के लिए फ़ाइल देखें README.

आइए एप्लिकेशन कंटेनर शुरू करें sa-frontend:

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

अब सब कुछ ब्राउज़र में पते पर नेविगेट करने के लिए तैयार है localhost:80 और ऐप का परीक्षण करें।

कृपया ध्यान दें कि यदि आप पोर्ट बदलते हैं sa-webapp, या यदि आप डॉकर वीएम चला रहे हैं, तो आपको फ़ाइल को संपादित करना होगा App.js एक फ़ोल्डर से sa-frontendविधि में आईपी पता या पोर्ट नंबर बदलकर analyzeSentence()अप्रचलित डेटा के स्थान पर वर्तमान जानकारी को प्रतिस्थापित करके। उसके बाद, आपको छवि को फिर से इकट्ठा करना होगा और उसका उपयोग करना होगा।

हमारा एप्लिकेशन आरेख अब इस तरह दिखता है।

माइक्रोसर्विसेज कंटेनरों में चलती हैं

सारांश: हमें कुबेरनेट्स क्लस्टर की आवश्यकता क्यों है?

हमने अभी फाइलों की समीक्षा की है Dockerfile, छवियों को बनाने और उन्हें डॉकर रिपॉजिटरी में भेजने के तरीके के बारे में बात की। इसके अलावा, हमने सीखा कि फ़ाइल का उपयोग करके छवियों के संयोजन को कैसे तेज़ किया जाए .dockerignore. परिणामस्वरूप, हमारी माइक्रोसर्विसेज अब डॉकर कंटेनरों में चल रही हैं। यहां आपके पास पूरी तरह से उचित प्रश्न हो सकता है कि हमें कुबेरनेट्स की आवश्यकता क्यों है। इस सामग्री का दूसरा भाग इस प्रश्न के उत्तर के लिए समर्पित होगा। इस बीच, निम्नलिखित प्रश्न पर विचार करें:
आइए मान लें कि हमारा टेक्स्ट विश्लेषण वेब एप्लिकेशन दुनिया भर में लोकप्रिय हो गया है। उनके पास हर मिनट लाखों रिक्वेस्ट आती हैं. इसका मतलब है कि माइक्रोसर्विसेज sa-webapp и sa-logic भारी तनाव में रहेंगे. माइक्रोसर्विसेज चलाने वाले कंटेनरों को कैसे स्केल करें?

स्रोत: www.habr.com

कुबेरनेट्स ट्यूटोरियल भाग 1: एप्लिकेशन, माइक्रोसर्विसेज और कंटेनर