1. परिचय
मोनोलिथिक ऐप्लिकेशन से माइक्रोसेवाओं वाले आर्किटेक्चर पर क्यों माइग्रेट करना चाहिए? किसी ऐप्लिकेशन को माइक्रोसेवाओं में बांटने से ये फ़ायदे मिलते हैं. इनमें से ज़्यादातर फ़ायदे इस वजह से मिलते हैं, क्योंकि माइक्रोसेवाएं एक-दूसरे से कम जुड़ी होती हैं.
- माइक्रोसर्विसेज़ को अलग-अलग टेस्ट और डिप्लॉय किया जा सकता है. डिप्लॉयमेंट की यूनिट जितनी छोटी होगी, डिप्लॉयमेंट उतना ही आसान होगा.
- इन्हें अलग-अलग भाषाओं और फ़्रेमवर्क में लागू किया जा सकता है. हर माइक्रोसेवा के लिए, इस्तेमाल के हिसाब से सबसे अच्छी टेक्नोलॉजी चुनी जा सकती है.
- इन्हें अलग-अलग टीमें मैनेज कर सकती हैं. माइक्रोसर्विसेज़ के बीच की सीमा की वजह से, एक या कई माइक्रोसर्विसेज़ के लिए टीम को काम सौंपना आसान हो जाता है.
- माइक्रोसर्विसेज़ पर माइग्रेट करने से, टीमों के बीच की डिपेंडेंसी कम हो जाती है. हर टीम को सिर्फ़ उन माइक्रोसेवाओं के एपीआई का ध्यान रखना होता है जिन पर वह निर्भर है. टीम को यह सोचने की ज़रूरत नहीं है कि उन माइक्रोसेवाओं को कैसे लागू किया जाता है, उनकी रिलीज़ साइकल क्या हैं वगैरह.
- आप ज़्यादा आसानी से, फ़ेल होने की स्थिति के लिए डिज़ाइन कर सकते हैं. सेवाओं के बीच साफ़ तौर पर सीमाएं तय होने से, यह तय करना आसान हो जाता है कि अगर कोई सेवा काम नहीं कर रही है, तो क्या करना है.
मोनोलिथ की तुलना में, माइक्रोसेवाओं के कुछ नुकसान ये हैं:
- माइक्रोसर्विसेज़ पर आधारित ऐप्लिकेशन, अलग-अलग सेवाओं का नेटवर्क होता है. ये सेवाएं अक्सर ऐसे तरीकों से इंटरैक्ट करती हैं जिनके बारे में पता नहीं चलता. इसलिए, सिस्टम की जटिलता बढ़ जाती है.
- मोनोलिथ के इंटरनल कॉम्पोनेंट के उलट, माइक्रोसेवाएं नेटवर्क पर कम्यूनिकेट करती हैं. कुछ मामलों में, इसे सुरक्षा से जुड़ी समस्या माना जा सकता है. Istio इस समस्या को हल करता है. यह माइक्रोसेवाओं के बीच ट्रैफ़िक को अपने-आप एन्क्रिप्ट (सुरक्षित) करता है.
- सेवाओं के बीच लेटेंसी की वजह से, मोनोलिथिक अप्रोच की तरह ही परफ़ॉर्मेंस हासिल करना मुश्किल हो सकता है.
- आपके सिस्टम की परफ़ॉर्मेंस पर किसी एक सेवा का असर नहीं पड़ता, बल्कि कई सेवाओं और उनके इंटरैक्शन का असर पड़ता है. इस वजह से, यह समझना मुश्किल हो जाता है कि प्रोडक्शन में आपका सिस्टम कैसा काम करता है (इसकी निगरानी करना). Istio भी इस समस्या का समाधान है.
इस लैब में, हम Google Kubernetes Engine (GKE) में माइक्रोसेवाएं चलाएंगे. Kubernetes, कंटेनर को मैनेज, होस्ट, स्केल, और डिप्लॉय करने का प्लैटफ़ॉर्म है. कंटेनर, कोड को पैकेज करने और चलाने का एक पोर्टेबल तरीका है. ये माइक्रोसेवाओं के पैटर्न के लिए सबसे सही हैं. इनमें हर माइक्रोसेवा अपने कंटेनर में चल सकती है.
इस लैब में, हम किसी मौजूदा मोनोलिथिक ऐप्लिकेशन को Google Kubernetes Engine क्लस्टर पर डिप्लॉय करेंगे. इसके बाद, इसे माइक्रोसेवाओं में बांट देंगे!
हमारी माइक्रोसर्विस का आर्किटेक्चर डायग्राम
हम अपने मोनोलिथ को एक-एक करके तीन माइक्रोसेवाओं में बांटेंगे. माइक्रोसर्विसेज में, ऑर्डर, प्रॉडक्ट, और फ़्रंटएंड शामिल हैं. हम Cloud Build का इस्तेमाल करके, हर माइक्रोसेवा के लिए एक Docker इमेज बनाते हैं. इसे Cloud Shell से ट्रिगर किया जाता है. इसके बाद, हम Kubernetes सेवा के टाइप LoadBalancer की मदद से, Google Kubernetes Engine (GKE) पर अपनी माइक्रोसेवाओं को डिप्लॉय और उपलब्ध कराएंगे. हम हर सेवा के लिए ऐसा करेंगे. साथ ही, हम उन्हें अपने मोनोलिथ से अलग करेंगे. इस प्रोसेस के दौरान, हम अपने मोनोलिथ और माइक्रोसेवाओं, दोनों को तब तक चालू रखेंगे, जब तक हम अपने मोनोलिथ को मिटाने की स्थिति में नहीं आ जाते.
आपको क्या सीखने को मिलेगा
- मोनोलिथ को माइक्रोसेवाओं में कैसे बदला जाता है
- Google Kubernetes Engine क्लस्टर बनाने का तरीका
- डॉकर इमेज बनाने का तरीका
- Kubernetes पर Docker इमेज डिप्लॉय करने का तरीका
ज़रूरी शर्तें
- Google Cloud Platform खाता, जिसके पास प्रोजेक्ट बनाने का एडमिन के तौर पर ऐक्सेस हो या प्रोजेक्ट के मालिक की भूमिका वाला प्रोजेक्ट
- Docker और Kubernetes की बुनियादी जानकारी
2. एनवायरमेंट सेटअप करना
अपनी स्पीड से एनवायरमेंट सेट अप करना
अगर आपके पास पहले से कोई Google खाता (Gmail या Google Apps) नहीं है, तो आपको एक खाता बनाना होगा. Google Cloud Platform Console ( console.cloud.google.com) में साइन इन करें और एक नया प्रोजेक्ट बनाएं:
प्रोजेक्ट आईडी याद रखें. यह सभी Google Cloud प्रोजेक्ट के लिए एक यूनीक नाम होता है. ऊपर दिया गया नाम पहले ही इस्तेमाल किया जा चुका है. इसलिए, यह आपके लिए काम नहीं करेगा. माफ़ करें! इस कोड लैब में इसे बाद में PROJECT_ID के तौर पर दिखाया जाएगा.
इसके बाद, आपको Google Cloud के संसाधनों का इस्तेमाल करने के लिए, Developers Console में बिलिंग चालू करनी होगी. साथ ही, Container Engine API चालू करना होगा.
इस कोडलैब को पूरा करने में आपको कुछ डॉलर से ज़्यादा खर्च नहीं करने पड़ेंगे. हालांकि, अगर आपको ज़्यादा संसाधनों का इस्तेमाल करना है या उन्हें चालू रखना है, तो यह खर्च बढ़ सकता है. इस दस्तावेज़ के आखिर में "सफाई" सेक्शन देखें. Google Kubernetes Engine की कीमत के बारे में जानकारी यहां दी गई है.
Google Cloud Platform के नए उपयोगकर्ताओं को, मुफ़्त में आज़माने के लिए 300 डॉलर का क्रेडिट मिलता है.
Google Cloud Shell
Google Cloud और Kubernetes को अपने लैपटॉप से रिमोटली चलाया जा सकता है. हालांकि, इस कोडलैब में हम Google Cloud Shell का इस्तेमाल करेंगे. यह क्लाउड में चलने वाला कमांड लाइन एनवायरमेंट है.
यह Debian पर आधारित वर्चुअल मशीन है. इसमें डेवलपमेंट के लिए ज़रूरी सभी टूल पहले से मौजूद हैं. यह 5 जीबी की होम डायरेक्ट्री उपलब्ध कराता है और Google Cloud में चलता है. इससे नेटवर्क की परफ़ॉर्मेंस और पुष्टि करने की प्रोसेस बेहतर होती है. इसका मतलब है कि इस कोडलैब के लिए, आपको सिर्फ़ एक ब्राउज़र की ज़रूरत होगी. हां, यह Chromebook पर भी काम करता है.
- Cloud Console से Cloud Shell चालू करने के लिए, बस Cloud Shell चालू करें
पर क्लिक करें. इसे चालू होने और एनवायरमेंट से कनेक्ट होने में कुछ ही समय लगेगा.
Cloud Shell से कनेक्ट होने के बाद, आपको दिखेगा कि आपकी पुष्टि पहले ही हो चुकी है और प्रोजेक्ट पहले से ही आपके PROJECT_ID पर सेट है.
gcloud auth list
कमांड आउटपुट
Credentialed accounts: - <myaccount>@<mydomain>.com (active)
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>
- आखिर में, डिफ़ॉल्ट ज़ोन और प्रोजेक्ट कॉन्फ़िगरेशन सेट करें.
gcloud config set compute/zone us-central1-f
आपके पास अलग-अलग ज़ोन चुनने का विकल्प होता है. ज़्यादा जानकारी के लिए, रीजन और ज़ोन देखें.
3. सोर्स रिपॉज़िटरी का क्लोन बनाना
हम एक काल्पनिक ई-कॉमर्स वेबसाइट के मौजूदा मोनोलिथिक ऐप्लिकेशन का इस्तेमाल करते हैं. इसमें एक सामान्य वेलकम पेज, एक प्रॉडक्ट पेज, और एक ऑर्डर का इतिहास पेज है. हमें सिर्फ़ अपने गिट रिपो से सोर्स को क्लोन करना होगा, ताकि हम इसे माइक्रोसेवाओं में बांटने और Google Kubernetes Engine (GKE) पर डिप्लॉय करने पर ध्यान दे सकें.
git repo को अपने Cloud Shell इंस्टेंस में क्लोन करने और सही डायरेक्ट्री में बदलने के लिए, यहां दिए गए कमांड चलाएं. हम NodeJS की डिपेंडेंसी भी इंस्टॉल करेंगे, ताकि डिप्लॉय करने से पहले हम अपने मोनोलिथ का टेस्ट कर सकें. इस स्क्रिप्ट को चलने में कुछ मिनट लग सकते हैं.
cd ~ git clone https://github.com/googlecodelabs/monolith-to-microservices.git cd ~/monolith-to-microservices ./setup.sh
इससे हमारी Github repo का क्लोन बन जाएगा. इसके बाद, डायरेक्ट्री में बदलाव किया जाएगा और हमारे ऐप्लिकेशन को स्थानीय तौर पर चलाने के लिए ज़रूरी डिपेंडेंसी इंस्टॉल की जाएंगी. इस स्क्रिप्ट को चलने में कुछ मिनट लग सकते हैं.
4. GKE क्लस्टर बनाना
अब आपके पास काम करने वाला डेवलपर एनवायरमेंट है. हमें अपने मोनोलिथ और आखिर में अपनी माइक्रोसेवाओं को डिप्लॉय करने के लिए, Kubernetes क्लस्टर की ज़रूरत है! क्लस्टर बनाने से पहले, हमें यह पक्का करना होगा कि सही एपीआई चालू हों. कंटेनर एपीआई चालू करने के लिए, यह कमांड चलाएं, ताकि हम Google Kubernetes Engine का इस्तेमाल कर सकें:
gcloud services enable container.googleapis.com
अब हम अपना क्लस्टर बनाने के लिए तैयार हैं! 3 नोड वाला fancy-cluster नाम का GKE क्लस्टर बनाने के लिए, नीचे दिया गया कमांड चलाएं.
gcloud container clusters create fancy-cluster --num-nodes 3
क्लस्टर बनने में कुछ मिनट लग सकते हैं. कमांड पूरी होने के बाद, यहां दी गई कमांड चलाएं और क्लस्टर के तीन वर्कर वीएम इंस्टेंस देखें:
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 पर जाएं और क्लस्टर पर क्लिक करें. आपको fancy-cluster नाम का क्लस्टर दिखेगा.
बधाई हो! आपने अभी-अभी अपना पहला Kubernetes क्लस्टर बनाया है!
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) पर ले जाएं. इससे आपको यह पता चलेगा कि आपका मोनोलिथ ऐक्सेस किया जा सकता है या नहीं.
आपको मोनोलिथिक वेबसाइट का वेलकम पेज दिखेगा. यह पेज, ऊपर दी गई इमेज की तरह होगा. वेलकम पेज एक स्टैटिक पेज है. इसे बाद में फ़्रंटएंड माइक्रोसेवा से दिखाया जाएगा. अब आपका मोनोलिथ, Kubernetes पर पूरी तरह से चल रहा है!
6. ऑर्डर को माइक्रोडेटा में माइग्रेट करना
अब हमारी मौजूदा मोनोलिथ वेबसाइट, GKE पर चल रही है. इसलिए, हम हर सेवा को माइक्रोसेवा में बदलना शुरू कर सकते हैं. आम तौर पर, यह तय करने के लिए प्लानिंग की जाती है कि किन सेवाओं को छोटे-छोटे हिस्सों में बांटा जाए. आम तौर पर, ऐप्लिकेशन के कुछ हिस्सों को छोटे-छोटे हिस्सों में बांटा जाता है, जैसे कि कारोबार का डोमेन. उदाहरण के तौर पर, हमने एक सामान्य उदाहरण बनाया है. इसमें कारोबार के डोमेन, ऑर्डर, प्रॉडक्ट, और फ़्रंटएंड से जुड़ी हर सेवा को अलग-अलग दिखाया गया है. कोड को पहले ही माइग्रेट कर दिया गया है. अब हम Google Kubernetes Engine (GKE) पर सेवाएं बनाने और उन्हें डिप्लॉय करने पर ध्यान देंगे.
Create New Orders Microservice
हम सबसे पहले, Orders सेवा को अलग करेंगे. हम उपलब्ध कराए गए अलग कोडबेस का इस्तेमाल करेंगे और इस सेवा के लिए एक अलग Docker कंटेनर बनाएंगे.
Google Cloud Build की मदद से Docker कंटेनर बनाना
हमने आपके लिए कोडबेस को पहले ही माइग्रेट कर दिया है. इसलिए, हमारा पहला चरण Google Cloud Build का इस्तेमाल करके, ऑर्डर सेवा का Docker कंटेनर बनाना होगा.
आम तौर पर, आपको दो चरणों वाला तरीका अपनाना होता है. इसमें एक डॉकर कंटेनर बनाना होता है और उसे किसी रजिस्ट्री में पुश करना होता है, ताकि GKE उस इमेज को खींच सके. हालांकि, हम इस प्रोसेस को आसान बना सकते हैं. Docker कंटेनर बनाने के लिए, Google Cloud Build का इस्तेमाल किया जा सकता है. साथ ही, एक ही कमांड का इस्तेमाल करके इमेज को Google Cloud Container Registry में रखा जा सकता है! इससे हमें एक ही कमांड का इस्तेमाल करके, इमेज बनाने और उसे कंटेनर रजिस्ट्री में ले जाने की सुविधा मिलती है. डॉकर फ़ाइल बनाने और उसे पुश करने की मैन्युअल प्रोसेस देखने के लिए, यहां जाएं.
Google Cloud Build, डायरेक्ट्री में मौजूद फ़ाइलों को कंप्रेस करेगा और उन्हें Google Cloud Storage बकेट में ले जाएगा. इसके बाद, बिल्ड प्रोसेस में बकेट से सभी फ़ाइलें ली जाएंगी. साथ ही, Dockerfile का इस्तेमाल करके Docker बिल्ड प्रोसेस को चलाया जाएगा. हमने Docker इमेज के लिए, gcr.io को होस्ट के तौर पर --tag फ़्लैग के साथ तय किया है. इसलिए, नतीजे के तौर पर मिली 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 Container Registry में पुश कर दिया है. अब इसे Kubernetes में डिप्लॉय करने का समय है!
Kubernetes, ऐप्लिकेशन को पॉड के तौर पर दिखाता है. ये ऐसी यूनिट होती हैं जो किसी कंटेनर (या आपस में जुड़े कंटेनर के ग्रुप) को दिखाती हैं. पॉड, Kubernetes में सबसे छोटी डिप्लॉय की जा सकने वाली यूनिट है. इस ट्यूटोरियल में, हर पॉड में सिर्फ़ आपका माइक्रोसेवा कंटेनर होता है.
GKE क्लस्टर पर ऐप्लिकेशन डिप्लॉय करने और उन्हें मैनेज करने के लिए, आपको Kubernetes क्लस्टर मैनेजमेंट सिस्टम से कम्यूनिकेट करना होगा. आम तौर पर, Cloud Shell में kubectl कमांड-लाइन टूल का इस्तेमाल करके ऐसा किया जाता है.
सबसे पहले, हम Deployment संसाधन बनाएंगे. डिप्लॉयमेंट, आपके ऐप्लिकेशन की कई कॉपी मैनेज करता है. इन्हें रेप्लिका कहा जाता है. साथ ही, यह उन्हें आपके क्लस्टर के अलग-अलग नोड पर चलाने के लिए शेड्यूल करता है. इस मामले में, डिप्लॉयमेंट आपके ऐप्लिकेशन का सिर्फ़ एक पॉड चलाएगा. डप्लॉयमेंट, ReplicaSet बनाकर यह पक्का करते हैं. ReplicaSet यह पक्का करता है कि तय की गई रेप्लिका की संख्या हमेशा चालू रहे.
नीचे दी गई kubectl create deployment कमांड की वजह से, Kubernetes आपके क्लस्टर पर orders नाम का डिप्लॉयमेंट बनाता है. इसमें 1 रेप्लिका होता है.
अपने ऐप्लिकेशन को डिप्लॉय करने के लिए, यह कमांड चलाएं:
kubectl create deployment orders --image=gcr.io/${GOOGLE_CLOUD_PROJECT}/orders:1.0.0
डिप्लॉयमेंट की पुष्टि करना
डिप्लॉयमेंट के सही तरीके से बनने की पुष्टि करने के लिए, यह कमांड चलाएं. पॉड के स्टेटस को 'चल रहा है' में बदलने में कुछ समय लग सकता है:
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, और चालू पॉड दिख रहा है. ऐसा लगता है कि सब कुछ बन गया है!
GKE कंटेनर को सार्वजनिक करना
हमने अपने ऐप्लिकेशन को GKE पर डिप्लॉय किया है. हालांकि, हमारे पास इसे क्लस्टर के बाहर ऐक्सेस करने का कोई तरीका नहीं है. डिफ़ॉल्ट रूप से, GKE पर चलाए जाने वाले कंटेनर को इंटरनेट से ऐक्सेस नहीं किया जा सकता. ऐसा इसलिए होता है, क्योंकि उनके पास बाहरी आईपी पते नहीं होते हैं. आपको अपने ऐप्लिकेशन को इंटरनेट से मिलने वाले ट्रैफ़िक के लिए उपलब्ध कराना होगा. इसके लिए, Service संसाधन का इस्तेमाल करें. सेवा, आपके ऐप्लिकेशन के पॉड को नेटवर्किंग और आईपी की सुविधा देती है. GKE, आपके ऐप्लिकेशन के लिए एक बाहरी आईपी पता और लोड बैलेंसर ( बिलिंग के लिए ज़रूरी है) बनाता है.
जब हमने ऑर्डर करने की सेवा को डिप्लॉय किया, तब हमने इसे Kubernetes डिप्लॉयमेंट के ज़रिए, पोर्ट 8081 पर इंटरनल तौर पर उपलब्ध कराया. इस सेवा को बाहरी तौर पर उपलब्ध कराने के लिए, हमें LoadBalancer टाइप की Kubernetes सेवा बनानी होगी. इससे पोर्ट 80 से आने वाले ट्रैफ़िक को बाहरी तौर पर Orders सेवा के इंटरनल पोर्ट 8081 पर रूट किया जा सकेगा. अपनी वेबसाइट को इंटरनेट पर दिखाने के लिए, यह कमांड चलाएं:
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
अपने ऐप्लिकेशन के लिए बाहरी आईपी पता तय करने के बाद, आईपी पते को कॉपी करें. इसे अगले चरण के लिए सेव करें, ताकि जब हम अपने मोनोलिथ को नई Orders सेवा पर ले जाएं, तो इसका इस्तेमाल किया जा सके!
मोनोलिथ को फिर से कॉन्फ़िगर करना
हमने Orders सेवा को मोनोलिथ से हटा दिया है. इसलिए, हमें मोनोलिथ में बदलाव करना होगा, ताकि वह नई बाहरी Orders माइक्रोसेवा की ओर इशारा कर सके.
मोनोलिथ को अलग-अलग हिस्सों में बांटने का मतलब है कि हम कोड के हिस्सों को एक कोडबेस से हटाकर, अलग-अलग कोडबेस में ले जा रहे हैं और उन्हें अलग-अलग डिप्लॉय कर रहे हैं. माइक्रोसर्विस किसी दूसरे सर्वर पर चल रही है. इसलिए, अब हम अपने सेवा यूआरएल को ऐब्सलूट पाथ के तौर पर रेफ़रंस नहीं कर सकते. हमें अपनी ऑर्डर माइक्रोसर्विस के नए सर्वर पते पर रूट करने की ज़रूरत है. ध्यान दें कि इससे मोनोलिथ सेवा को कुछ समय के लिए बंद करना होगा, ताकि वह हर उस सेवा के लिए यूआरएल अपडेट कर सके जिसे अलग किया गया है. माइक्रोसर्विसेज़ माइग्रेशन की प्रोसेस के दौरान, अपनी माइक्रोसर्विसेज़ और मोनोलिथ को प्रोडक्शन में ले जाने का प्लान बनाते समय, इस बात का ध्यान रखना चाहिए.
हमें अपने मोनोलिथ में कॉन्फ़िगरेशन फ़ाइल को अपडेट करना होगा, ताकि वह नए Orders microservices के आईपी पते पर रीडायरेक्ट हो सके. लोकल यूआरएल को हमारी नई Orders microservice के आईपी पते से बदलने के लिए, nano एडिटर का इस्तेमाल करें. में बदलाव करने के लिए, यह कमांड चलाएं
cd ~/monolith-to-microservices/react-app nano .env.monolith
एडिटर खुलने के बाद, आपकी फ़ाइल ऐसी दिखनी चाहिए:
REACT_APP_ORDERS_URL=/service/orders REACT_APP_PRODUCTS_URL=/service/products
अपने Orders microservice के आईपी पते से बदलते समय, REACT_APP_ORDERS_URL को नए फ़ॉर्मैट से बदलें, ताकि यह नीचे दिए गए फ़ॉर्मैट से मेल खाए:
REACT_APP_ORDERS_URL=http://<ORDERS_IP_ADDRESS>/api/orders REACT_APP_PRODUCTS_URL=/service/products
nano एडिटर में फ़ाइल सेव करने के लिए, CTRL+O दबाएं. इसके बाद, ENTER दबाएं और फिर CTRL+X दबाएं.
इस फ़ाइल में सेट किए गए यूआरएल पर जाकर, अपनी नई माइक्रोसेवा की जांच की जा सकती है. वेबपेज को हमारी Orders microservice से 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
यह पुष्टि की जा सकती है कि आपका ऐप्लिकेशन अब नए Orders microservice का इस्तेमाल कर रहा है. इसके लिए, अपने ब्राउज़र में मोनोलिथ ऐप्लिकेशन पर जाएं और Orders पेज पर जाएं. सभी ऑर्डर आईडी, नीचे दिए गए तरीके से -MICROSERVICE सफ़िक्स के साथ खत्म होने चाहिए:
7. प्रॉडक्ट को माइक्रोसर्विस पर माइग्रेट करना
Create New Products Microservice
हम प्रॉडक्ट सेवा को माइग्रेट करके, अपनी सेवाओं को अलग-अलग करना जारी रख सकते हैं. हम पिछले चरण वाली प्रोसेस को ही अपनाएंगे. 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
nano एडिटर में फ़ाइल सेव करने के लिए, 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. फ़्रंटएंड को माइक्रोडेटा में माइग्रेट करना
माइग्रेशन की प्रोसेस का आखिरी चरण, फ़्रंटएंड कोड को माइक्रोसेवा में ले जाना और मोनोलिथ को बंद करना है! यह चरण पूरा होने के बाद, हम अपने मोनोलिथ को माइक्रोसेवाओं वाले आर्किटेक्चर में माइग्रेट कर देंगे!
नई फ़्रंटएंड माइक्रोसेवा बनाएं
नया फ़्रंटएंड माइक्रोसेवा बनाने के लिए, आइए पिछले दो चरणों की तरह ही प्रक्रिया अपनाएं.
पहले, जब हमने अपने मोनोलिथ को फिर से बनाया था, तब हमने अपने कॉन्फ़िगरेशन को मोनोलिथ पर पॉइंट करने के लिए अपडेट किया था. हालांकि, अब हमें अपने फ़्रंटएंड माइक्रोसेवा के लिए उसी कॉन्फ़िगरेशन का इस्तेमाल करना होगा. हमारी माइक्रोसेवाओं के यूआरएल कॉन्फ़िगरेशन फ़ाइलों को फ़्रंटएंड माइक्रोसेवा के कोडबेस में कॉपी करने के लिए, यहां दी गई कमांड चलाएं:
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
Delete The Monolith
अब हमारी सभी सेवाएं माइक्रोसेवाओं के तौर पर चल रही हैं. इसलिए, हम अपने मोनोलिथ ऐप्लिकेशन को मिटा सकते हैं! ध्यान दें कि माइग्रेशन के दौरान, डीएनएस में बदलाव भी किए जाएंगे. इससे हमारे मौजूदा डोमेन नेम, हमारे ऐप्लिकेशन के नए फ़्रंटएंड माइक्रोसेवाओं पर रीडायरेक्ट हो पाएंगे. हमारे मोनोलिथ को मिटाने के लिए, ये कमांड चलाएं:
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
फ़्रंटएंड माइक्रोसर्विस के लिए बाहरी आईपी पते का पता लगाने के बाद, आईपी पते को कॉपी करें. अपने ब्राउज़र को इस यूआरएल (जैसे, http://203.0.113.0) पर ले जाएं. इससे यह पता चलेगा कि आपका फ़्रंटएंड ऐक्सेस किया जा सकता है या नहीं. आपकी वेबसाइट पहले जैसी ही होनी चाहिए, जैसे कि हमने मोनोलिथ को माइक्रोसेवाओं में बांटने से पहले किया था!
9. साफ़-सफ़ाई सेवा
तैयार होने के बाद, की गई सभी गतिविधियों को मिटाने का सबसे आसान तरीका है कि प्रोजेक्ट को मिटा दिया जाए. प्रोजेक्ट को मिटाने से, इस कोडलैब में बनाए गए सभी संसाधन मिट जाते हैं. इससे यह पक्का किया जाता है कि आपसे बार-बार कोई शुल्क न लिया जाए. Cloud Shell में यहां दिया गया कमांड चलाएं. इसमें PROJECT_ID, प्रोजेक्ट का पूरा आईडी है, न कि सिर्फ़ प्रोजेक्ट का नाम.
gcloud projects delete [PROJECT_ID]
जब आपसे कहा जाए, तब "Y" डालकर मिटाने की पुष्टि करें.
10. बधाई हो!
आपने अपने मोनोलिथिक ऐप्लिकेशन को माइक्रोसेवाओं में बांटकर, उन्हें Google Kubernetes Engine पर डिप्लॉय कर दिया है!
अगले चरण
Kubernetes के बारे में ज़्यादा जानने के लिए, यहां दिए गए कोडलैब देखें:
- Google Kubernetes Engine पर अपनी वेबसाइट को डिप्लॉय, स्केल, और अपडेट करना
- Kubernetes पर Node.js की मदद से Slack बॉट बनाना
- Spinnaker का इस्तेमाल करके, Kubernetes पर लगातार डिलीवरी करना
- Google Kubernetes Engine पर Kubernetes में Java ऐप्लिकेशन डिप्लॉय करना
अतिरिक्त संसाधन
- Docker - https://docs.docker.com/
- Kubernetes - https://kubernetes.io/docs/home/
- Google Kubernetes Engine (GKE) - https://cloud.google.com/kubernetes-engine/docs/
- Google Cloud Build - https://cloud.google.com/cloud-build/docs/
- Google Container Registry - https://cloud.google.com/container-registry/docs/
- मोनोलिथ को माइक्रोसेवाओं में माइग्रेट करना - https://cloud.google.com/solutions/migrating-a-monolithic-app-to-microservices-gke