Google Kubernetes Engine पर, मोनोलिथिक वेबसाइट को माइक्रोसर्विस पर माइग्रेट करना

1. परिचय

एक मोनोलिथिक ऐप्लिकेशन से, माइक्रोसर्विस आर्किटेक्चर पर माइग्रेट क्यों करें? किसी ऐप्लिकेशन को माइक्रोसर्विस में बांटने के ये फ़ायदे हैं; उनमें से ज़्यादातर सेवा इस बात से जुड़ी होती है कि माइक्रोसेवाओं के बीच संतुलन बना रहता है.

• माइक्रोसेवाओं को स्वतंत्र रूप से टेस्ट करके डिप्लॉय किया जा सकता है. डिप्लॉयमेंट की यूनिट जितनी छोटी होगी, डिप्लॉयमेंट उतना ही आसान होगा.
• उन्हें अलग-अलग भाषाओं और फ़्रेमवर्क में लागू किया जा सकता है. हर माइक्रोसेवा के लिए, उसके इस्तेमाल के हिसाब से सबसे अच्छी टेक्नोलॉजी को चुना जा सकता है.
• इन्हें अलग-अलग टीमें मैनेज कर सकती हैं. माइक्रोसर्विस के बीच की सीमा की मदद से, एक या कई माइक्रोसर्विस के लिए टीम बनाना आसान हो जाता है.
• माइक्रोसेवाओं का इस्तेमाल करने से, टीमों के बीच उनकी निर्भरता कम हो जाती है. हर टीम को सिर्फ़ उन माइक्रोसर्विस के एपीआई की चिंता करनी होती है जिन पर वे निर्भर करती हैं. टीम को इस बारे में सोचने की ज़रूरत नहीं है कि उन माइक्रोसेवाओं को कैसे लागू किया जाता है, उनकी रिलीज़ साइकल के बारे में और इसी तरह की दूसरी चीज़ों के बारे में.
• गड़बड़ी होने पर, उसे आसानी से डिज़ाइन किया जा सकता है. सेवाओं के बीच साफ़ सीमाएं होने से, यह तय करना आसान हो जाता है कि सेवा बंद होने पर क्या किया जाए.

मोनोलिथ की तुलना में इसके कुछ नुकसान हैं:

• माइक्रोसर्विस पर आधारित ऐप्लिकेशन, अलग-अलग सेवाओं का एक नेटवर्क होता है, जो अक्सर ऐसे तरीकों से काम करती है जो साफ़ तौर पर नहीं पता होते. इसलिए, सिस्टम की जटिलता बढ़ती जा रही है.
• मोनोलिथ की अंदरूनी चीज़ों के उलट, माइक्रोसर्विस, नेटवर्क के ज़रिए एक-दूसरे से बातचीत करती हैं. कुछ परिस्थितियों में, इसे सुरक्षा से जुड़ी चिंता के रूप में देखा जा सकता है. Istio, माइक्रोसेवाओं के बीच ट्रैफ़िक को अपने-आप एन्क्रिप्ट (सुरक्षित) करके, इस समस्या को हल कर सकता है.
• सेवाओं के बीच देरी की वजह से, मोनोलिथिक तरीके से परफ़ॉर्मेंस का वही लेवल हासिल करना मुश्किल हो सकता है जो मोनोलिथिक तरीके से होता है.
• आपका सिस्टम किसी एक सेवा की वजह से नहीं, बल्कि उनमें से कई सेवाओं के साथ हुए उनके इंटरैक्शन की वजह से ऐसा हो सकता है. इस वजह से, यह समझना मुश्किल हो जाता है कि आपका सिस्टम प्रोडक्शन में कैसे काम करता है (इसकी निगरानी रखना मुश्किल होता है). इस समस्या का हल भी है Istio में है.

इस लैब में, हम Google Kubernetes Engine (GKE) में माइक्रोसर्विस चलाएं. Kubernetes एक ऐसा प्लैटफ़ॉर्म है जो कंटेनर को मैनेज करने, होस्ट करने, स्केल करने, और डिप्लॉय करने का काम करता है. कंटेनर, पैकेजिंग और रनिंग कोड का पोर्टेबल तरीका हैं. ये माइक्रोसर्विस पैटर्न के हिसाब से सही होती हैं. हर माइक्रोसर्विस, अपने कंटेनर में चल सकती है.

इस लैब के लिए, हम मौजूदा मोनोलिथिक ऐप्लिकेशन को Google Kubernetes Engine क्लस्टर में डिप्लॉय करेंगे. इसके बाद, इसे माइक्रोसर्विस में बांट देंगे!

ध्यान दें

ज़्यादा जानकारी के लिए, ये लिंक देखें:

मोनोलिथ को माइक्रोसर्विस पर माइग्रेट करना (पूरा लेख)

माइक्रोसेवाओं के इस्तेमाल के सबसे सही तरीके

हमारी माइक्रोसर्विस का आर्किटेक्चर डायग्राम

हम अपने मोनोलिथ को तीन माइक्रोसर्विस में बांटकर शुरुआत करेंगे. एक-एक करके देखें. माइक्रोसेवाओं में ऑर्डर, प्रॉडक्ट, और फ़्रंटएंड शामिल हैं. हम Cloud Build का इस्तेमाल करके, हर माइक्रोसर्विस के लिए Docker इमेज बनाते हैं, जिसे हम Cloud Shell से ट्रिगर करते हैं. इसके बाद, हम अपनी माइक्रोसेवाओं को Google Kubernetes Engine (GKE) पर, Kubernetes सेवा के Load Balr के साथ डिप्लॉय और दिखाएं. हम हर सेवा के लिए ऐसा करेंगे और साथ-साथ हर सेवा के लिए, फिर से रीफ़ैक्टर करेंगे. इस प्रोसेस के दौरान, हम अपने मोनोलिथ और माइक्रोसर्विस को तब तक चालू रखते हैं, जब तक कि हम अपने मोनोलिथ को मिटा नहीं देते.

आप इन चीज़ों के बारे में जानेंगे

• मोनोलिथ को माइक्रोसर्विस में कैसे बदलें
• Google Kubernetes Engine क्लस्टर बनाने का तरीका
• Docker इमेज बनाने का तरीका
• Kubernetes में Docker इमेज डिप्लॉय करने का तरीका

ज़रूरी शर्तें

• Google Cloud Platform खाता, जिसके पास एडमिन के तौर पर ऐक्सेस होता है. इसकी मदद से, प्रोजेक्ट या प्रोजेक्ट के मालिक की भूमिका वाला प्रोजेक्ट बनाया जा सकता है
• Docker और Kubernetes की बुनियादी समझ

ज़्यादा जानकारी

डॉकर

कुबेरनेट्स

मोनोलिथ को माइक्रोसर्विस पर माइग्रेट करना (पूरा लेख)

माइक्रोसेवाओं के इस्तेमाल के सबसे सही तरीके

2. एनवायरमेंट का सेटअप

अपने हिसाब से एनवायरमेंट सेटअप करें

अगर आपके पास पहले से Google खाता (Gmail या Google Apps) नहीं है, तो एक खाता बनाएं. Google Cloud Platform कंसोल ( console.cloud.google.com) में साइन इन करें और एक नया प्रोजेक्ट बनाएं:

प्रोजेक्ट आईडी याद रखें. यह Google Cloud के सभी प्रोजेक्ट के लिए एक खास नाम होता है (ऊपर दिया गया नाम पहले ही ले लिया गया है और यह आपके लिए काम नहीं करेगा!). बाद में, इस कोडलैब को इस कोडलैब में PROJECT_ID के तौर पर दिखाया जाएगा.

इसके बाद, Google क्लाउड के संसाधनों का इस्तेमाल करने और कंटेनर इंजन एपीआई को चालू करने के लिए, आपको Developers Console में बिलिंग चालू करनी होगी.

इस कोडलैब को आज़माने के लिए आपको कुछ डॉलर से ज़्यादा खर्च नहीं करना चाहिए. हालांकि, अगर आप ज़्यादा संसाधनों का इस्तेमाल करने का फ़ैसला करते हैं या उन्हें बंद कर देते हैं, तो यह ज़्यादा हो सकता है (इस दस्तावेज़ के आखिर में "क्लीनअप" सेक्शन देखें). Google Kubernetes Engine की कीमत की जानकारी यहां दी गई है.

Google Cloud Platform के नए उपयोगकर्ता $300 के मुफ़्त परीक्षण के लिए योग्य हैं.

Google Cloud शेल

Google Cloud और Kubernetes को आपके लैपटॉप से, कहीं से भी ऑपरेट किया जा सकता है. हालांकि, इस कोडलैब में हम Google Cloud Shell का इस्तेमाल करेंगे. यह क्लाउड में चलने वाला कमांड लाइन एनवायरमेंट है.

Debian आधारित इस वर्चुअल मशीन में ऐसे सभी डेवलपमेंट टूल मौजूद हैं जिनकी आपको ज़रूरत पड़ेगी. यह पांच जीबी की स्थायी होम डायरेक्ट्री उपलब्ध कराता है और Google Cloud में चलता है. यह नेटवर्क की परफ़ॉर्मेंस और पुष्टि करने की प्रोसेस को बेहतर बनाता है. इसका मतलब है कि इस कोडलैब के लिए आपको सिर्फ़ एक ब्राउज़र की ज़रूरत होगी. हां, यह Chromebook पर काम करता है.

1. Cloud Console से Cloud Shell को चालू करने के लिए, Cloud Shell को चालू करें पर क्लिक करें. प्रावधान करने और एनवायरमेंट से कनेक्ट होने में कुछ ही समय लगेगा.

Cloud Shell से कनेक्ट करने के बाद, आपको दिखेगा कि आपकी पुष्टि पहले ही हो चुकी है. साथ ही, यह प्रोजेक्ट पहले से ही आपके PROJECT_ID पर सेट है.

gcloud auth list

कमांड आउटपुट

Credentialed accounts:
 - <myaccount>@<mydomain>.com (active)

ध्यान दें: gcloud कमांड-लाइन टूल, Cloud Shell में पहले से इंस्टॉल होता है. टैब पूरा करने पर यह सुविधा आपको ज़रूर मिलेगी. ज़्यादा जानकारी के लिए, gcloud command-line टूल की खास जानकारी देखें.

gcloud config list project

कमांड आउटपुट

[core]
project = <PROJECT_ID>

अगर किसी कारण से, प्रोजेक्ट सेट नहीं है, तो बस निम्न आदेश जारी करें:

gcloud config set project <PROJECT_ID>

क्या आपको अपना PROJECT_ID चाहिए? देखें कि आपने सेटअप के चरणों में किस आईडी का इस्तेमाल किया है या इसे Cloud Console के डैशबोर्ड में देखें:

Cloud Shell, डिफ़ॉल्ट रूप से कुछ एनवायरमेंट वैरिएबल सेट करता है. ये वैरिएबल, आने वाले समय में कमांड चलाने के दौरान काम आ सकते हैं.

echo $GOOGLE_CLOUD_PROJECT

कमांड आउटपुट

<PROJECT_ID>

2. आखिर में, डिफ़ॉल्ट ज़ोन और प्रोजेक्ट कॉन्फ़िगरेशन सेट करें.

gcloud config set compute/zone us-central1-f

आपके पास कई तरह के ज़ोन चुनने का विकल्प होता है. ज़्यादा जानकारी के लिए, क्षेत्र और ज़ोन.

ध्यान दें: जब अपनी मशीन पर gcloud चलाया जाता है, तो कॉन्फ़िगरेशन सेटिंग सभी सेशन में लागू रहेगी. हालांकि, Cloud Shell में आपको हर नए सेशन या फिर से कनेक्ट करने के लिए, इस सेटिंग को सेट करना होगा.

3. क्लोन सोर्स रिपॉज़िटरी

हम एक काल्पनिक ई-कॉमर्स वेबसाइट के मौजूदा मोनोलिथिक ऐप्लिकेशन का इस्तेमाल करते हैं. इसमें एक सामान्य स्वागत पेज, एक प्रॉडक्ट पेज, और एक ऑर्डर के इतिहास वाला पेज होता है. हमें सिर्फ़ अपने git रेपो से सोर्स का क्लोन बनाना होगा, ताकि हम इसे माइक्रोसर्विस में बांट सकें और Google Kubernetes Engine (GKE) में डिप्लॉय कर सकें.

अपने Cloud Shell इंस्टेंस में git repo का क्लोन बनाने और उसे सही डायरेक्ट्री में बदलने के लिए, नीचे दिए गए निर्देशों का पालन करें. हम NodeJS डिपेंडेंसी भी इंस्टॉल करेंगे, ताकि डिप्लॉय करने से पहले, हम अपने मोनोलिथ की जांच कर सकें. इस स्क्रिप्ट को चलने में कुछ मिनट लग सकते हैं.

cd ~
git clone https://github.com/googlecodelabs/monolith-to-microservices.git
cd ~/monolith-to-microservices
./setup.sh

यह हमारे GitHub रेपो का क्लोन बनाएगा, डायरेक्ट्री में बदलाव करेगा, और हमारे ऐप्लिकेशन को स्थानीय तौर पर चलाने के लिए ज़रूरी डिपेंडेंसी इंस्टॉल करेगा. इस स्क्रिप्ट को चलने में कुछ मिनट लग सकते हैं.

4. GKE (जीकेई) क्लस्टर बनाएं

अब आपको डेवलपर एनवायरमेंट मिल गया है. इसलिए, हमें Kubernetes क्लस्टर की ज़रूरत है, ताकि हमारे मोनोलिथ को लागू किया जा सके और आखिर में हमारी माइक्रोसर्विस का इस्तेमाल किया जा सके! क्लस्टर बनाने से पहले, हमें यह पक्का करना होगा कि सही एपीआई चालू किए गए हैं. कंटेनर api चालू करने के लिए नीचे दिया गया निर्देश चलाएं, ताकि हम Google Kubernetes Engine का इस्तेमाल कर सकें:

gcloud services enable container.googleapis.com

अब हम अपना क्लस्टर बनाने के लिए तैयार हैं! 3 नोड वाला fancy-cluster नाम का GKE क्लस्टर बनाने के लिए, नीचे दिए गए निर्देश को चलाएं.

gcloud container clusters create fancy-cluster --num-nodes 3

चेतावनी

अगर आपको क्षेत्र/ज़ोन की जानकारी न दिए जाने के बारे में गड़बड़ी मिलती है, तो कृपया एनवायरमेंट सेटअप सेक्शन देखें और पक्का करें कि आपने डिफ़ॉल्ट कंप्यूट ज़ोन सेट किया हो.

क्लस्टर बनने में कुछ मिनट लग सकते हैं. निर्देश पूरा होने के बाद, नीचे दिया गया निर्देश चलाएं और क्लस्टर के तीन वर्कर VM इंस्टेंस देखें:

gcloud compute instances list

आउटपुट:

NAME                                          ZONE        MACHINE_TYPE   PREEMPTIBLE  INTERNAL_IP  EXTERNAL_IP    STATUS
gke-fancy-cluster-default-pool-ad92506d-1ng3  us-east4-a  n1-standard-1               10.150.0.7   XX.XX.XX.XX    RUNNING
gke-fancy-cluster-default-pool-ad92506d-4fvq  us-east4-a  n1-standard-1               10.150.0.5   XX.XX.XX.XX    RUNNING
gke-fancy-cluster-default-pool-ad92506d-4zs3  us-east4-a  n1-standard-1               10.150.0.6   XX.XX.XX.XX    RUNNING

Google Cloud Console में, अपने Kubernetes क्लस्टर और उससे जुड़ी जानकारी को भी देखा जा सकता है. ऊपर बाईं ओर दिए गए मेन्यू बटन पर क्लिक करें, नीचे स्क्रोल करके Kubernetes Engine पर जाएं, और Clusters पर क्लिक करें. आपको fancy-cluster नाम का अपना क्लस्टर दिखेगा.

बधाई हो! आपने अभी-अभी अपना पहला Kubernetes क्लस्टर बनाया है!

ध्यान दें

अगर आपने किसी मौजूदा Google Kubernetes Engine क्लस्टर का इस्तेमाल किया है या Google Cloud Platform Console के ज़रिए क्लस्टर बनाया है, तो क्लस्टर के क्रेडेंशियल वापस पाने और उनके साथ kubectl कमांड-लाइन टूल कॉन्फ़िगर करने के लिए, आपको यह कमांड चलाना होगा:

gcloud container clusters get-credentials fancy-cluster

अगर आपने पहले से ही gcloud कंटेनर क्लस्टर वाला क्लस्टर बना लिया है, तो यह ऊपर दी गई सूची में मौजूद कमांड बना सकता है. ऐसे में, यह चरण ज़रूरी नहीं है.

5. मौजूदा मोनोलिथ को डिप्लॉय करें

इस लैब का मकसद, मोनोलिथ को माइक्रोसर्विस में बांटकर जाना है. इसलिए, हमें मोनोलिथ ऐप्लिकेशन को तैयार करके उसे चलाना होगा. इस लैब के लिए, हमारे GKE (जीकेई) क्लस्टर में मोनोलिथ ऐप्लिकेशन डिप्लॉय करने के लिए, नीचे दी गई स्क्रिप्ट चलाएं:

cd ~/monolith-to-microservices
./deploy-monolith.sh

मोनोलिथ को ऐक्सेस करना

हमारे मोनोलिथ ऐप्लिकेशन का बाहरी आईपी पता ढूंढने के लिए, नीचे दिया गया कमांड चलाएं.

kubectl get service monolith

आपको इससे मिलता-जुलता आउटपुट दिखेगा:

NAME         CLUSTER-IP      EXTERNAL-IP     PORT(S)          AGE
monolith     10.3.251.122    203.0.113.0     80:30877/TCP     3d

ध्यान दें: इसके लिए, एक्सटर्नल लोड बैलेंसर और आईपी का प्रावधान करना होगा. इसलिए, ऐसा होने में कुछ समय लगेगा. अगर आपके आउटपुट में एक्सटर्नल आईपी इस तरह दिखता है

<pending> कुछ मिनट बाद फिर से कोशिश करें.

अपने मोनोलिथ के लिए बाहरी आईपी पता तय करने के बाद, आईपी पता कॉपी करें. अपने ब्राउज़र को इस यूआरएल (जैसे कि http://203.0.113.0) पर ले जाएं और देखें कि आपके मोनोलिथ को ऐक्सेस किया जा सकता है या नहीं.

ध्यान दें

इस आईपी पते को याद रखें, क्योंकि आने वाले समय में भी आप इसका इस्तेमाल करते रहेंगे. आप इसी निर्देश से उसे कभी भी ढूंढ सकते हैं.

आपको ऊपर दिए गए चित्र की तरह ही मोनोलिथिक वेबसाइट के लिए स्वागत पेज दिखाई देगा. स्वागत पेज एक स्टैटिक पेज है, जिसे आने वाले समय में Frontend माइक्रो सर्विस के ज़रिए दिखाया जाएगा. अब आपका मोनोलिथ, Kubernetes पर पूरी तरह से चलने वाला है!

6. ऑर्डर को माइक्रोसर्विस पर माइग्रेट करें

अब हमारी मोनोलिथ वेबसाइट GKE (जीकेई) पर काम कर रही है, इसलिए हम हर सेवा को माइक्रोसर्विस में बांट सकते हैं. आम तौर पर, यह ध्यान रखना चाहिए कि किन सेवाओं को ऐप्लिकेशन के छोटे हिस्सों में बांटना है, जैसे कि कारोबार का डोमेन. समझाने के मकसद से, हमने एक आसान उदाहरण बनाया है. साथ ही, कारोबार के डोमेन, ऑर्डर, प्रॉडक्ट, और फ़्रंटएंड से जुड़ी हर सेवा के बारे में अलग-अलग बताया है. कोड पहले ही माइग्रेट कर दिया गया है. हम Google Kubernetes Engine (GKE) पर सेवाएं बनाने और उन्हें डिप्लॉय करने पर ध्यान देंगे.

नए ऑर्डर की माइक्रोसेवा बनाएं

हम सबसे पहली सेवा के तौर पर ऑर्डर सेवा उपलब्ध कराएंगे. हम दिए गए अलग कोड बेस का इस्तेमाल करेंगे और इस सेवा के लिए एक अलग Docker कंटेनर बनाएंगे.

Google Cloud Build के साथ Docker कंटेनर बनाएं

हमने आपके लिए कोड बेस पहले ही माइग्रेट कर दिया है. इसलिए, हमारा पहला चरण Google Cloud Build का इस्तेमाल करके, हमारी ऑर्डर सेवा का Docker कंटेनर बनाना होगा.

आम तौर पर, आपको दो चरणों में काम करना होता है. इसके लिए, एक डॉकर कंटेनर बनाना होता है और उसे रजिस्ट्री में भेजना पड़ता है, ताकि GKE (जीकेई) से इमेज लेने के लिए उसे स्टोर किया जा सके. हालांकि, इससे काम आसान हो सकता है और हम Google Cloud Build का इस्तेमाल करके Docker कंटेनर बना सकते हैं. साथ ही, सिर्फ़ एक निर्देश से, इमेज को Google Cloud Container Registry में भेज सकते हैं! इससे हम अपनी इमेज बनाने और उसे कंटेनर रजिस्ट्री में ले जाने के लिए, एक निर्देश दे पाते हैं. डॉकर फ़ाइल बनाने और उसे पुश करने की मैन्युअल प्रोसेस देखने के लिए, यहां जाएं.

Google Cloud Build, डायरेक्ट्री से फ़ाइलों को कंप्रेस करेगा और उन्हें Google Cloud Storage बकेट में ले जाएगा. इसके बाद, बिल्ड प्रोसेस बकेट की सभी फ़ाइलें ले लेगी और Docker बिल्ड प्रोसेस को चलाने के लिए, Dockerfile का इस्तेमाल करेगी. हमने Docker इमेज के लिए, होस्ट के साथ --tag फ़्लैग को gcr.io के तौर पर बताया है. इसलिए, इससे बनने वाली Docker इमेज को Google Cloud Container Registry में भेज दिया जाएगा.

अपना Docker कंटेनर बनाने और उसे Google Container Registry में भेजने के लिए, नीचे दिए गए निर्देशों का पालन करें:

cd ~/monolith-to-microservices/microservices/src/orders
gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/orders:1.0.0 .

इस प्रोसेस में कुछ मिनट लगेंगे, लेकिन इसके पूरा होने के बाद, टर्मिनल में कुछ जैसा आउटपुट होगा:

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
ID                                    CREATE_TIME                DURATION  SOURCE                                                                                  IMAGES                              STATUS
1ae295d9-63cb-482c-959b-bc52e9644d53  2019-08-29T01:56:35+00:00  33S       gs://<PROJECT_ID>_cloudbuild/source/1567043793.94-abfd382011724422bf49af1558b894aa.tgz  gcr.io/<PROJECT_ID>/orders:1.0.0  SUCCESS

बिल्ड का इतिहास देखने या इस प्रोसेस को रीयल टाइम में देखने के लिए, Google Cloud Console पर जाएं. सबसे ऊपर बाईं ओर मौजूद मेन्यू बटन पर क्लिक करें. इसके बाद, नीचे की ओर स्क्रोल करके टूल → Cloud Build पर जाएं और इतिहास पर क्लिक करें. यहां अपने पिछले सभी बिल्ड की सूची देखी जा सकती है. आपने अभी-अभी सिर्फ़ एक बिल्ड बनाया है.

बिल्ड आईडी पर क्लिक करने पर, आपको उस बिल्ड की पूरी जानकारी दिखेगी. इसमें लॉग आउटपुट भी शामिल है.

बिल्ड की जानकारी वाले पेज पर, बिल्ड की जानकारी वाले सेक्शन में इमेज के नाम पर क्लिक करके बनाई गई कंटेनर इमेज देखी जा सकती है.

GKE (जीकेई) में कंटेनर डिप्लॉय करें

अब जब हमने अपनी वेबसाइट को कंटेनर तैयार कर लिया है और अपने कंटेनर को Google कंटेनर रजिस्ट्री में भेज दिया है, तो अब इसे Kubernetes पर डिप्लॉय करने का समय है!

Kubernetes, ऐप्लिकेशन को पॉड के रूप में दिखाती हैं. ये ऐसी इकाइयां होती हैं जो कंटेनर (या जोड़े गए कंटेनर के ग्रुप) को दिखाती हैं. Pod, Kubernetes में डिप्लॉय की जा सकने वाली सबसे छोटी यूनिट है. इस ट्यूटोरियल में, हर पॉड में सिर्फ़ माइक्रोसर्विस कंटेनर मौजूद है.

GKE (जीकेई) क्लस्टर पर ऐप्लिकेशन डिप्लॉय और मैनेज करने के लिए, आपको Kubernetes क्लस्टर मैनेजमेंट सिस्टम से संपर्क करना होगा. आम तौर पर, ऐसा करने के लिए Cloud Shell में kubectl कमांड-लाइन टूल का इस्तेमाल किया जाता है.

सबसे पहले हम एक डिप्लॉयमेंट संसाधन बनाएंगे. डिप्लॉयमेंट आपके ऐप्लिकेशन की कई कॉपी मैनेज करता है, जिन्हें कॉपी कहा जाता है. साथ ही, डिप्लॉयमेंट उन्हें आपके क्लस्टर में अलग-अलग नोड पर चलने के लिए शेड्यूल करता है. इस मामले में, डिप्लॉयमेंट आपके ऐप्लिकेशन का सिर्फ़ एक Pod चलाएगा. डिप्लॉयमेंट, ReplicaSet बनाकर इसे पक्का करते हैं. ReplicaSet यह पक्का करने के लिए ज़िम्मेदार है कि तय की गई कॉपी की संख्या हमेशा चल रही है.

नीचे दिए गए kubectl create deployment कमांड की मदद से, Kubernetes आपके क्लस्टर पर 1 रेप्लिका के साथ ऑर्डर नाम का डिप्लॉयमेंट बना देती है.

अपने ऐप्लिकेशन को डिप्लॉय करने के लिए, यहां दिया गया कमांड चलाएं:

kubectl create deployment orders --image=gcr.io/${GOOGLE_CLOUD_PROJECT}/orders:1.0.0

ध्यान दें

हमारा सुझाव है कि आप YAML फ़ाइल का इस्तेमाल करके, Kubernetes क्लस्टर में अपने बदलाव का एलान करें.साथ ही, इन बदलावों को सेव करने के लिए सोर्स कंट्रोल सिस्टम का इस्तेमाल करें. जैसे- डिप्लॉयमेंट या सेवा में बदलाव करना या डिप्लॉयमेंट या सेवा में बदलाव करना.

ज़्यादा जानकारी के लिए ये संसाधन देखें:

Kubernetes डिप्लॉयमेंट

डिप्लॉयमेंट की पुष्टि करें

डिप्लॉयमेंट के सही होने की पुष्टि करने के लिए, नीचे दिए गए निर्देश को चलाएं. पॉड की स्थिति को चालू होने में कुछ समय लग सकता है:

kubectl get all

आउटपुट:

NAME                            READY   STATUS    RESTARTS   AGE
pod/monolith-779c8d95f5-dxnzl   1/1     Running   0          15h
pod/orders-5bc6969d76-kdxkk     1/1     Running   0          21s
NAME                 TYPE           CLUSTER-IP      EXTERNAL-IP    PORT(S)        AGE
service/kubernetes   ClusterIP      10.39.240.1     <none>         443/TCP        19d
service/monolith     LoadBalancer   10.39.241.130   34.74.209.57   80:30412/TCP   15h
NAME                       READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/monolith   1/1     1            1           15h
deployment.apps/orders     1/1     1            1           21s
NAME                                  DESIRED   CURRENT   READY   AGE
replicaset.apps/monolith-779c8d95f5   1         1         1       15h
replicaset.apps/orders-5bc6969d76     1         1         1       21s

इस आउटपुट से हमें कई चीज़ें दिखती हैं. हम देख सकते हैं कि हमारा डिप्लॉयमेंट हाल ही का है या नहीं. इसके अलावा, हम अपना ReplicaSet देख सकते हैं, जिसकी पॉड की संख्या 1 होनी चाहिए, और जो अभी चल रहा है. ऐसा लगता है कि सब कुछ बना दिया गया है!

मददगार हिंट

सबसे ऊपर बाएं मेन्यू पर जाकर, Kubernetes Engine → Workloads पर जाकर, कंसोल के ज़रिए अपने Kubernetes डिप्लॉयमेंट को भी देखा जा सकता है

GKE (जीकेई) कंटेनर दिखाएं

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

ध्यान दें

इस डेमो में हमने अपनी सेवा को आसान बना दिया है. आम तौर पर, अपने सार्वजनिक एंडपॉइंट को सुरक्षित रखने के लिए, एपीआई गेटवे का इस्तेमाल किया जाता है. माइक्रोसेवाओं को इस्तेमाल करने के सबसे सही तरीकों के बारे में ज़्यादा जानने के लिए, यहां क्लिक करें.

जब हमने अपनी ऑर्डर सेवा को डिप्लॉय किया, तो हमने इसे Kubernetes डिप्लॉयमेंट की मदद से पोर्ट 8081 पर दिखाया. इस सेवा को बाहरी लोगों को दिखाने के लिए, हमें ऑर्डर सेवा के लिए ट्रैफ़िक को पोर्ट 80 से बाहर के पोर्ट 8081 पर भेजने के लिए, Load Balancer टाइप की Kubernetes सेवा बनानी होगी. अपनी वेबसाइट को इंटरनेट पर दिखाने के लिए, नीचे दिया गया कमांड चलाएं:

kubectl expose deployment orders --type=LoadBalancer --port 80 --target-port 8081

सेवा को ऐक्सेस करना

GKE (जीकेई), सेवा से जुड़े संसाधन को बाहरी आईपी पता असाइन करता है, न कि डिप्लॉयमेंट को. अगर आपको यह पता लगाना है कि आपके ऐप्लिकेशन में GKE (जीकेई) ने कौनसा आईपी पता लगाया है, तो kubectl get service निर्देश से सेवा की जांच करें:

kubectl get service orders

आउटपुट:

NAME         CLUSTER-IP      EXTERNAL-IP     PORT(S)          AGE
orders       10.3.251.122    203.0.113.0     80:30877/TCP     3d

अपने ऐप्लिकेशन के लिए बाहरी आईपी पता तय करने के बाद, आईपी पता कॉपी करें. जब हम अपने मोनोलिथ को बदलकर अपनी नई ऑर्डर सेवा पर ले जाएं, तब इसे अगले चरण के लिए सेव करें!

मोनोलिथ को फिर से कॉन्फ़िगर करें

हमने मोनोलिथ से ऑर्डर सेवा हटा दी है. इसलिए, हमें नई बाहरी ऑर्डर वाली माइक्रोसेवा पर ले जाने के लिए मोनोलिथ में बदलाव करना होगा.

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

हमें अपने मोनोलिथ में अपनी कॉन्फ़िगरेशन फ़ाइल अपडेट करनी होगी, ताकि हमें नए ऑर्डर माइक्रोसर्विस के आईपी पते पर ले जाया जा सके. नैनो एडिटर का इस्तेमाल करके, लोकल यूआरएल को हमारी नई ऑर्डर माइक्रोसेवा के आईपी पते से बदलें. मौजूदा विंडो में बदलाव करने के लिए, नीचे दिया गया कमांड चलाएं

cd ~/monolith-to-microservices/react-app
nano .env.monolith

एडिटर खुलने पर, आपकी फ़ाइल इस तरह दिखेगी:

REACT_APP_ORDERS_URL=/service/orders
REACT_APP_PRODUCTS_URL=/service/products

अपने ऑर्डर माइक्रोसर्विस आईपी पते से, REACT_APP_ORDERS_URL को नए फ़ॉर्मैट में बदलें, ताकि यह नीचे दिए गए पते से मैच करे:

REACT_APP_ORDERS_URL=http://<ORDERS_IP_ADDRESS>/api/orders
REACT_APP_PRODUCTS_URL=/service/products

फ़ाइल को नैनो एडिटर में सेव करने के लिए, CTRL+O दबाएं और फिर ENTER दबाएं. इसके बाद, CTRL+X दबाएं.

इस फ़ाइल में अभी सेट किए गए यूआरएल पर जाकर, नई माइक्रोसर्विस की जांच की जा सकती है. वेबपेज को हमारे ऑर्डर माइक्रोसर्विस से, JSON रिस्पॉन्स देना चाहिए.

इसके बाद, हमें अपने मोनोलिथ फ़्रंटएंड को फिर से बनाना होगा. साथ ही, बिल्ड प्रोसेस को दोहराना होगा, ताकि मोनोलिथ के लिए कंटेनर बनाया जा सके और हमारे GKE (जीकेई) क्लस्टर में फिर से डिप्लॉय किया जा सके. निम्न कमांड चलाएँ इन चरणों को पूरा करें:

मोनोलिथ कॉन्फ़िगरेशन फ़ाइलें फिर से बनाएं

npm run build:monolith

Google Cloud Build के साथ Docker कंटेनर बनाएं

cd ~/monolith-to-microservices/monolith
gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:2.0.0 .

GKE (जीकेई) में कंटेनर डिप्लॉय करें

kubectl set image deployment/monolith monolith=gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:2.0.0

आप अपने ब्राउज़र में मोनोलिथ ऐप्लिकेशन पर जाकर और ऑर्डर पेज पर जाकर यह पुष्टि कर सकते हैं कि आपका ऐप्लिकेशन अब नए ऑर्डर्स माइक्रोसर्विस को हिट कर रहा है. सभी ऑर्डर आईडी के आखिर में प्रत्यय -MICROSERVICE होना चाहिए, जैसा कि नीचे दिखाया गया है:

7. प्रॉडक्ट को माइक्रोसर्विस पर माइग्रेट करें

नए प्रॉडक्ट की माइक्रोसर्विस बनाएं

हम इसके बाद उत्पाद सेवा को माइग्रेट करके अपनी सेवाओं को अलग करना जारी रख सकते हैं. हम पिछले चरण वाली प्रक्रिया का ही पालन करेंगे. Docker कंटेनर बनाने, अपने कंटेनर को डिप्लॉय करने, और उसे Kubernetes सेवा की मदद से सार्वजनिक करने के लिए, यहां दिए गए निर्देशों का पालन करें.

Google Cloud Build के साथ Docker कंटेनर बनाएं

cd ~/monolith-to-microservices/microservices/src/products
gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/products:1.0.0 .

GKE (जीकेई) में कंटेनर डिप्लॉय करें

kubectl create deployment products --image=gcr.io/${GOOGLE_CLOUD_PROJECT}/products:1.0.0

GKE (जीकेई) कंटेनर दिखाएं

kubectl expose deployment products --type=LoadBalancer --port 80 --target-port 8082

हमारी प्रॉडक्ट सेवाओं का सार्वजनिक आईपी ठीक उसी तरह ढूंढें जैसा हमने अपनी ऑर्डर सेवा के लिए किया था. इसके लिए यहां दिए गए निर्देश का इस्तेमाल करें:

kubectl get service products

आउटपुट:

NAME         CLUSTER-IP      EXTERNAL-IP     PORT(S)          AGE
products     10.3.251.122    203.0.113.0     80:30877/TCP     3d

जब हम अपने मोनोलिथ को फिर से कॉन्फ़िगर करके, नए प्रॉडक्ट माइक्रोसेवा पर ले जाएं, तब अगले चरण के लिए आईपी पता सेव करें.

मोनोलिथ को फिर से कॉन्फ़िगर करें

लोकल यूआरएल को हमारे नए 'प्रॉडक्ट' माइक्रोसर्विस के आईपी पते से बदलने के लिए नैनो एडिटर का इस्तेमाल करें:

cd ~/monolith-to-microservices/react-app
nano .env.monolith

एडिटर खुलने पर, आपकी फ़ाइल इस तरह दिखेगी:

REACT_APP_ORDERS_URL=http://<ORDERS_IP_ADDRESS>/api/orders
REACT_APP_PRODUCTS_URL=/service/products

अपने प्रॉडक्ट माइक्रोसर्विस आईपी पते से, REACT_APP_PRODUCTS_URL को नए फ़ॉर्मैट में बदलें, ताकि यह नीचे दिए गए पते से मेल खाए:

REACT_APP_ORDERS_URL=http://<ORDERS_IP_ADDRESS>/api/orders
REACT_APP_PRODUCTS_URL=http://<PRODUCTS_IP_ADDRESS>/api/products

फ़ाइल को नैनो एडिटर में सेव करने के लिए, CTRL+O दबाएं और फिर ENTER दबाएं. इसके बाद, CTRL+X दबाएं.

इस फ़ाइल में अभी सेट किए गए यूआरएल पर जाकर, नई माइक्रोसर्विस की जांच की जा सकती है. वेबपेज को हमारे प्रॉडक्ट माइक्रोसर्विस से JSON रिस्पॉन्स देना चाहिए.

इसके बाद, हमें अपने मोनोलिथ फ़्रंटएंड को फिर से बनाना होगा. साथ ही, बिल्ड प्रोसेस को दोहराना होगा, ताकि मोनोलिथ के लिए कंटेनर बनाया जा सके और हमारे GKE (जीकेई) क्लस्टर में फिर से डिप्लॉय किया जा सके. निम्न कमांड चलाएँ इन चरणों को पूरा करें:

मोनोलिथ कॉन्फ़िगरेशन फ़ाइलें फिर से बनाएं

npm run build:monolith

Google Cloud Build के साथ Docker कंटेनर बनाएं

cd ~/monolith-to-microservices/monolith
gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:3.0.0 .

GKE (जीकेई) में कंटेनर डिप्लॉय करें

kubectl set image deployment/monolith monolith=gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:3.0.0

आप अपने ब्राउज़र में मोनोलिथ ऐप्लिकेशन पर जाकर और प्रॉडक्ट पेज पर नेविगेट करके यह पुष्टि कर सकते हैं कि आपका ऐप्लिकेशन अब नया प्रॉडक्ट माइक्रोसर्विस हिट कर रहा है. सभी प्रॉडक्ट के नामों से पहले MS- लगाएं, जैसा कि यहां दिखाया गया है:

8. फ़्रंटएंड को माइक्रोसर्विस पर माइग्रेट करें

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

नई फ़्रंटएंड माइक्रोसर्विस बनाएं

नई फ़्रंटएंड माइक्रोसर्विस बनाने के लिए, आखिरी दो चरणों वाली प्रोसेस को ही अपनाते हैं.

पहले जब हमने अपने मोनोलिथ को दोबारा बनाया था, तब हमने अपने मोनोलिथ को पॉइंट करने के लिए कॉन्फ़िगरेशन को अपडेट किया था. अब हमें Frontend माइक्रोसर्विस के लिए उसी कॉन्फ़िगरेशन का इस्तेमाल करना होगा. हमारी माइक्रोसेवाओं की यूआरएल कॉन्फ़िगरेशन फ़ाइलों को Frontend माइक्रोसर्विस कोड बेस में कॉपी करने के लिए, नीचे दिए गए निर्देशों का पालन करें:

cd ~/monolith-to-microservices/react-app
cp .env.monolith .env
npm run build

इसके पूरा होने के बाद, हम पिछले चरणों वाली प्रक्रिया का ही पालन करेंगे. Docker कंटेनर बनाने, अपने कंटेनर को डिप्लॉय करने, और उसे Kubernetes सेवा की मदद से सार्वजनिक करने के लिए, यहां दिए गए निर्देशों का पालन करें.

Google Cloud Build के साथ Docker कंटेनर बनाएं

cd ~/monolith-to-microservices/microservices/src/frontend
gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/frontend:1.0.0 .

GKE (जीकेई) में कंटेनर डिप्लॉय करें

kubectl create deployment frontend --image=gcr.io/${GOOGLE_CLOUD_PROJECT}/frontend:1.0.0

GKE (जीकेई) कंटेनर दिखाएं

kubectl expose deployment frontend --type=LoadBalancer --port 80 --target-port 8080

मोनोलिथ मिटाएं

अब हमारी सभी सेवाएं माइक्रोसर्विस के तौर पर काम कर रही हैं, इसलिए हम मोनोलिथ ऐप्लिकेशन को मिटा सकते हैं! ध्यान दें, असल में माइग्रेट करने के दौरान, इसकी वजह से डीएनएस में बदलाव वगैरह भी होंगे, ताकि हमारे मौजूदा डोमेन नेम, हमारे ऐप्लिकेशन के लिए नए फ़्रंटएंड माइक्रोसर्विस पर ले जा सकें. हमारा मोनोलिथ मिटाने के लिए, नीचे दिए गए निर्देशों का पालन करें:

kubectl delete deployment monolith
kubectl delete service monolith

अपना काम परखें

यह पुष्टि करने के लिए कि सब कुछ काम कर रहा है, आपके मोनोलिथ सेवा का पुराना आईपी पता काम नहीं करना चाहिए. साथ ही, आपकी फ़्रंटएंड सेवा का नया आईपी पता, नए ऐप्लिकेशन को होस्ट करेगा. सभी सेवाओं और आईपी पतों की सूची देखने के लिए, इस कमांड का इस्तेमाल करें:

kubectl get services

आपका आउटपुट ऐसा दिखना चाहिए:

NAME         TYPE           CLUSTER-IP      EXTERNAL-IP      PORT(S)        AGE
frontend     LoadBalancer   10.39.246.135   35.227.21.154    80:32663/TCP   12m
kubernetes   ClusterIP      10.39.240.1     <none>           443/TCP        18d
orders       LoadBalancer   10.39.243.42    35.243.173.255   80:32714/TCP   31m
products     LoadBalancer   10.39.250.16    35.243.180.23    80:32335/TCP   21m

अपने Frontend माइक्रोसेवा के लिए बाहरी आईपी पता तय कर लेने के बाद, आईपी पते को कॉपी करें. अपने ब्राउज़र को इस यूआरएल (जैसे कि http://203.0.113.0) पर ले जाएं और देखें कि आपका फ़्रंटएंड ऐक्सेस किया जा सकता है या नहीं. आपकी वेबसाइट ठीक वैसी ही होनी चाहिए जैसी हमने माइक्रोसर्विस में बांटने से पहले की थी!

9. साफ़-सफ़ाई सेवा

प्रोजेक्ट को मिटाने के बाद, प्रोजेक्ट से की गई सभी गतिविधियों को आसानी से मिटाएं. प्रोजेक्ट को मिटाने पर, इस कोडलैब (कोड बनाना सीखना) में बनाए गए सभी संसाधन मिट जाएंगे, ताकि यह पक्का किया जा सके कि बार-बार लगने वाला कोई भी शुल्क अचानक न लिया जाए. Cloud Shell में यह लागू करें, जहां PROJECT_ID पूरा प्रोजेक्ट आईडी है, न कि सिर्फ़ प्रोजेक्ट का नाम.

gcloud projects delete [PROJECT_ID]

"Y" डालकर, मिटाने की पुष्टि करें प्रॉम्प्ट दिखाई दे.

अगर आपको प्रोजेक्ट आईडी नहीं पता है, तो मौजूदा प्रोजेक्ट आईडी पाने के लिए Cloud Shell से gcloud config list | grep project को चलाया जा सकता है.

10. बधाई हो!

आपने अपने मोनोलिथिक ऐप्लिकेशन को माइक्रोसर्विस में बांट दिया है और उसे Google Kubernetes Engine पर डिप्लॉय कर दिया है!

अगले चरण

Kubernetes के बारे में ज़्यादा जानने के लिए, यहां दिए गए कोडलैब देखें:

• Google Kubernetes Engine पर अपनी वेबसाइट को डिप्लॉय, स्केल, और अपडेट करना
• Kubernetes पर Node.js की मदद से Slack बॉट बनाना
• Sinnaker की मदद से, Kubernetes पर लगातार डिलीवरी
• Google Kubernetes Engine पर, Kubernetes में Java ऐप्लिकेशन डिप्लॉय करना

अतिरिक्त संसाधन

• Docker - https://docs.docker.com/
• कुबेरनेट्स - https://kubernetes.io/docs/home/
• Google Kubernetes Engine (जीकेई) - https://cloud.google.com/kubernetes-engine/docs/
• Google Cloud बिल्ड - https://cloud.google.com/cloud-build/docs/
• Google कंटेनर रजिस्ट्री - https://cloud.google.com/container-registry/docs/
• मोनोलिथ को माइक्रोसर्विस पर माइग्रेट करना - https://cloud.google.com/solutions/migrating-a-monolithic-app-to-microservices-gke