इस पेज का अनुवाद Cloud Translation API से किया गया है.

Compute Engine की मदद से, Google Cloud में वेब ऐप्लिकेशन को होस्ट और स्केल करें

1. परिचय

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

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

Compute Engine इंस्टेंस बनाने का तरीका
सोर्स इंस्टेंस से इंस्टेंस टेंप्लेट बनाने का तरीका
मैनेज किए जा रहे इंस्टेंस ग्रुप बनाने का तरीका
स्वास्थ्य की जांच और अपने-आप ठीक होने की सुविधा सेट अप करने का तरीका
एचटीटीपी या एचटीटीपीएस लोड बैलेंसिंग बनाने का तरीका
लोड बैलेंसर के लिए हेल्थ चेक कैसे तैयार करें
कैश मेमोरी में सेव करने के लिए, कॉन्टेंट-डिलीवरी नेटवर्क का इस्तेमाल करने का तरीका

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

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

इस लैब में इस्तेमाल किए जाने वाले कॉन्सेप्ट की शुरुआती खास जानकारी के लिए, कृपया नीचे दिया गया कॉन्टेंट देखें:
Google Cloud Platform में आपका स्वागत है - GCP के ज़रूरी फ़ायदे
Google Cloud Compute Engine का इस्तेमाल शुरू करना
Google Cloud Storage का इस्तेमाल शुरू करना
इस्तेमाल शुरू करना: Cloud Shell

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

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

Cloud Console में साइन इन करें और नया प्रोजेक्ट बनाएं या किसी मौजूदा प्रोजेक्ट का फिर से इस्तेमाल करें. अगर आपके पास पहले से Gmail या Google Workspace खाता नहीं है, तो आपको नया खाता बनाना होगा.

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

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

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

Compute Engine API चालू करें

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

Cloud Shell में, Compute Engine API चालू करने के लिए यह तरीका अपनाएं:

gcloud services enable compute.googleapis.com

Cloud Shell

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

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

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

14-06-2017 को 10.13.43 PM.png पर स्क्रीन शॉट लिया गया

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

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

Cloud Storage बकेट बनाएं

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

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

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

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

आपके पास प्रोजेक्ट में कोड रिपॉज़िटरी का अपने-आप क्लोन बनाने का विकल्प है. साथ ही, Cloud Shell और पहले से मौजूद कोड एडिटर को खोलने के लिए, नीचे दिए गए लिंक का इस्तेमाल करें: Cloud Shell में खोलें.

इसके अलावा, Cloud Shell के अंदर नीचे दिए गए निर्देशों का इस्तेमाल करके, मैन्युअल तरीके से रिपॉज़िटरी का क्लोन बनाया जा सकता है:

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

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

./setup.sh

पूरी सावधानी बरतें और अपने ऐप्लिकेशन की जांच करें. अपना वेब सर्वर चालू करने के लिए, यहां दिया गया कमांड चलाएं:

cd microservices
npm start

आउटपुट:

Products microservice listening on port 8082!
Frontend microservice listening on port 8080!
Orders microservice listening on port 8081!

वेब प्रीव्यू आइकॉन पर क्लिक करके और "पोर्ट 8080 पर झलक देखें" को चुनकर अपने ऐप्लिकेशन की झलक देखें.

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

वेबसाइट देखने के बाद, इस विंडो को बंद किया जा सकता है. वेब सर्वर की प्रोसेस रोकने के लिए, टर्मिनल विंडो में Control+C (Macintosh पर Command+C) दबाएं.

4. Compute Engine इंस्टेंस बनाएं

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

इंस्टेंस कॉन्फ़िगर करने के लिए, स्टार्टअप स्क्रिप्ट बनाएं.
सोर्स कोड का क्लोन बनाएं और उसे Cloud Storage में अपलोड करें.
बैकएंड माइक्रोसर्विस को होस्ट करने के लिए, Compute Engine इंस्टेंस डिप्लॉय करें.
बैकएंड माइक्रोसर्विस इंस्टेंस का इस्तेमाल करने के लिए, फ़्रंटएंड कोड को फिर से कॉन्फ़िगर करें.
फ़्रंटएंड माइक्रोसर्विस को होस्ट करने के लिए, Compute Engine इंस्टेंस डिप्लॉय करें.
संचार करने की अनुमति देने के लिए नेटवर्क को कॉन्फ़िगर करें.

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

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

कोड एडिटर खोलने के लिए, Cloud Shell रिबन में पेंसिल आइकॉन पर क्लिक करें.

मोनोलिथ-टू-माइक्रोसर्विस फ़ोल्डर पर जाएं. फ़ाइल पर क्लिक करें > नई फ़ाइल पर क्लिक करें और Start-script.sh नाम की फ़ाइल बनाएं.

नई फ़ाइल में, नीचे दिया गया कोड चिपकाएं, जिनमें से कुछ कोड को चिपकाने के बाद आप उसमें बदलाव करेंगे:

#!/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/

स्टार्टअप स्क्रिप्ट ये काम करती है:

लॉगिंग एजेंट को इंस्टॉल करना, जो syslog से अपने-आप लॉग इकट्ठा करता है
Node.js और Supervisor को इंस्टॉल करना, जो ऐप्लिकेशन को डीमन के तौर पर चलाता है
Cloud Storage बकेट से ऐप्लिकेशन के सोर्स कोड की क्लोनिंग करना और डिपेंडेंसी इंस्टॉल करना
सुपरवाइज़र का कॉन्फ़िगरेशन, जो ऐप्लिकेशन को चलाता है. यह पक्का करता है कि ऐप्लिकेशन अचानक बंद होने या किसी एडमिन या प्रोसेस के बंद होने पर चालू हो

अब बनाई गई Start-script.sh फ़ाइल को, पहले से बनाए गए Cloud Storage बकेट में कॉपी करें:

gsutil cp ~/monolith-to-microservices/startup-script.sh gs://fancy-store-$DEVSHELL_PROJECT_ID

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

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

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

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

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

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

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

एक f1-micro इंस्टेंस बनाने के लिए, Cloud Shell में नीचे दिया गया निर्देश चलाएं. यह इंस्टेंस आपकी पहले बनाई गई स्टार्टअप स्क्रिप्ट का इस्तेमाल करने के लिए कॉन्फ़िगर किया गया है और इसे बैकएंड इंस्टेंस के तौर पर टैग किया गया है, ताकि आप बाद में इस पर फ़ायरवॉल के खास नियम लागू कर सकें:

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 के कोड एडिटर में, मोनोलिथ-टू-माइक्रोसर्विस फ़ोल्डर पर जाएं > प्रतिक्रिया ऐप्लिकेशन इस्तेमाल करें. कोड एडिटर मेन्यू से, व्यू > .env फ़ाइल को देखने के लिए, छिपी हुई फ़ाइलों को टॉगल करें.

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

REACT_APP_ORDERS_URL=http://[BACKEND_ADDRESS]:8081/api/orders
REACT_APP_PRODUCTS_URL=http://[BACKEND_ADDRESS]:8082/api/products

फ़ाइल सेव करें.

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

cd ~/monolith-to-microservices/react-app
npm install && npm run-script build

ऐप्लिकेशन कोड को Cloud Storage बकेट में कॉपी करें:

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

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

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

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

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

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

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

gcloud compute firewall-rules create fw-fe \
    --allow tcp:8080 \
    --target-tags=frontend

gcloud compute firewall-rules create fw-be \
    --allow tcp:8081-8082 \
    --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

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

watch -n 5 curl http://[EXTERNAL_IP]:8080

जब आपको नीचे दिए गए फ़ॉर्मैट से मिलता-जुलता आउटपुट दिखे, तो वेबसाइट तैयार हो जाएगी. वॉच कमांड को रद्द करने के लिए, कमांड प्रॉम्प्ट पर Control+C (Macintosh पर Command+C) दबाएं.

वेबसाइट तक पहुंचने के लिए नए वेब ब्राउज़र टैब की सहायता से http://[FRONTEND_ADDRESS]:8080 पर ब्राउज़ करें, जहां [FRONTEND_ADDRESS] ऊपर दिया गया EXTERNAL_IP है.

प्रॉडक्ट और ऑर्डर वाले पेजों पर जाएं. यहां आपको ये पेज भी दिखेंगे.

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

5. मैनेज किए जा रहे इंस्टेंस ग्रुप बनाएं

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

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

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

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

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

सबसे पहले, आपको दोनों इंस्टेंस बंद करने होंगे.

gcloud compute instances stop frontend

gcloud compute instances stop backend

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

gcloud compute instance-templates create fancy-fe \
    --source-instance=frontend

gcloud compute instance-templates create fancy-be \
    --source-instance=backend

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

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

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

gcloud compute instance-groups set-named-ports fancy-fe-mig \ 
    --named-ports frontend:8080

gcloud compute instance-groups set-named-ports fancy-be-mig \
    --named-ports orders:8081,products:8082

ऑटोहीलिंग कॉन्फ़िगर करें

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

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

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

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

gcloud compute health-checks create http fancy-fe-hc \
    --port 8080 \
    --check-interval 30s \
    --healthy-threshold 1 \
    --timeout 10s \
    --unhealthy-threshold 3

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

स्वास्थ्य जांच की जांच को पोर्ट 8080 और 8081 पर माइक्रोसेवाओं से कनेक्ट करने की अनुमति देने के लिए, फ़ायरवॉल का नियम बनाएं:

gcloud compute firewall-rules create allow-health-check \
    --allow tcp:8080-8081 \
    --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

कोडलैब का इस्तेमाल जारी रखें, ताकि ग्रुप में इंस्टेंस के अपने-आप ठीक होने (ऑटो-हील) के लिए, समय मिल सके. बाद में, आपको गड़बड़ी के आधार पर ऑटोहीलिंग की जांच करने का मौका मिलेगा.

6. लोड बैलेंसर बनाएं

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

Google Cloud में उपलब्ध, लोड बैलेंसिंग के विकल्पों के बारे में ज़्यादा जानने के लिए, लोड बैलेंसिंग के बारे में खास जानकारी देखें.

एचटीटीपी या एचटीटीपीएस लोड बैलेंसिंग बनाएं

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

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

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

gcloud compute http-health-checks create fancy-fe-frontend-hc \
  --request-path / \
  --port 8080

gcloud compute http-health-checks create fancy-be-orders-hc \
  --request-path /api/orders \
  --port 8081

gcloud compute http-health-checks create fancy-be-products-hc \
  --request-path /api/products \
  --port 8082

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

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-f \
  --global

gcloud compute backend-services add-backend fancy-be-orders \
  --instance-group fancy-be-mig \
  --instance-group-zone us-central1-f \
  --global

gcloud compute backend-services add-backend fancy-be-products \
  --instance-group fancy-be-mig \
  --instance-group-zone us-central1-f \
  --global

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

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

पाथ मैचर बनाएं, ताकि /api/order और /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 फ़ाइल में अपने पसंदीदा टेक्स्ट एडिटर (जैसे कि GNU नैनो) का इस्तेमाल करके बदलाव करें, ताकि वह लोड बैलेंसर के सार्वजनिक आईपी पते पर ले जाए. [LB_IP], बैकएंड इंस्टेंस का बाहरी आईपी पता दिखाता है.

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

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

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 \
    --max-unavailable 100%

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

रोलिंग-ऐक्शन रीस्टार्ट करने का निर्देश देने के बाद, करीब 30 सेकंड इंतज़ार करें, ताकि इंस्टेंस को प्रोसेस होने का समय मिल सके. इसके बाद, मैनेज किए जा रहे इंस्टेंस ग्रुप का स्टेटस तब तक देखें, जब तक सूची में इंस्टेंस न दिखें.

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

सूची में आइटम दिखने के बाद, Control+C (Macintosh पर Command+C) दबाकर, वॉच कमांड से बाहर निकलें.

पुष्टि करें कि सेवा को 'सही है' के तौर पर लिस्ट किया गया है.

watch -n 5 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: 8080
  - 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: 8080
  kind: compute#backendServiceGroupHealth

सूची में आइटम दिखने के बाद, Control+C (Macintosh पर Command+C) दबाकर, watch कमांड से बाहर निकलें.

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

gcloud compute forwarding-rules list --global

7. स्केलिंग कंप्यूट इंजन

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

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

ऑटो स्केलिंग की नीति बनाने के लिए, 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 फ़्रंटएंड पर आता है. उपयोगकर्ता के अनुरोध का जवाब देने के लिए, यह सबसे पहले Cloud सीडीएन कैश में दिखता है. अगर फ़्रंटएंड को कोई कैश मेमोरी में सेव किया गया जवाब मिलता है, तो वह उपयोगकर्ता को कैश मेमोरी में सेव किया गया जवाब भेजता है. इसे कैश मेमोरी हिट कहा जाता है.

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

8. वेबसाइट अपडेट करें

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

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

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

आपको अपने इंस्टेंस टेंप्लेट के मशीन टाइप में बदलाव करना होगा. इसके लिए, f1-micro स्टैंडर्ड मशीन टाइप को 4 vCPU और 3840MiB रैम वाले कस्टम मशीन टाइप में बदलना होगा.

Cloud Shell में, frontend इंस्टेंस के मशीन टाइप में बदलाव करने के लिए नीचे दिया गया कमांड चलाएं:

gcloud compute instances set-machine-type frontend --machine-type custom-4-3840

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

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

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

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

RUNNING स्थिति में एक से ज़्यादा इंस्टेंस होने पर, ACTION कोई नहीं पर सेट हो और INSTANCE_TEMPLATE नए टेंप्लेट नाम (fancy-fe-new) के तौर पर सेट हो, तो अगले निर्देश में इस्तेमाल करने के लिए सूची में दी गई मशीनों में से किसी एक का नाम कॉपी करें.

देखने की प्रोसेस से बाहर निकलने के लिए, Control+S (Macintosh पर Command+S).

नीचे दिया गया तरीका अपनाकर देखें कि वर्चुअल मशीन में नए मशीन टाइप (custom-4-3840) का इस्तेमाल किया जा रहा है या नहीं, जहां [VM_NAME] हाल ही में बनाया गया इंस्टेंस है:

gcloud compute instances describe [VM_NAME] | grep machineType

अनुमानित आउटपुट का उदाहरण:

machineType: https://www.googleapis.com/compute/v1/projects/project-name/zones/us-central1-f/machineTypes/custom-4-3840

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

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

इसके बाद, कोड को फिर से अपने Cloud Storage बकेट में डालें.

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%

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

रोलिंग ऐक्शन को रीस्टार्ट करने का निर्देश देने के बाद, करीब 30 सेकंड इंतज़ार करें, ताकि इंस्टेंस को प्रोसेस होने का समय दिया जा सके. इसके बाद, मैनेज किए गए इंस्टेंस ग्रुप का स्टेटस तब तक देखें, जब तक कि सूची में इंस्टेंस न दिख जाएं.

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

सूची में आइटम दिखने के बाद, Control+S (Macintosh पर Command+S) दबाकर, वॉच कमांड से बाहर निकलें.

इन निर्देशों को चलाकर पुष्टि करें कि सेवा, हेल्थ के तौर पर लिस्ट की गई है:

watch -n 5 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: 8080
  - 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: 8080
  kind: compute#backendServiceGroupHealth

सूची में आइटम दिखने के बाद, Control+S (Macintosh पर Command+S) दबाकर, वॉच कमांड से बाहर निकलें.

कॉन्टेंट-डिलीवरी नेटवर्क में कैश मेमोरी में सेव किए गए कॉन्टेंट को अमान्य करने और यह पक्का करने के लिए कि नया कॉन्टेंट दिखे, ये काम करें:

gcloud compute url-maps invalidate-cdn-cache fancy-map \
    --path "/*"

http://[LB_IP] के ज़रिए वेबसाइट पर ब्राउज़ करें. यहां लोड बैलेंसर के लिए [LB_IP] IP_ADDRESS होता है. इसे नीचे दिए गए निर्देश की मदद से खोजा जा सकता है:

gcloud compute forwarding-rules list --global

वेबसाइट में किए गए नए बदलाव अब दिखने चाहिए.

सिम्युलेट नहीं किया जा सका

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

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

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

gcloud compute ssh [INSTANCE_NAME]

उदाहरण के लिए, ऐप्लिकेशन को रोकने के लिए Supervisorctl का इस्तेमाल करें.

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

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

9. व्यवस्थित करें

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

gcloud projects delete [PROJECT_ID]

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

10. बधाई हो!

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