1. परिचय
वेबसाइट और ऐप्लिकेशन चलाना कठिन है.
चीज़ें गलत हो जाती हैं, लेकिन अचानक बंद हो जाती हैं, सर्वर क्रैश हो जाते हैं, मांग बढ़ने से ज़्यादा संसाधन इस्तेमाल होने लगते हैं, और डाउनटाइम के बिना बदलाव करना मुश्किल और तनाव भरा होता है.
ज़रा सोचो कि एक ऐसा टूल है जो आपको यह काम करने में मदद कर सकता है और उसे ऑटोमेट भी कर सकता है! GKE (जीकेई) से ये सब करना न सिर्फ़ संभव है, बल्कि बेहद आसान है! इस कोडलैब में, आपको लगता है कि आपको एक डेवलपर की भूमिका निभानी है और वह एक काल्पनिक कंपनी-फ़ैंसी स्टोर के लिए ई-कॉमर्स वेबसाइट चलाता है. स्केलिंग और आउटेज से जुड़ी समस्याओं की वजह से, आपको अपने ऐप्लिकेशन को GKE (जीकेई) पर डिप्लॉय करने की ज़िम्मेदारी दी गई है!
इन अभ्यासों को क्लाउड डेवलपर के सामान्य अनुभव के हिसाब से व्यवस्थित किया जाता है:
- GKE (जीकेई) क्लस्टर बनाएं.
- Docker कंटेनर बनाएं.
- कंटेनर को GKE (जीकेई) में डिप्लॉय करें.
- कंटेनर को किसी सेवा के ज़रिए सार्वजनिक करें.
- कंटेनर को कई प्रतिकृतियों पर स्केल करें.
- वेबसाइट में बदलाव करें.
- बिना किसी डाउनटाइम के नया वर्शन रोल आउट करें.
आर्किटेक्चर का डायग्राम
आप इन चीज़ों के बारे में जानेंगे
- GKE (जीकेई) क्लस्टर बनाने का तरीका
- Docker इमेज बनाने का तरीका
- Kubernetes में Docker इमेज डिप्लॉय करने का तरीका
- Kubernetes पर किसी ऐप्लिकेशन को स्केल करने का तरीका
- Kubernetes पर रोलिंग अपडेट करने का तरीका
ज़रूरी शर्तें
- प्रोजेक्ट बनाने के लिए, एडमिन के तौर पर ऐक्सेस वाला Google खाता या प्रोजेक्ट के मालिक की भूमिका वाला प्रोजेक्ट
- Docker और Kubernetes की बुनियादी समझ (अगर आपको बुनियादी समझ नहीं है, तो कृपया Docker और Kubernetes की समीक्षा अभी करें.
2. एनवायरमेंट का सेटअप
अपने हिसाब से एनवायरमेंट सेटअप करें
अगर आपके पास पहले से कोई Google खाता नहीं है, तो आपको एक खाता बनाना होगा. Google Cloud Console में साइन इन करें और एक नया प्रोजेक्ट बनाएं.
याद रखें कि प्रोजेक्ट आईडी, Google Cloud के सभी प्रोजेक्ट का यूनीक नाम होता है. ऊपर दिया गया नाम पहले ही किसी दूसरे प्रोजेक्ट के लिए इस्तेमाल किया जा चुका है. इसलिए, यह आपके लिए काम नहीं करेगा! बाद में, इसे PROJECT_ID के तौर पर दिखाया जाएगा.
इसके बाद, आपको Google Cloud के संसाधनों का इस्तेमाल करने के लिए, Cloud Console में बिलिंग की सुविधा चालू करनी होगी. Google Cloud के नए उपयोगकर्ता, 300 डॉलर मुफ़्त में आज़माने की सुविधा पा सकते हैं. अगर आप नए उपयोगकर्ता नहीं हैं, तो चिंता न करें, क्योंकि कोडलैब के लिए आपको कुछ डॉलर से ज़्यादा खर्च नहीं करना चाहिए. हालांकि, अगर ज़्यादा संसाधनों का इस्तेमाल किया जाता है या उन्हें चलाना बंद कर दिया जाता है, तो कोडलैब का इस्तेमाल करने पर आपको ज़्यादा पैसे खर्च करने पड़ सकते हैं. इसके लिए, आखिर में मौजूद "साफ़ करें" सेक्शन देखें. ज़्यादा जानकारी के लिए, कीमत देखें.
Cloud Shell
लैपटॉप पर Google Cloud और GKE (जीकेई) को रिमोट तरीके से इस्तेमाल किया जा सकता है, लेकिन कोडलैब के लिए Cloud Shell का इस्तेमाल किया जा सकता है. यह क्लाउड में चलने वाला कमांड-लाइन एनवायरमेंट है.
Debian आधारित इस वर्चुअल मशीन में ऐसे सभी डेवलपमेंट टूल मौजूद हैं जिनकी आपको ज़रूरत पड़ेगी. यह पांच जीबी की स्थायी होम डायरेक्ट्री उपलब्ध कराता है और 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. GKE (जीकेई) क्लस्टर बनाएं
अब आपको डेवलपर एनवायरमेंट मिल गया है. इसलिए, अपनी वेबसाइट को डिप्लॉय करने के लिए, आपको GKE (जीकेई) क्लस्टर की ज़रूरत होगी! क्लस्टर बनाने से पहले, आपको यह पक्का करना होगा कि सही एपीआई चालू किए गए हैं. कंटेनर एपीआई को चालू करने के लिए, यह कमांड चलाएं:
gcloud services enable container.googleapis.com
अब, आप अपना क्लस्टर बना सकते हैं! 3 नोड वाला फ़ैंसी-क्लस्टर नाम का क्लस्टर बनाने के लिए, नीचे दिया गया तरीका अपनाएं:
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
Cloud Console में, अपने क्लस्टर और उससे जुड़ी जानकारी भी देखी जा सकती है. सबसे ऊपर बाएं कोने में, मेन्यू बटन पर क्लिक करें. इसके बाद, स्क्रोल करके Kubernetes Engine पर जाएं और Clusters पर क्लिक करें. आपको fancy-cluster नाम का अपना क्लस्टर दिखेगा.
बधाई हो! आपने अपना पहला क्लस्टर बनाया है!
4. क्लोन सोर्स रिपॉज़िटरी
यह एक मौजूदा वेबसाइट है, इसलिए आपको सिर्फ़ रिपॉज़िटरी से सोर्स का क्लोन बनाना होगा. इससे आपको Docker इमेज बनाने और GKE (जीकेई) पर डिप्लॉय करने पर फ़ोकस करने में मदद मिलेगी.
अपने Cloud Shell इंस्टेंस में, सोर्स रिपॉज़िटरी का क्लोन बनाने और उसे सही डायरेक्ट्री में बदलने के लिए, नीचे दिए गए निर्देशों का पालन करें. आपको Node.js डिपेंडेंसी भी इंस्टॉल करनी होगी, ताकि आप अपने ऐप्लिकेशन को डिप्लॉय करने से पहले उसकी जांच कर सकें.
cd ~ git clone https://github.com/googlecodelabs/monolith-to-microservices.git cd ~/monolith-to-microservices ./setup.sh
यह रिपॉज़िटरी को क्लोन करता है, डायरेक्ट्री में बदलाव करता है, और आपके ऐप्लिकेशन को स्थानीय तौर पर चलाने के लिए ज़रूरी डिपेंडेंसी इंस्टॉल करता है. इस स्क्रिप्ट को चलने में कुछ मिनट लग सकते हैं.
पूरी सावधानी बरतें और अपने आवेदन की जांच करें. अपना वेब सर्वर चालू करने के लिए, यहां दिया गया कमांड चलाएं:
cd ~/monolith-to-microservices/monolith npm start
आउटपुट:
Monolith listening on port 8080!
Cloud Shell मेन्यू में वेब प्रीव्यू आइकॉन पर क्लिक करके और पोर्ट 8080 पर 'झलक देखें' को चुनकर अपने ऐप्लिकेशन की झलक देखी जा सकती है.
यह एक नई विंडो में खुलेगा जहां आप अपने Fancy Store को काम करते हुए देख सकते हैं!
वेबसाइट देखने के बाद, उस विंडो को बंद किया जा सकता है. वेब सर्वर की प्रोसेस रोकने के लिए, टर्मिनल विंडो में Control+C (Windows या Mac) दबाएं.
5. Cloud Build की मदद से Docker कंटेनर बनाएं
अब आपकी सोर्स फ़ाइलें इस्तेमाल के लिए तैयार हैं, इसलिए ऐप्लिकेशन को डॉक करने का समय आ गया है!
आम तौर पर, आपको दो चरणों में काम करना होगा. इसमें, Docker कंटेनर बनाना और GKE (जीकेई) से ली गई इमेज को स्टोर करने के लिए उसे रजिस्ट्री में भेजना होगा. हालांकि, Cloud Build का इस्तेमाल करके Docker कंटेनर बनाकर, इमेज को एक ही निर्देश से कंटेनर रजिस्ट्री में डालकर ज़िंदगी को आसान बनाया जा सकता है! (डॉकर फ़ाइल बनाने और उसे पुश करने की मैन्युअल प्रोसेस देखने के लिए, कंटेनर रजिस्ट्री के लिए क्विकस्टार्ट देखें.)
Cloud Build, डायरेक्ट्री से फ़ाइलों को कंप्रेस करता है और उन्हें Cloud Storage बकेट में ले जाता है. इसके बाद, बिल्ड प्रोसेस बकेट से फ़ाइलें लेती है और Docker बिल्ड प्रोसेस को चलाने के लिए Dockerfile का इस्तेमाल करती है. आपने Docker इमेज के लिए, होस्ट वाले --tag फ़्लैग को gcr.io के तौर पर सेट किया है. इसलिए, इससे बनने वाली Docker इमेज, Container Registry में भेज दी जाती है.
सबसे पहले, आपको यह कमांड चलाकर Cloud Build API को चालू करना होगा:
gcloud services enable cloudbuild.googleapis.com
एपीआई चालू होने के बाद, बिल्ड प्रोसेस शुरू करने के लिए Cloud Shell में नीचे दिया गया कमांड चलाएं:
cd ~/monolith-to-microservices/monolith
gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith: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>/monolith:1.0.0 SUCCESS
अपने बिल्ड का इतिहास देखने या इस प्रोसेस को रीयल टाइम में देखने के लिए, Cloud Console पर जाएं. सबसे ऊपर बाएं कोने में मौजूद मेन्यू बटन पर क्लिक करें. इसके बाद, नीचे की ओर स्क्रोल करके Ci/CD पर जाएं. इसके बाद, Cloud Build पर क्लिक करें और आखिर में, 'इतिहास' पर क्लिक करें. यहां आपको अपने पिछले बिल्ड की सूची दिखेगी. हालांकि, आपको सिर्फ़ वही बिल्ड मिलना चाहिए जो आपने बनाया है.
बिल्ड आईडी पर क्लिक करने पर, आपको उस बिल्ड के लिए लॉग आउटपुट के साथ-साथ पूरी जानकारी दिखेगी.
बिल्ड की जानकारी वाले पेज पर, कंटेनर की वह इमेज देखी जा सकती है जिसे बिल्ड की जानकारी वाले सेक्शन में इमेज के नाम पर क्लिक करके बनाया गया था.
6. कंटेनर को GKE (जीकेई) में डिप्लॉय करें
अब आपने अपनी वेबसाइट को कंटेनर बना लिया है और कंटेनर को कंटेनर रजिस्ट्री में भेजा है, तो अब आप इसे Kubernetes पर डिप्लॉय कर सकते हैं!
GKE (जीकेई) क्लस्टर पर ऐप्लिकेशन डिप्लॉय और मैनेज करने के लिए, आपको Kubernetes क्लस्टर-मैनेजमेंट सिस्टम से संपर्क करना होगा. ऐसा करने के लिए, आम तौर पर kubectl कमांड-लाइन टूल इस्तेमाल किया जाता है.
Kubernetes, ऐप्लिकेशन को पॉड के रूप में दिखाती हैं. ये ऐसी इकाइयां होती हैं जो कंटेनर (या आपस में जुड़े कंटेनर के ग्रुप) को दिखाती हैं. Pod, Kubernetes में डिप्लॉय की जा सकने वाली सबसे छोटी यूनिट है. यहां, हर पॉड में सिर्फ़ आपका मोनोलिथ कंटेनर होता है.
अपने ऐप्लिकेशन को डिप्लॉय करने के लिए, आपको डिप्लॉयमेंट बनाना होगा. डिप्लॉयमेंट आपके ऐप्लिकेशन की कई कॉपी मैनेज करता है, जिन्हें कॉपी कहा जाता है. साथ ही, उन्हें आपके क्लस्टर में अलग-अलग नोड पर चलने के लिए शेड्यूल करता है. इस स्थिति में, डिप्लॉयमेंट आपके ऐप्लिकेशन का सिर्फ़ एक Pod चलाएगा. डिप्लॉयमेंट, ReplicaSet बनाकर यह पक्का करते हैं. ReplicaSet यह पक्का करने के लिए ज़िम्मेदार है कि बताई गई कॉपी की संख्या हमेशा चल रही है.
kubectl create deployment निर्देश की मदद से Kubernetes आपके क्लस्टर पर 1 रेप्लिका के साथ मोनोलिथ नाम का डिप्लॉयमेंट बना देती है.
अपने ऐप्लिकेशन को डिप्लॉय करने के लिए, यहां दिया गया कमांड चलाएं:
kubectl create deployment monolith --image=gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:1.0.0
डिप्लॉयमेंट की पुष्टि करें
यह पुष्टि करने के लिए कि डिप्लॉयमेंट सही तरीके से बनाया गया है या नहीं, नीचे दिए गए कमांड को चलाएं (Pod के स्टेटस को "चल रहा है" में दिखने में कुछ समय लग सकता है):
kubectl get all
आउटपुट:
NAME READY STATUS RESTARTS AGE pod/monolith-7d8bc7bf68-htm7z 1/1 Running 0 6m21s NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE service/kubernetes ClusterIP 10.27.240.1 <none> 443/TCP 24h NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE deployment.apps/monolith 1 1 1 1 20m NAME DESIRED CURRENT READY AGE replicaset.apps/monolith-7d8bc7bf68 1 1 1 20m
यह आउटपुट आपको कई चीज़ें दिखाता है. आप अपना परिनियोजन देख सकते हैं, जो हाल का है; आपका ReplicaSet, जिसकी पसंद के पॉड की संख्या एक है; और आपका पॉड भी. ऐसा लगता है कि आपने सब कुछ बना लिया है!
अपने संसाधनों को अलग-अलग देखने के लिए, ये निर्देश दिए जा सकते हैं:
# Show pods kubectl get pods # Show deployments kubectl get deployments # Show replica sets kubectl get rs #You can also combine them kubectl get pods,deployments
Kubernetes का पूरा फ़ायदा देखने के लिए, सर्वर क्रैश होने की नकल करें, पॉड को मिटाएं, और देखें कि क्या होता है!
पिछले कमांड से अपने पॉड का नाम कॉपी करें और उसे मिटाने के लिए, यहां दिया गया कमांड चलाएं:
kubectl delete pod/<POD_NAME>
अगर आपकी रफ़्तार काफ़ी तेज़ है, तो सभी को फिर से देखने के लिए पिछले निर्देश को चलाएं. इसके बाद, आपको दो पॉड दिखेंगे, एक खत्म होने वाला है और दूसरा बना या चल रहा है:
kubectl get all
आउटपुट:
NAME READY STATUS RESTARTS AGE pod/monolith-7d8bc7bf68-2bxts 1/1 Running 0 4s pod/monolith-7d8bc7bf68-htm7z 1/1 Terminating 0 9m35s NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE service/kubernetes ClusterIP 10.27.240.1 <none> 443/TCP 24h NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE deployment.apps/monolith 1 1 1 1 24m NAME DESIRED CURRENT READY AGE replicaset.apps/monolith-7d8bc7bf68 1 1 1 24m
इसका कारण क्या है? ReplicaSet को पता चला कि पॉड बंद हो रहा है और उसने एक नया पॉड ट्रिगर किया, ताकि वह डुप्लीकेट पॉड की संख्या बनाए रख सके. इसके बाद, कैंपेन को स्केल करने का तरीका बताया जाएगा, ताकि यह पक्का किया जा सके कि आपके कई इंस्टेंस चल रहे हैं. इससे, अगर कोई इंस्टेंस कम हो जाता है, तो आपके उपयोगकर्ताओं को डाउनटाइम नहीं दिखेगा!
7. GKE (जीकेई) डिप्लॉयमेंट को सार्वजनिक करें
आपने अपने ऐप्लिकेशन को GKE (जीकेई) पर डिप्लॉय किया है, लेकिन आपके पास इसे ऐक्सेस करने का कोई तरीका नहीं है. डिफ़ॉल्ट रूप से, GKE (जीकेई) पर चलाए जाने वाले कंटेनर, इंटरनेट से ऐक्सेस नहीं किए जा सकते, क्योंकि उनमें बाहरी आईपी पते नहीं होते हैं. आपको किसी सेवा संसाधन के ज़रिए, अपने ऐप्लिकेशन को इंटरनेट से ट्रैफ़िक के लिए साफ़ तौर पर सार्वजनिक करना होगा. किसी सेवा से, आपके ऐप्लिकेशन के पॉड के लिए नेटवर्किंग और आईपी सपोर्ट मिलता है. GKE (जीकेई), आपके ऐप्लिकेशन के लिए एक एक्सटर्नल आईपी और लोड बैलेंसर (बिलिंग पर निर्भर करता है) बनाता है.
अपनी वेबसाइट को इंटरनेट पर सार्वजनिक करने के लिए, नीचे दिया गया कमांड चलाएं:
kubectl expose deployment monolith --type=LoadBalancer --port 80 --target-port 8080
आउटपुट:
service/monolith exposed
सेवा को ऐक्सेस करना
GKE (जीकेई), सेवा से जुड़े संसाधन को बाहरी आईपी पता असाइन करता है, न कि डिप्लॉयमेंट को. अगर आपको अपने ऐप्लिकेशन में GKE (जीकेई) के लिए प्रावधान किया गया बाहरी आईपी पता करना है, तो kubectl पाएं सर्विस कमांड की मदद से सेवा की जांच करें:
kubectl get service
आउटपुट:
NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE monolith 10.3.251.122 203.0.113.0 80:30877/TCP 3d
अपने ऐप्लिकेशन का एक्सटर्नल आईपी पता तय करने के बाद, उसे कॉपी करें. अपने ब्राउज़र को उस यूआरएल (जैसे कि http://203.0.113.0) पर ले जाएं, ताकि यह देखा जा सके कि आपका ऐप्लिकेशन ऐक्सेस किया जा सकता है या नहीं.
आपको वही वेबसाइट दिखनी चाहिए जिसकी आपने पहले जांच की थी! बधाई हो! आपकी वेबसाइट पूरी तरह से Kubernetes पर चलती है!
8. GKE (जीकेई) डिप्लॉयमेंट को स्केल करें
अब GKE (जीकेई) में आपका ऐप्लिकेशन चल रहा है और वह इंटरनेट पर दिख रहा है, इसलिए आपकी वेबसाइट बहुत लोकप्रिय हो गई है! आपके पास अपने ऐप्लिकेशन को कई इंस्टेंस पर स्केल करने का तरीका होना चाहिए, ताकि आप ट्रैफ़िक को मैनेज कर सकें. अपने ऐप्लिकेशन को तीन प्रतिकृतियों तक स्केल करना सीखें.
अपने डिप्लॉयमेंट को तीन कॉपी तक स्केल करने के लिए नीचे दिया गया कमांड चलाएं:
kubectl scale deployment monolith --replicas=3
आउटपुट:
deployment.apps/monolith scaled
बड़े किए गए डिप्लॉयमेंट की पुष्टि करें
यह पुष्टि करने के लिए कि डिप्लॉयमेंट सही से स्केल हो गया है या नहीं, यह कमांड चलाएं:
kubectl get all
आउटपुट:
NAME READY STATUS RESTARTS AGE pod/monolith-7d8bc7bf68-2bxts 1/1 Running 0 36m pod/monolith-7d8bc7bf68-7ds7q 1/1 Running 0 45s pod/monolith-7d8bc7bf68-c5kxk 1/1 Running 0 45s NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE service/kubernetes ClusterIP 10.27.240.1 <none> 443/TCP 25h service/monolith LoadBalancer 10.27.253.64 XX.XX.XX.XX 80:32050/TCP 6m7s NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE deployment.apps/monolith 3 3 3 3 61m NAME DESIRED CURRENT READY AGE replicaset.apps/monolith-7d8bc7bf68 3 3 3 61m
आपको पॉड के तीन इंस्टेंस दिखेंगे. साथ ही, ध्यान रखें कि अब आपके परिनियोजन और ReplicaSet की संख्या तीन हो सकती है.
9. वेबसाइट में बदलाव करना
आपकी मार्केटिंग टीम ने आपसे अपनी वेबसाइट का होम पेज बदलने के लिए कहा है. उनका मानना है कि आपकी कंपनी क्या है और आपके प्रॉडक्ट बेचे जाने वाले प्रॉडक्ट की जानकारी देकर ज़्यादा जानकारी दी जानी चाहिए. इस सेक्शन में, आपको मार्केटिंग टीम को खुश करने के लिए होम पेज में कुछ टेक्स्ट जोड़ना होगा! ऐसा लगता है कि हमारे किसी डेवलपर ने पहले ही index.js.new फ़ाइल नाम से बदलाव कर लिए हैं. index.js में फ़ाइल कॉपी की जा सकती है. इससे आपके बदलाव दिखने लगेंगे. ज़रूरी बदलाव करने के लिए, नीचे दिए गए निर्देशों का पालन करें.
इन निर्देशों को चलाएं, अपडेट की गई फ़ाइल को सही फ़ाइल नाम पर कॉपी करें, और बदलावों की पुष्टि करने के लिए इसका कॉन्टेंट प्रिंट करें:
cd ~/monolith-to-microservices/react-app/src/pages/Home mv index.js.new index.js cat ~/monolith-to-microservices/react-app/src/pages/Home/index.js
मिलने वाला कोड कुछ ऐसा दिखना चाहिए:
/*
Copyright 2019 Google LLC
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
https://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
import React from "react";
import { makeStyles } from "@material-ui/core/styles";
import Paper from "@material-ui/core/Paper";
import Typography from "@material-ui/core/Typography";
const useStyles = makeStyles(theme => ({
root: {
flexGrow: 1
},
paper: {
width: "800px",
margin: "0 auto",
padding: theme.spacing(3, 2)
}
}));
export default function Home() {
const classes = useStyles();
return (
<div className={classes.root}>
<Paper className={classes.paper}>
<Typography variant="h5">
Fancy Fashion & Style Online
</Typography>
<br />
<Typography variant="body1">
Tired of mainstream fashion ideas, popular trends and societal norms?
This line of lifestyle products will help you catch up with the Fancy trend and express your personal style.
Start shopping Fancy items now!
</Typography>
</Paper>
</div>
);
}
आपने React कॉम्पोनेंट अपडेट कर दिए हैं, लेकिन आपको स्टैटिक फ़ाइलें जनरेट करने के लिए React ऐप्लिकेशन बनाना होगा. React ऐप्लिकेशन बनाने और उसे मोनोलिथ वाली सार्वजनिक डायरेक्ट्री में कॉपी करने के लिए, नीचे दिया गया कमांड चलाएं:
cd ~/monolith-to-microservices/react-app npm run build:monolith
कोड अपडेट होने के बाद, अब आपको अपना Docker कंटेनर फिर से बनाना होगा और उसे Container Registry में पब्लिश करना होगा. आप पहले वाले निर्देश का ही इस्तेमाल कर सकते हैं. हालांकि, इस बार आपको वर्शन लेबल अपडेट करने का विकल्प मिलेगा!
इमेज के अपडेट किए गए 2.0.0 वर्शन के साथ नया Cloud Build ट्रिगर करने के लिए, यह कमांड चलाएं:
cd ~/monolith-to-microservices/monolith
#Feel free to test your application
npm start
gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:2.0.0 .
वेब सर्वर की प्रोसेस रोकने के लिए, टर्मिनल विंडो में Control+C (Windows या Mac) दबाएं.
अगले सेक्शन में, उस इमेज का इस्तेमाल, बिना किसी डाउनटाइम के अपने ऐप्लिकेशन को अपडेट करने के लिए किया जाएगा.
10. वेबसाइट को बिना किसी डाउनटाइम के अपडेट करें
बदलाव पूरे हो गए हैं और मार्केटिंग टीम आपके अपडेट से खुश है! अब उपयोगकर्ताओं को बिना रुकावट के वेबसाइट को अपडेट करें. अपनी वेबसाइट अपडेट करने के लिए, नीचे दिए गए निर्देशों का पालन करें.
GKE (जीकेई) के रोलिंग अपडेट यह पक्का करते हैं कि आपका ऐप्लिकेशन अप-टू-डेट रहे और उपलब्ध रहे. भले ही सिस्टम, चल रहे सभी कॉपी में आपकी पुरानी कंटेनर इमेज के इंस्टेंस को आपकी नई इमेज से बदल दे.
कमांड लाइन से, Kubernetes को बताया जा सकता है कि आपको अपने डिप्लॉयमेंट के लिए इमेज को इन कमांड का इस्तेमाल करके, नए वर्शन में अपडेट करना है:
kubectl set image deployment/monolith monolith=gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:2.0.0
आउटपुट:
deployment.apps/monolith image updated
डिप्लॉयमेंट की पुष्टि करें
नीचे दिए गए कमांड को चलाकर, डिप्लॉयमेंट अपडेट की पुष्टि की जा सकती है:
kubectl get pods
आउटपुट:
NAME READY STATUS RESTARTS AGE monolith-584fbc994b-4hj68 1/1 Terminating 0 60m monolith-584fbc994b-fpwdw 1/1 Running 0 60m monolith-584fbc994b-xsk8s 1/1 Terminating 0 60m monolith-75f4cf58d5-24cq8 1/1 Running 0 3s monolith-75f4cf58d5-rfj8r 1/1 Running 0 5s monolith-75f4cf58d5-xm44v 0/1 ContainerCreating 0 1s
आपको तीन नए पॉड बनाए जा रहे हैं और आपके पुराने पॉड बंद हो रहे हैं. उम्र के हिसाब से देखा जा सकता है कि कौनसा गाना नया है और कौनसा पुराना है. आखिर में, आपको फिर से सिर्फ़ तीन पॉड दिखेंगे. इनमें, अपडेट किए गए तीन पॉड होंगे.
अपने बदलावों की पुष्टि करने के लिए, लोड बैलेंसर के बाहरी आईपी पते पर फिर से जाएं. इसके बाद, देखें कि आपका ऐप्लिकेशन अपडेट हो गया है.
सेवाओं की सूची बनाने और आईपी पता भूल जाने पर उसे देखने के लिए नीचे दिया गया कमांड चलाएं:
kubectl get svc
आपकी वेबसाइट में वही टेक्स्ट दिखना चाहिए जिसे आपने होम पेज कॉम्पोनेंट में जोड़ा है!
11. व्यवस्थित करें
Git डेटा स्टोर करने की जगह मिटाएं
cd ~ rm -rf monolith-to-microservices
कंटेनर रजिस्ट्री की इमेज मिटाएं
ध्यान दें: अगर आपने दूसरे वर्शन बनाए हैं, तो उन इमेज को मिटाने के लिए भी उसी सिंटैक्स का इस्तेमाल किया जा सकता है. यह कोडलैब यह मानता है कि आपके पास सिर्फ़ दो टैग हैं.
# Delete the container image for version 1.0.0 of our monolith
gcloud container images delete gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:1.0.0 --quiet
# Delete the container image for version 2.0.0 of our monolith
gcloud container images delete gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:2.0.0 --quiet
Cloud Storage से Cloud Build आर्टफ़ैक्ट मिटाएं
ध्यान दें: अगर आपने इस कोडलैब के अलावा, किसी दूसरे आर्टफ़ैक्ट के लिए Cloud Build का इस्तेमाल किया है, तो आपको Cloud Storage बकेट gs://<PROJECT_ID>_cloudbuild/source से अपना सोर्स मैन्युअल तरीके से मिटाना होगा.
# The following command will take all source archives from all builds and delete them from cloud storage
# Run this command to print all sources:
# gcloud builds list | awk 'NR > 1 {print $4}'
gcloud builds list | awk 'NR > 1 {print $4}' | while read line; do gsutil rm $line; done
GKE (जीकेई) सेवा मिटाएं
kubectl delete service monolith kubectl delete deployment monolith
GKE (जीकेई) क्लस्टर मिटाएं
gcloud container clusters delete fancy-cluster
ध्यान दें: यह निर्देश देने में थोड़ा समय लग सकता है.
12. बधाई हो!
आपने GKE (जीकेई) पर अपनी वेबसाइट को डिप्लॉय, स्केल, और अपडेट किया है. अब आपने Docker और Kubernetes का इस्तेमाल कर लिया है!