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

1. परिचय

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

आपको क्या सीखने को मिलेगा

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

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

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

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

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

अपनी स्पीड से एनवायरमेंट सेट अप करना

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

ध्यान दें: Cloud Console के यूआरएल को याद रखकर, इसे आसानी से ऐक्सेस किया जा सकता है. इसका यूआरएल console.cloud.google.com है.

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

ध्यान दें: अगर Gmail खाते का इस्तेमाल किया जा रहा है, तो डिफ़ॉल्ट जगह को कोई संगठन नहीं पर सेट किया जा सकता है. अगर Google Workspace खाते का इस्तेमाल किया जा रहा है, तो अपने संगठन के हिसाब से कोई जगह चुनें.

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

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

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

Compute Engine API चालू करना

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

Compute Engine API को चालू करने के लिए, Cloud Shell में यह निर्देश चलाएं:

gcloud services enable compute.googleapis.com

Cloud Shell

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

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

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

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

gcloud auth list

कमांड आउटपुट

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

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

gcloud config list project

कमांड आउटपुट

[core]
project = <PROJECT_ID>

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

gcloud config set project <PROJECT_ID>

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

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

echo $GOOGLE_CLOUD_PROJECT

कमांड आउटपुट

<PROJECT_ID>

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

gcloud config set compute/zone us-central1-f

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

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

Cloud Storage बकेट बनाना

हम अपने बनाए गए कोड और स्टार्टअप स्क्रिप्ट को सेव करने के लिए, Cloud Storage बकेट का इस्तेमाल करेंगे. Cloud Shell में, नया Cloud Storage बकेट बनाने के लिए यह कमांड चलाएं:

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

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

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 पर झलक दिखाएं" चुनें.

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

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

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

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

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

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

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

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

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

monolith-to-microservices फ़ोल्डर पर जाएं. फ़ाइल > नई फ़ाइल पर क्लिक करें और startup-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/

ध्यान दें: अगर Cloud Shell में कोड एडिटर का इस्तेमाल किया जा रहा है, तो पक्का करें कि "लाइन के आखिर में आने वाला क्रम" "LF" पर सेट हो, न कि "CRLF" पर. इसे कोड एडिटर में सबसे नीचे दाईं ओर देखा जा सकता है:

अगर यह CRLF पर सेट है, तो CRLF पर क्लिक करें. इसके बाद, ड्रॉप-डाउन में "LF" चुनें.

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

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

अब बनाई गई startup-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/

ध्यान दें: ‘node_modules' डिपेंडेंसी डायरेक्ट्री मिटाएं, ताकि यह पक्का किया जा सके कि कोड ज़्यादा से ज़्यादा तेज़ी से और कुशलता से काम करे. ये इवेंट, शुरू होने पर फिर से बनाए जाते हैं.

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

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

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

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

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

ध्यान दें: अगर पिछले चरणों में Compute Engine API चालू नहीं किया गया था, तो gcloud कमांड-लाइन टूल आपसे पूछेगा, "क्या आपको इसे चालू करके फिर से कोशिश करनी है (इसमें कुछ मिनट लगेंगे)?" Compute Engine API को चालू करने के लिए, कृपया ‘y' चुनें.

ध्यान दें: अगर आपसे ज़ोन तय करने के लिए कहा जाता है, तो पक्का करें कि एनवायरमेंट सेटअप सेक्शन में पहले से कोई डिफ़ॉल्ट ज़ोन कॉन्फ़िगर किया गया हो.

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

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

बैकएंड का एक्सटर्नल आईपी पता पाएं. इसे बैकएंड इंस्टेंस के 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 के कोड एडिटर में, monolith-to-microservices > react-app फ़ोल्डर पर जाएं. कोड एडिटर मेन्यू में, .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

फ़ाइल सेव करें.

react-app को फिर से बनाने के लिए, इस निर्देश का इस्तेमाल करें. इससे फ़्रंटएंड कोड अपडेट हो जाएगा:

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. मैनेज किए गए इंस्टेंस ग्रुप बनाना

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

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

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

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

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

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

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

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

ध्यान दें: ऑटोहीलिंग की सुविधा को ग्रुप में मौजूद इंस्टेंस की निगरानी शुरू करने में 15 मिनट लग सकते हैं.

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

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

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

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

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

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

1. फ़ॉरवर्ड करने का नियम, आने वाले अनुरोधों को टारगेट एचटीटीपी प्रॉक्सी पर भेजता है.
2. टारगेट एचटीटीपी प्रॉक्सी, हर अनुरोध की जांच यूआरएल मैप के हिसाब से करती है. इससे यह तय किया जाता है कि अनुरोध के लिए सही बैकएंड सेवा कौनसी है.
3. बैकएंड सेवा, हर अनुरोध को सही बैकएंड पर भेजती है. यह अनुरोध भेजने की क्षमता, ज़ोन, और अटैच किए गए बैकएंड के इंस्टेंस की स्थिति के आधार पर तय होता है. हर बैकएंड इंस्टेंस की परफ़ॉर्मेंस की जांच, एचटीटीपी हेल्थ चेक का इस्तेमाल करके की जाती है. अगर बैकएंड सेवा को एचटीटीपीएस या एचटीटीपी/2 हेल्थ चेक का इस्तेमाल करने के लिए कॉन्फ़िगर किया गया है, तो बैकएंड इंस्टेंस तक पहुंचने के दौरान अनुरोध को एन्क्रिप्ट (सुरक्षित) किया जाएगा.
4. लोड बैलेंसर और इंस्टेंस के बीच के सेशन, एचटीटीपी, एचटीटीपीएस या एचटीटीपी/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/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 में, react-app फ़ोल्डर पर जाएं. इसमें .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

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

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

ध्यान दें: नए पते में पोर्ट हटा दिए जाते हैं, क्योंकि लोड बैलेंसर को आपके लिए फ़ॉरवर्डिंग को मैनेज करने के लिए कॉन्फ़िगर किया जाता है.

react-app को फिर से बनाएं. इससे फ़्रंटएंड कोड अपडेट हो जाएगा.

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%

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

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

रोलिंग-ऐक्शन रीस्टार्ट कमांड जारी करने के बाद, करीब 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

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

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

gcloud compute forwarding-rules list --global

7. Compute Engine को स्केल करना

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

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

ऑटोसकेलिंग की नीति बनाने के लिए, 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

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

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

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

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

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

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

इंस्टेंस टेंप्लेट अपडेट किया जा रहा है

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

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

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

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

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 को None पर सेट किया गया हो, और 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

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

ध्यान दें: अगर नया कॉन्टेंट नहीं दिखता है, तो Google Chrome में Control+F5 (Macintosh पर Command+Shift+R) दबाकर वेब पेज को रीफ़्रेश करें. इससे यह पक्का किया जा सकेगा कि कैश किया गया कॉन्टेंट फिर से डाउनलोड हो जाए.

सिम्युलेट किया गया फ़ेल होने का मैसेज

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

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" डालकर मिटाने की पुष्टि करें.

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

10. बधाई हो!

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