GCE (जीसीई) का इस्तेमाल करके Google Cloud पर वेब ऐप्लिकेशन होस्ट करना

Google Cloud में वेब साइटों को डिप्लॉय करने के कई तरीके हैं. इन तरीकों में अलग-अलग सुविधाएं, क्षमताएं, और कंट्रोल के लेवल शामिल हैं. Google Compute Engine को GCE (जीसीई) भी कहा जाता है. यह किसी वेबसाइट को चलाने के लिए इस्तेमाल होने वाले इंफ़्रास्ट्रक्चर पर बेहतर कंट्रोल देता है. हालांकि, Google Kubernetes Engines (GKE), Google App Engine (GAE) या दूसरे सॉफ़्टवेयर की तुलना में इसे बेहतर तरीके से काम करने की ज़रूरत होती है. Compute Engine की मदद से, हमारे पास इन्फ़्रास्ट्रक्चर की बारीकियां कंट्रोल होती हैं. इनमें वर्चुअल मशीनें, लोड बैलेंसर वगैरह शामिल हैं. आज हम सैंपल ऐप्लिकेशन, Fancy Store की ई-कॉमर्स वेबसाइट लॉन्च करेंगे, ताकि आप यह दिखा सकें कि वेबसाइट को कंप्यूट इंजन की मदद से किस तरह डिप्लॉय और स्केल किया जा सकता है.

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

कोडलैब के आखिर में, हमारे पास मैनेज किए जाने वाले इंस्टेंस ग्रुप में इंस्टेंस होंगे. इनकी मदद से, हमारी वेबसाइट के लिए ऑटोहीलिंग, लोड बैलेंसिंग, ऑटो-स्केलिंग, और रोलिंग अपडेट उपलब्ध होंगे.

ज़रूरी बातें

अपने-आप काम करने वाला एनवायरमेंट सेट अप

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

10-02-2016 का स्क्रीनशॉट 12:45:26.png

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

इसके बाद, आपको Google Cloud के संसाधनों का इस्तेमाल करने के लिए, Cloud Console में बिलिंग को चालू करना होगा.

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

Google Cloud Platform के नए उपयोगकर्ता, 300 डॉलर का मुफ़्त ट्रायल पा सकते हैं.

कंप्यूट इंजन API सक्षम करें

इसके बाद, आपको Compute Engine API चालू करना होगा. एपीआई को चालू करने के लिए, आपको एपीआई की सेवा की शर्तें और बिलिंग की ज़िम्मेदारी स्वीकार करनी होगी.

Google क्लाउड शेल

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

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

Google Cloud Shell को चालू करने के लिए, डेवलपर कंसोल से सबसे ऊपर दाईं ओर मौजूद बटन पर क्लिक करें. प्रावधान करने और आस-पास के सिस्टम से कनेक्ट करने में, कुछ ही समय लगेगा:

CloudShell.png को चालू करें

& & दिया को Cloud Shell" बटन पर क्लिक करें:

14-06-2017 को सुबह 10.13.43 बजे के लिए स्क्रीन शॉट

क्लाउड शेल से कनेक्ट होने के बाद, आपको दिखेगा कि पहले से ही आपकी पुष्टि हो चुकी है और प्रोजेक्ट पहले से ही PROJECT_ID पर सेट है :

gcloud auth list

कमांड आउटपुट

Credentialed accounts:
 - <myaccount>@<mydomain>.com (active)
gcloud config list project

कमांड आउटपुट

[core]
project = <PROJECT_ID>

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

echo $GOOGLE_CLOUD_PROJECT

कमांड आउटपुट

<PROJECT_ID>

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

gcloud config set project <PROJECT_ID>

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

Project_ID.png

अहम जानकारी: आखिर में, डिफ़ॉल्ट ज़ोन और प्रोजेक्ट कॉन्फ़िगरेशन सेट करें:

gcloud config set compute/zone us-central1-f

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

GCS बकेट बनाएं

हम अपने पहले से मौजूद कोड के साथ-साथ अपने स्टार्टअप स्क्रिप्ट को रखने के लिए भी Google Cloud Storage बकेट का इस्तेमाल करेंगे. Cloud Shell के अंदर से, एक नया GCS बकेट बनाने के लिए नीचे दिया गया तरीका अपनाएं:

gsutil mb gs://fancy-store-$DEVSHELL_PROJECT_ID

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

प्रोजेक्ट में कोड स्टोर करने की जगह को क्लोन करने के लिए, नीचे दिए गए बटन पर क्लिक करें. साथ ही, Cloud Shell और पहले से मौजूद कोड एडिटर भी खोलें.

Cloud Shell कमांड प्रॉम्प्ट में, कोड का शुरुआती बिल्ड चलाएं, ताकि ऐप्लिकेशन स्थानीय तौर पर चल सके. इस स्क्रिप्ट को चलने में कुछ मिनट लग सकते हैं.

./setup.sh

हम पूरी जांच-पड़ताल करें और हमारे आवेदन की जांच करें. हमारा वेब सर्वर शुरू करने के लिए, नीचे दिए गए निर्देश चलाएं:

cd microservices
npm start

आउटपुट:

Products microservice listening on port 8092!
Frontend microservice listening on port 8090!
Orders microservice listening on port 8091!

आप वेब की झलक दिखाने वाले आइकॉन पर क्लिक करके, &पोर्ट कोट करें&कोटेशन चुनें और फ़्रंटएंड माइक्रोसेवा: 8090 का पोर्ट डालकर अपने ऐप्लिकेशन की झलक देख सकते हैं. &कोटेशन&झलक बदलें चुनें.

इससे एक नई विंडो खुल जाएगी, जहां आप फ़ैंसी स्टोर का फ़्रंटएंड देख सकते हैं!

आप वेबसाइट देखने के बाद इस विंडो को बंद कर सकते हैं और वेब सर्वर प्रोसेस बंद कर सकते हैं. इसके लिए, टर्मिनल विंडो में CTRL+C दबाएं.

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

  1. इंस्टेंस को कॉन्फ़िगर करने के लिए, स्टार्टअप स्क्रिप्ट बनाना
  2. सोर्स कोड का क्लोन बनाएं और Google Cloud Storage पर अपलोड करें
  3. बैकएंड माइक्रोसेवाएं होस्ट करने के लिए कंप्यूट इंजन इंस्टेंस का इस्तेमाल करें
  4. बैकएंड माइक्रोसेवाएं इंस्टेंस का इस्तेमाल करने के लिए फ़्रंटएंड कोड फिर से कॉन्फ़िगर करें
  5. फ़्रंटएंड माइक्रोसेवा को होस्ट करने के लिए कंप्यूट इंजन इंस्टेंस को डिप्लॉय करें
  6. संचार की अनुमति देने के लिए नेटवर्क कॉन्फ़िगर करें

स्टार्टअप स्क्रिप्ट बनाएं

इंस्टेंस को अपनी पसंद के मुताबिक अपने-आप कॉन्फ़िगर करने के लिए, हम एक स्टार्टअप स्क्रिप्ट का इस्तेमाल करेंगे. यह स्क्रिप्ट निर्देश देगी कि हर बार शुरू करने पर क्या करना है. Cloud Shell के कोड एडिटर में, monolith-to-microservices फ़ोल्डर पर जाएं और &कोटेशन startup-script.sh&kot; नाम वाली फ़ाइल बनाएं.

इस नई फ़ाइल में, नीचे दिया गया कोड चिपकाएं. पेस्ट करने के बाद हम कुछ कोड में बदलाव करेंगे.

#!/bin/bash

# Install logging monitor. The monitor will automatically pick up logs sent to
# syslog.
curl -s "https://storage.googleapis.com/signals-agents/logging/google-fluentd-install.sh" | bash
service google-fluentd restart &

# Install dependencies from apt
apt-get update
apt-get install -yq ca-certificates git build-essential supervisor psmisc

# Install nodejs
mkdir /opt/nodejs
curl https://nodejs.org/dist/v8.12.0/node-v8.12.0-linux-x64.tar.gz | tar xvzf - -C /opt/nodejs --strip-components=1
ln -s /opt/nodejs/bin/node /usr/bin/node
ln -s /opt/nodejs/bin/npm /usr/bin/npm

# Get the application source code from the Google Cloud Storage bucket.
mkdir /fancy-store
gsutil -m cp -r gs://fancy-store-[DEVSHELL_PROJECT_ID]/monolith-to-microservices/microservices/* /fancy-store/

# Install app dependencies.
cd /fancy-store/
npm install

# Create a nodeapp user. The application will run as this user.
useradd -m -d /home/nodeapp nodeapp
chown -R nodeapp:nodeapp /opt/app

# Configure supervisor to run the node app.
cat >/etc/supervisor/conf.d/node-app.conf << EOF
[program:nodeapp]
directory=/fancy-store
command=npm start
autostart=true
autorestart=true
user=nodeapp
environment=HOME="/home/nodeapp",USER="nodeapp",NODE_ENV="production"
stdout_logfile=syslog
stderr_logfile=syslog
EOF

supervisorctl reread
supervisorctl update

अब, एडिटर में, [DEVSHELL_PROJECT_ID] टेक्स्ट ढूंढें और उसे नीचे दिए गए निर्देश के आउटपुट से बदलें:

echo $DEVSHELL_PROJECT_ID

आउटपुट का उदाहरण:

my-gce-codelab-253520

startup-script.sh में मौजूद कोड की लाइन अब एक जैसी होनी चाहिए:

gs://fancy-store-my-gce-codelab-253520/monolith-to-microservices/microservices/* /fancy-store/

स्टार्टअप स्क्रिप्ट में ये टास्क पूरे किए जाते हैं:

  • लॉगिंग एजेंट इंस्टॉल करता है. एजेंट, ISlog से अपने-आप लॉग इकट्ठा करता है.
  • Node.js और सुपरवाइज़र को इंस्टॉल करता है. निगरानी करने वाला, ऐप्लिकेशन को डेमन के तौर पर चलाता है.
  • GCS बकेट की मदद से ऐप्लिकेशन और #39; का सोर्स कोड क्लोन करें और यह डिपेंडेंसी इंस्टॉल करता है.
  • ऐप्लिकेशन चलाने के लिए सुपरवाइज़र को कॉन्फ़िगर करता है. सुपरवाइज़र से यह पक्का होता है कि अगर ऐप्लिकेशन अचानक बंद हो जाता है या कोई एडमिन या प्रोसेस उसे रोक देता है, तो वह रीस्टार्ट हो जाता है. यह लॉग करने वाले एजेंट के लिए ऐप्लिकेशन और # stdout और stderr को ISlog को इकट्ठा करता है, ताकि वह इसे इकट्ठा कर सके.

अब बनाई गई स्टार्टअप-script.sh फ़ाइल को पहले बनाई गई हमारी GCS बकेट में कॉपी करें:

gsutil cp startup-script.sh gs://fancy-store-$DEVSHELL_PROJECT_ID

इसे अब https://storage.googleapis.com/[BUCKET_NAME]/startup-script.sh पर ऐक्सेस किया जा सकेगा. [BUCKET_NAME], Cloud Storage बकेट का नाम दिखाता है. इसे डिफ़ॉल्ट रूप से सिर्फ़ अनुमति पाए हुए उपयोगकर्ता और सेवा खाते देख सकेंगे, इसलिए किसी वेब ब्राउज़र से इसे ऐक्सेस नहीं किया जा सकेगा. Google Compute Engine इंस्टेंस, अपने सेवा खाते से इसे अपने-आप ऐक्सेस कर पाएंगे.

कोड को GCS बकेट में कॉपी करें

इंस्टेंस लॉन्च होने पर, वे जीसीएस बकेट से कोड लेते हैं, ताकि हम कोड की फ़ाइल के कुछ कॉन्फ़िगरेशन वैरिएबल को .env' फ़ाइल में स्टोर कर सकें.

क्लोक किए गए कोड को GCS बकेट में कॉपी करें:

cd ~
rm -rf monolith-to-microservices/*/node_modules
gsutil -m cp -r monolith-to-microservices gs://fancy-store-$DEVSHELL_PROJECT_ID/

बैकएंड इंस्टेंस डिप्लॉय करें

पहला इंस्टेंस हम बैकएंड इंस्टेंस के तौर पर इस्तेमाल करेंगे. इसमें ऑर्डर और प्रॉडक्ट की माइक्रोसेवाएं शामिल होंगी.

F1-माइक्रो इंस्टेंस बनाने के लिए, Cloud Shell में यह कमांड एक्ज़ीक्यूट करें. इसे हमारा पहले से बनाया हुआ शुरुआती स्क्रिप्ट इस्तेमाल करने के लिए कॉन्फ़िगर किया गया है. साथ ही, इसे &&tt;बैकएंड&कोटेशन; के तौर पर भी टैग किया गया है, ताकि हम बाद में खास फ़ायरवॉल नियमों को लागू कर सकें:

gcloud compute instances create backend \
    --machine-type=f1-micro \
    --image=debian-9-stretch-v20190905 \
    --image-project=debian-cloud \
    --tags=backend \
    --metadata=startup-script-url=https://storage.googleapis.com/fancy-store-$DEVSHELL_PROJECT_ID/startup-script.sh

बैकएंड के लिए कनेक्शन कॉन्फ़िगर करें

ऐप्लिकेशन के फ़्रंटएंड को डिप्लॉय करने से पहले, हमें कॉन्फ़िगरेशन को अपडेट करना होता है, ताकि बैकएंड को हाल ही में डिप्लॉय किया जा सके.

बैकएंड का बाहरी आईपी पता पाएं, जिसे बैकएंड इंस्टेंस के लिए EXTERNAL_IP टैब के नीचे दिए गए निर्देश से देखा जा सकता है:

gcloud compute instances list

आउटपुट का उदाहरण:

NAME     ZONE           MACHINE_TYPE  PREEMPTIBLE  INTERNAL_IP  EXTERNAL_IP   STATUS
backend  us-central1-a  f1-micro                   10.128.0.2   34.68.223.88  RUNNING

Cloud Shell's Code Editor में, मोनोलिथ-टू-माइक्रोडेटा → प्रतिक्रिया वाले ऐप्लिकेशन फ़ोल्डर पर जाएं. कोड एडिटर के मेन्यू में जाकर, छिपी हुई फ़ाइलें देखें → टॉगल करें को चुनें, ताकि आप .env' फ़ाइल देख सकें.

बैकएंड के बाहरी आईपी पर ले जाने के लिए .env' फ़ाइल में बदलाव करें. [BACKEND_ADDRESS] नीचे दिए गए बैकएंड इंस्टेंस के बाहरी आईपी पते को दिखाता है, जो ऊपर दिए गए gcloud निर्देश से तय किया जाता है. 

REACT_APP_ORDERS_URL=http://[BACKEND_ADDRESS]:8091/api/orders
REACT_APP_PRODUCTS_URL=http://[BACKEND_ADDRESS]:8092/api/products

प्रतिक्रिया वाला ऐप्लिकेशन फिर से बनाएं. इससे फ़्रंटएंड कोड अपडेट हो जाएगा:

npm install && npm run-script build

ऐप्लिकेशन कोड को वापस GCS बकेट में कॉपी करें:

cd ~
rm -rf monolith-to-microservices/*/node_modules
gsutil -m cp -r monolith-to-microservices gs://fancy-store-$DEVSHELL_PROJECT_ID/

फ़्रंटएंड इंस्टेंस डिप्लॉय करें

अब कोड कॉन्फ़िगर हो जाने के बाद, हम फ़्रंटएंड इंस्टेंस लागू कर सकते हैं. फ़्रंटएंड इंस्टेंस को पहले मिलते-जुलते निर्देश के साथ लागू करने के लिए, इसे एक्ज़ीक्यूट करें. हालांकि, इस इंस्टेंस को फ़ायरवॉल के मकसद से "frontend&kot; के तौर पर टैग किया गया है.

gcloud compute instances create frontend \
    --machine-type=f1-micro \
    --image=debian-9-stretch-v20190905 \
    --image-project=debian-cloud \
    --tags=frontend \
    --metadata=startup-script-url=https://storage.googleapis.com/fancy-store-$DEVSHELL_PROJECT_ID/startup-script.sh

नेटवर्क कॉन्फ़िगर करें

फ़्रंटएंड के लिए पोर्ट 8090 और बैकएंड के लिए पोर्ट 8091-8092 के ऐक्सेस की अनुमति देने के लिए फ़ायरवॉल के नियम बनाएं. फ़ायरवॉल के ये निर्देश, ऐप्लिकेशन बनाने के लिए इंस्टेंस के दौरान असाइन किए गए टैग का इस्तेमाल करते हैं.

gcloud compute firewall-rules create fw-fe \
    --allow tcp:8090 \
    --target-tags=frontend
gcloud compute firewall-rules create fw-be \
    --allow tcp:8091-8092 \
    --target-tags=backend

वेबसाइट अब काम करनी चाहिए. फ़्रंटएंड के बाहरी आईपी पर जाएं. यह पता फ़्रंटएंड इंस्टेंस के EXTERNAL_IP को खोजकर तय किया जा सकता है:

gcloud compute instances list

आउटपुट का उदाहरण:

NAME      ZONE           MACHINE_TYPE  PREEMPTIBLE  INTERNAL_IP  EXTERNAL_IP      STATUS
backend   us-central1-a  f1-micro                   10.128.0.2   104.198.235.171  RUNNING
frontend  us-central1-a  f1-micro                   10.128.0.3   34.69.141.9      RUNNING

वेबसाइट को ऐक्सेस करने के लिए, http://[FRONTEND_ADDRESS]:8090 पर जाएं. यहां FR_T का मतलब [FRONTEND_ADDRESS] है. इंस्टेंस को शुरू और कॉन्फ़िगर होने में कुछ मिनट लग सकते हैं.

प्रॉडक्ट और ऑर्डर पेज पर जाएं. इन्हें भी काम करना चाहिए.

हमारे ऐप्लिकेशन को स्केल करने की अनुमति देने के लिए मैनेज किए गए इंस्टेंस ग्रुप बनाए जाएंगे और इंस्टेंस टेंप्लेट के तौर पर फ़्रंटएंड और बैकएंड इंस्टेंस का इस्तेमाल करेंगे.

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

स्रोत इंस्टेंस से इंस्टेंस टेंप्लेट बनाएं

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

इंस्टेंस टेंप्लेट बनाने के लिए, हम पहले बनाए गए मौजूदा इंस्टेंस का इस्तेमाल करेंगे. सबसे पहले, हमें दोनों इंस्टेंस को बंद करना होगा:

gcloud compute instances stop frontend
gcloud compute instances stop backend

इसके बाद, हम सोर्स इंस्टेंस से इंस्टेंस टेंप्लेट बना सकते हैं:

gcloud compute instance-templates create fancy-fe \
    --source-instance=frontend \
    --source-instance-zone=us-central1-a
gcloud compute instance-templates create fancy-be \
    --source-instance=backend \
    --source-instance-zone=us-central1-a

पुष्टि करें कि इंस्टेंस टेंप्लेट बनाए गए हैं:

gcloud compute instance-templates list

आउटपुट का उदाहरण:

NAME      MACHINE_TYPE  PREEMPTIBLE  CREATION_TIMESTAMP
fancy-be  f1-micro                   2019-09-12T07:52:57.544-07:00
fancy-fe  f1-micro                   2019-09-12T07:52:48.238-07:00

मैनेज किया जाने वाला इंस्टेंस ग्रुप बनाएं

हम दो मैनेज किए गए इंस्टेंस ग्रुप बनाएंगे, एक फ़्रंटएंड के लिए और दूसरा बैकएंड के लिए. ये प्रबंधित इंस्टेंस ग्रुप, पहले बनाए गए इंस्टेंस टेंप्लेट का इस्तेमाल करेंगे. साथ ही, शुरू करने के लिए हर ग्रुप में दो इंस्टेंस के लिए कॉन्फ़िगर किए जाएंगे. इंस्टेंस को "base-instance-name" के आधार पर अपने-आप नाम दिया जाएगा. साथ ही, यह किसी भी क्रम में जोड़े गए वर्णों से तय होगा.

gcloud compute instance-groups managed create fancy-fe-mig \
    --base-instance-name fancy-fe \
    --size 2 \
    --template fancy-fe
gcloud compute instance-groups managed create fancy-be-mig \
    --base-instance-name fancy-be \
    --size 2 \
    --template fancy-be

हमारे ऐप्लिकेशन के लिए, फ़्रंटएंड माइक्रोसेवा पोर्ट 8090 पर चलती है और बैकएंड माइक्रोसेवाएं ऑर्डर के लिए पोर्ट 8091 पर और प्रॉडक्ट के लिए पोर्ट 8092 पर चलती हैं. ये गैर-मानक पोर्ट होते हैं, इसलिए हम इनकी पहचान करने के लिए नाम वाले पोर्ट तय करेंगे. नाम वाले पोर्ट, की:वैल्यू पेयर का मेटाडेटा होते हैं. इसमें, सेवा का नाम और उस पोर्ट के बारे में बताया जाता है जिस पर यह #33 चलता है. नाम वाले पोर्ट किसी इंस्टेंस ग्रुप को असाइन किए जा सकते हैं. इससे पता चलता है कि यह सेवा, ग्रुप के सभी इंस्टेंस पर उपलब्ध है. इस जानकारी का इस्तेमाल एचटीटीपी लोड बैलेंसिंग सेवा करती है, जिसे बाद में कॉन्फ़िगर किया जाएगा. 

gcloud compute instance-groups set-named-ports fancy-fe-mig \ 
    --named-ports frontend:8090
gcloud compute instance-groups set-named-ports fancy-be-mig \
    --named-ports orders:8091,products:8092

अपने-आप सही होने की सुविधा कॉन्फ़िगर करें

ऐप्लिकेशन की उपलब्धता को बेहतर बनाने और उसकी पुष्टि करने के लिए, आप मैनेज किए गए इंस्टेंस ग्रुप के लिए अपने-आप उपचार करने की नीति कॉन्फ़िगर कर सकते हैं.

अपने-आप उपचार की नीति यह पुष्टि करने के लिए ऐप्लिकेशन पर आधारित स्वास्थ्य जांच पर निर्भर करती है कि कोई ऐप्लिकेशन उम्मीद के मुताबिक जवाब दे रहा है या नहीं. किसी ऐप्लिकेशन के जवाब की जांच करने से यह पुष्टि नहीं होती कि कोई इंस्टेंस RUNNING की स्थिति में है या नहीं. यह डिफ़ॉल्ट व्यवहार है.

स्वास्थ्य से जुड़ी जांच बनाएं, अगर यह फ़्रंटएंड और बैकएंड के लिए बार-बार तीन बार खराब हुई, तो इसे ठीक करें:

gcloud compute health-checks create http fancy-fe-hc \
    --port 8090 \
    --check-interval 30s \
    --healthy-threshold 1 \
    --timeout 10s \
    --unhealthy-threshold 3
gcloud compute health-checks create http fancy-be-hc \
    --port 8091 \
    --request-path=/api/orders \
    --check-interval 30s \
    --healthy-threshold 1 \
    --timeout 10s \
    --unhealthy-threshold 3

फ़ायरवॉल की सुविधा का नियम बनाएं, ताकि पोर्ट की जांच 8090-8091 में मौजूद माइक्रो सेवाओं से स्वास्थ्य की जांच करने वाले जांच कर सकें:

gcloud compute firewall-rules create allow-health-check \
    --allow tcp:8090-8091 \
    --source-ranges 130.211.0.0/22,35.191.0.0/16 \
    --network default

स्वास्थ्य से जुड़ी सेवाओं को उनसे जुड़ी सेवाओं पर लागू करें:

gcloud compute instance-groups managed update fancy-fe-mig \
    --health-check fancy-fe-hc \
    --initial-delay 300
gcloud compute instance-groups managed update fancy-be-mig \
    --health-check fancy-be-hc \
    --initial-delay 300

सिम्युलेशन विफल

स्वास्थ्य जांच की सुविधा की पुष्टि करने के लिए, इंस्टेंस में लॉग इन करें और सेवाओं को बंद करें. इंस्टेंस का नाम ढूंढने के लिए, नीचे दिया गया तरीका अपनाएं:

gcloud compute instance-groups list-instances fancy-fe-mig

यहां से, किसी एक इंस्टेंस में शेल सुरक्षित करें, जहां INSTANCE_NAME सूची के इंस्टेंस में से एक है:

gcloud compute ssh [INSTANCE_NAME]

इंस्टेंस के साथ, ऐप्लिकेशन बंद करने के लिए सुपरवाइज़र का इस्तेमाल करें:

sudo supervisorctl stop nodeapp; sudo killall node

इंस्टेंस से बाहर निकलें:

exit

रिपेयर से जुड़ी कार्रवाइयों पर नज़र रखें:

watch -n 5 gcloud compute operations list \
--filter='operationType~compute.instances.repair.*'

नीचे दिए गए उदाहरण का आउटपुट देखें:

NAME                                                  TYPE                                       TARGET                                 HTTP_STATUS  STATUS  TIMESTAMP
repair-1568314034627-5925f90ee238d-fe645bf0-7becce15  compute.instances.repair.recreateInstance  us-central1-a/instances/fancy-fe-1vqq  200          DONE    2019-09-12T11:47:14.627-07:00

रिपेयर का पता लगने पर, स्मार्टवॉच के निर्देश से बाहर निकलने के लिए Ctrl+C दबाएं. इस समय, मैनेज किए जा रहे इंस्टेंस ग्रुप को ठीक करने के लिए, यह इंस्टेंस फिर से बनाएगा.

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

https://cloud.google.com/load-balancing/docs/load-balancing-overview.

HTTP(S) लोड बैलेंसर बनाएं

Google Cloud Platform कई तरह के लोड बैलेंसर ऑफ़र करता है, लेकिन हम अपने ट्रैफ़िक के लिए एचटीटीपी बैलेंस का इस्तेमाल करेंगे. एचटीटीपी लोड बैलेंसर को इस तरह बनाया जाता है:

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

ऐसी स्वास्थ्य जांच करें, जिसका इस्तेमाल यह पता लगाने के लिए किया जाए कि कौनसे इंस्टेंस हर सेवा के लिए ट्रैफ़िक दिखा सकते हैं. 

gcloud compute http-health-checks create fancy-fe-frontend-hc \
  --request-path / \
  --port 8090
gcloud compute http-health-checks create fancy-be-orders-hc \
  --request-path /api/orders \
  --port 8091
gcloud compute http-health-checks create fancy-be-products-hc \
  --request-path /api/products \
  --port 8092

ऐसी बैकएंड सेवाएं बनाएं, जो लोड-संतुलित ट्रैफ़िक के लिए टारगेट हों. यह बैकएंड सेवाएं, स्वास्थ्य की जांच और हमारे बनाए गए पोर्ट का इस्तेमाल करेंगी.

gcloud compute backend-services create fancy-fe-frontend \
  --http-health-checks fancy-fe-frontend-hc \
  --port-name frontend \
  --global
gcloud compute backend-services create fancy-be-orders \
  --http-health-checks fancy-be-orders-hc \
  --port-name orders \
  --global
gcloud compute backend-services create fancy-be-products \
  --http-health-checks fancy-be-products-hc \
  --port-name products \
  --global

बैकएंड सेवाएं जोड़ें:

gcloud compute backend-services add-backend fancy-fe-frontend \
  --instance-group fancy-fe-mig \
  --instance-group-zone us-central1-a \
  --global
gcloud compute backend-services add-backend fancy-be-orders \
  --instance-group fancy-be-mig \
  --instance-group-zone us-central1-a \
  --global
gcloud compute backend-services add-backend fancy-be-products \
  --instance-group fancy-be-mig \
  --instance-group-zone us-central1-a \
  --global

यूआरएल मैप बनाने के लिए. यूआरएल मैप से यह पता चलता है कि कौनसे यूआरएल, बैकएंड सेवाओं पर ले जाते हैं.

gcloud compute url-maps create fancy-map \
  --default-service fancy-fe-frontend

‘/api/orders' और ‘/api/products' पाथ को उनसे जुड़ी सेवाओं पर रूट करने की अनुमति देने के लिए पाथ मैचर बनाएं:

gcloud compute url-maps add-path-matcher fancy-map \
   --default-service fancy-fe-frontend \
   --path-matcher-name orders \
   --path-rules "/api/orders=fancy-be-orders,/api/products=fancy-be-products"

बनाए गए प्रॉक्सी को मैप बनाने के लिए प्रॉक्सी बनाएं.

gcloud compute target-http-proxies create fancy-proxy \
  --url-map fancy-map

डेटा फ़ॉरवर्ड करने का ऐसा नियम बनाएं जो सार्वजनिक आईपी पता और प्रॉक्सी सर्वर से जुड़ा हो.

gcloud compute forwarding-rules create fancy-http-rule \
  --global \
  --target-http-proxy fancy-proxy \
  --ports 80

कॉन्फ़िगरेशन अपडेट करें

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

Cloud Shell से, प्रतिक्रिया वाले ऐप्लिकेशन फ़ोल्डर में बदलें जिसमें कॉन्फ़िगरेशन वाला .env' फ़ाइल मौजूद है :

cd ~/monolith-to-microservices/react-app/

लोड बैलेंसर के लिए आईपी पता ढूंढें:

gcloud compute forwarding-rules list --global

आउटपुट का उदाहरण:

NAME                    REGION  IP_ADDRESS     IP_PROTOCOL  TARGET
fancy-http-rule          34.102.237.51  TCP          fancy-proxy

लोड बैलेंसर के पब्लिक आईपी की तरफ़ पॉइंट करने के लिए, अपने पसंदीदा टेक्स्ट एडिटर (जैसे कि नैनो) से .env में बदलाव करें. [LB_IP], ऊपर दिए गए बैकएंड इंस्टेंस के बाहरी आईपी पते के बारे में बताता है. 

REACT_APP_ORDERS_URL=http://[LB_IP]/api/orders
REACT_APP_PRODUCTS_URL=http://[LB_IP]/api/products

प्रतिक्रिया वाला ऐप्लिकेशन फिर से बनाएं. इससे फ़्रंटएंड कोड अपडेट हो जाएगा:

npm install && npm run-script build

ऐप्लिकेशन कोड को वापस GCS बकेट में कॉपी करें:

cd ~
rm -rf monolith-to-microservices/*/node_modules
gsutil -m cp -r monolith-to-microservices gs://fancy-store-$DEVSHELL_PROJECT_ID/

फ़्रंटएंड इंस्टेंस अपडेट करें

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

gcloud compute instance-groups managed rolling-action restart fancy-fe-mig \
    --max-unavailable 100%

वेबसाइट की जांच करें

मैनेज किए जा रहे इंस्टेंस ग्रुप की स्थिति तब तक जांचें, जब तक कि सूची में इंस्टेंस न दिखें:

watch -n 5 gcloud compute instance-groups list-instances fancy-fe-mig

सूची में आइटम दिखने के बाद, Ctrl+C दबाकर स्मार्टवॉच के निर्देश से बाहर निकलें.

पुष्टि करें कि सेवा की स्थिति अच्छी है:

gcloud compute backend-services get-health fancy-fe-frontend --global

आउटपुट का उदाहरण:

---
backend: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/us-central1-a/instanceGroups/fancy-fe-mig
status:
  healthStatus:
  - healthState: HEALTHY
    instance: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/us-central1-a/instances/fancy-fe-x151
    ipAddress: 10.128.0.7
    port: 8090
  - healthState: HEALTHY
    instance: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/us-central1-a/instances/fancy-fe-cgrt
    ipAddress: 10.128.0.11
    port: 8090
  kind: compute#backendServiceGroupHealth

इसके बाद, ऐप्लिकेशन को http://[LB_IP] के ज़रिए ऐक्सेस किया जा सकेगा, जहां [LB_IP] आईपी बैलेंस के लिए तय किया गया IP_ADDRESS है. इसे नीचे दिए गए निर्देश से ढूंढा जा सकता है:

gcloud compute forwarding-rules list --global

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

इस्तेमाल करके अपने-आप साइज़ बदलें

ऑटोस्केलिंग से जुड़ी नीति बनाने के लिए, Cloud Shell में यह कोड लागू करें. ये निर्देश मैनेज किए गए इंस्टेंस ग्रुप पर ऑटोस्केलर बनाते हैं, जो इस्तेमाल के 60% से ज़्यादा होने पर, इंस्टेंस अपने-आप जोड़ देते हैं. साथ ही, लोड बैलेंसर के 60% से कम इस्तेमाल होने पर, इंस्टेंस भी हटा दिए जाते हैं.

gcloud compute instance-groups managed set-autoscaling \
  fancy-fe-mig \
  --max-num-replicas 5 \
  --target-load-balancing-utilization 0.60
gcloud compute instance-groups managed set-autoscaling \
  fancy-be-mig \
  --max-num-replicas 5 \
  --target-load-balancing-utilization 0.60

कॉन्टेंट डिलीवरी नेटवर्क चालू करें

स्केलिंग में मदद करने वाली एक और सुविधा, Cloud CDN को चालू करना है, जो कॉन्टेंट डिलीवरी नेटवर्क की सेवा है. इसकी मदद से, फ़्रंटएंड को कैश मेमोरी में सेव किया जाता है. ऐसा करने के लिए, हम अपनी फ़्रंटएंड सेवा पर यह निर्देश लागू कर सकते हैं:

gcloud compute backend-services update fancy-fe-frontend \
    --enable-cdn --global

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

इसके अलावा, अगर GFE को अनुरोध के लिए कैश मेमोरी में सेव किया गया कोई जवाब नहीं मिलता, तो GFE सीधे बैकएंड में अनुरोध करता है. अगर इस अनुरोध का जवाब कैश करने लायक है, तो जीएफ़ई जवाब को Cloud CDN कैश में स्टोर करता है ताकि बाद के अनुरोधों के लिए कैश का इस्तेमाल किया जा सके.

इंस्टेंस टेंप्लेट को अपडेट करना

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

इस सेक्शन में, हम फ़्रंटएंड इंस्टेंस अपडेट करेंगे. यह हमारे इंस्टेंस टेंप्लेट के आधार पर काम करता है. अपडेट के दौरान, हम इंस्टेंस टेंप्लेट ##39

अगर फ़्रंटएंड इंस्टेंस पहले से नहीं चल रहा है, तो उसे शुरू करें:

gcloud compute instances start frontend

इंस्टेंस में शेल सुरक्षित करें:

gcloud compute ssh frontend

इंस्टेंस के अंदर, यह अपडेट करने के लिए फ़ाइल को अपडेट करें:{0/}

echo "Updated" > ~/updated_proof

इंस्टेंस से बाहर निकलें:

exit

इंस्टेंस को शट डाउन करें:

gcloud compute instances stop frontend

नया इंस्टेंस टेंप्लेट बनाना:

gcloud compute instance-templates create fancy-fe-new \
    --source-instance=frontend \
    --source-instance-zone=us-central1-a

मैनेज किए गए इंस्टेंस ग्रुप में, अपडेट किया गया इंस्टेंस टेंप्लेट रोल आउट करें:

gcloud compute instance-groups managed rolling-action start-update fancy-fe-mig \
    --version template=fancy-fe-new

अपडेट की स्थिति पर नज़र रखना:

gcloud compute instance-groups managed list-instances fancy-fe-mig

एक बार इंस्टेंस के INUNANCE_ होने पर, जहां INSTANCE_Template को fancy-fe-new पर सेट किया गया हो, नए इंस्टेंस में लॉग इन करें और देखें कि क्या “updated_proof' फ़ाइल मौजूद है, जहां [VM_NAME] नया बना हुआ इंस्टेंस है:

gcloud compute ssh [VM_NAME]

अगर 'update_proof' फ़ाइल अब मैनेज किए जा रहे ग्रुप इंस्टेंस पर मौजूद है, तो अपडेट को पुश कर दिया गया है.

वेबसाइटों में बदलाव करना

आपकी मार्केटिंग टीम ने आपसे अपनी साइट का होम पेज बदलने के लिए कहा है. उन्हें लगता है कि आपकी कंपनी के बारे में और जानकारी देने वाली जानकारी होनी चाहिए. इस सेक्शन में, हम मार्केटिंग टीम को खुश करने के लिए होम पेज पर कुछ टेक्स्ट जोड़ेंगे! ऐसा लगता है कि हमारे किसी डेवलपर ने फ़ाइल नाम 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 &amp; 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 install && npm run-script build

इसके बाद, हम इस कोड को अपनी GCS बकेट में फिर से पुश करते हैं:

cd ~
rm -rf monolith-to-microservices/*/node_modules
gsutil -m cp -r monolith-to-microservices gs://fancy-store-$DEVSHELL_PROJECT_ID/

रोलिंग अपडेट की मदद से बदलाव करें

अब हम अपडेट पाने के लिए सभी इंस्टेंस को ज़बरदस्ती रीस्टार्ट कर सकते हैं:

gcloud compute instance-groups managed rolling-action restart fancy-fe-mig

इस नए तरीके से रीस्टार्ट होने से, बफ़र के दौरान इंस्टेंस फिर से चालू होंगे, ताकि ऐक्सेस पर कोई असर न हो. कंसोल के ज़रिए इंस्टेंस की साइकलिंग पर नज़र रखें. अपडेट करते समय, स्थिति पूरी तरह बदल जाएगी. इसके पूरा होने के बाद, मैनेज किए गए इंस्टेंस ग्रुप, Compute Engine -> इंस्टेंस ग्रुप के तहत तैयार के तौर पर दिखेंगे:

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

gcloud projects delete [PROJECT_ID]

पूछे जाने पर &कोटेशन दर्ज करके मिटाने की पुष्टि करें.

आपने GCE (जीसीई) पर अपनी वेबसाइट को डिप्लॉय किया, बढ़ाया, और अपडेट किया. अब आपको Compute Engine, मैनेज किए गए इंस्टेंस ग्रुप, लोड बैलेंसर, और स्वास्थ्य जांच का अनुभव मिल गया है!