Cloud Run की मदद से तीन आसान चरणों में वीडियो बनाएं

1. परिचय

ऐप्लिकेशन मैनेज करना इतना मुश्किल क्यों है?

इसकी एक बड़ी वजह यह है कि डेवलपर को अक्सर पार्ट-टाइम सिस्टम एडमिन के तौर पर काम करना पड़ता है. मॉडर्न प्रोडक्शन-ग्रेड वेब ऐप्लिकेशन को डेवलप, डिप्लॉय, और मैनेज करने के लिए, इन (आंशिक) समस्याओं के बारे में सोचें :

मुझे नहीं पता कि आपको इन बातों की चिंता है या नहीं, लेकिन मुझे इन बातों की चिंता नहीं करनी है! मुझे अपने ऐप्लिकेशन के लॉजिक के बारे में सोचना है:

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

ऊपर बताई गई प्रशासनिक समस्याओं के अलावा, आपको इन समस्याओं का भी सामना करना पड़ सकता है:

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

Cloud Run, इन और अन्य कई समस्याओं को हल करने में आपकी मदद करता है. हालांकि, हमारी बात पर भरोसा करने के बजाय, आइए, साथ मिलकर एक ऐप्लिकेशन बनाएं और देखें कि कुछ ही आसान चरणों में, लोकल डेवलपमेंट एनवायरमेंट से प्रोडक्शन-ग्रेड क्लाउड ऐप्लिकेशन पर स्विच करना कितना आसान है.

आपको क्या करना होगा...

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

आपको यह जानकारी मिलेगी...

Python में एक सामान्य वेब सर्वर ऐप्लिकेशन बनाने का तरीका
अपने ऐप्लिकेशन को ऐसे Docker कंटेनर में पैकेज करने का तरीका जो कहीं भी चल सके
अपने ऐप्लिकेशन को क्लाउड पर डिप्लॉय करने का तरीका, ताकि कोई भी व्यक्ति आपकी नई क्रिएशन को आज़मा सके
Buildpacks का इस्तेमाल करके, ऊपर दिए गए चरणों को और भी आसान बनाने का तरीका
Google Cloud कमांड लाइन टूल और Cloud Console के वेब यूज़र इंटरफ़ेस (यूआई) का इस्तेमाल कैसे करें

आपको इन चीज़ों की ज़रूरत होगी...

वेब ब्राउज़र
Google खाता

यह लैब, सभी लेवल के डेवलपर के लिए है. इसमें शुरुआती डेवलपर भी शामिल हैं. हालांकि, आपको Python का इस्तेमाल करना होगा, लेकिन इसके लिए आपको Python प्रोग्रामिंग के बारे में जानकारी होना ज़रूरी नहीं है. ऐसा इसलिए, क्योंकि हम इस्तेमाल किए गए सभी कोड के बारे में बताएंगे.

2. सेट अप करना

इस सेक्शन में, इस लैब को शुरू करने के लिए ज़रूरी सभी चरणों के बारे में बताया गया है.

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

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

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

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

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

Cloud Shell शुरू करें

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

Cloud Shell चालू करें

Cloud Console में, Cloud Shell चालू करें पर क्लिक करें.

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

Cloud Shell से कनेक्ट होने में कुछ ही सेकंड लगेंगे.

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

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

पुष्टि करें कि आपने Cloud Shell में पुष्टि कर ली है. इसके लिए, यह कमांड चलाएं:

gcloud auth list

कमांड आउटपुट

 Credentialed Accounts
ACTIVE  ACCOUNT
*       <my_account>@<my_domain.com>

To set the active account, run:
    $ gcloud config set account `ACCOUNT`

यह पुष्टि करने के लिए कि gcloud कमांड को आपके प्रोजेक्ट के बारे में पता है, Cloud Shell में यह कमांड चलाएं:

gcloud config list project

कमांड आउटपुट

[core]
project = <PROJECT_ID>

अगर ऐसा नहीं है, तो इस कमांड का इस्तेमाल करके इसे सेट किया जा सकता है:

gcloud config set project <PROJECT_ID>

कमांड आउटपुट

Updated property [core/project].

अपने टर्मिनल में कुछ एनवायरमेंट वैरिएबल सेट करें. इससे आपको आगे के चरणों में आसानी होगी:

export PROJ=$GOOGLE_CLOUD_PROJECT 
export APP=hello 
export PORT=8080
export REGION="us-central1"
export TAG="gcr.io/$PROJ/$APP"

एपीआई चालू करना

बाद के चरणों में, आपको पता चलेगा कि इन सेवाओं की ज़रूरत कहां और क्यों है. हालांकि, फ़िलहाल इस कमांड को चलाकर, अपने प्रोजेक्ट को Cloud Build, Container Registry, और Cloud Run सेवाओं का ऐक्सेस दें:

gcloud services enable cloudbuild.googleapis.com         \
                       containerregistry.googleapis.com  \
                       run.googleapis.com

इससे, इस तरह का मैसेज दिखेगा:

Operation "operations/acf.cc11852d-40af-47ad-9d59-477a12847c9e" finished successfully.

3. एक सामान्य वेब ऐप्लिकेशन बनाना

शुरू करने के लिए, Cloud Shell पैनल में सबसे ऊपर मौजूद Open Editor बटन पर क्लिक करें. यह इस तरह दिखता है:

इसके बाद, आपको Visual Studio Code जैसा IDE एनवायरमेंट दिखेगा. इसमें प्रोजेक्ट बनाए जा सकते हैं, सोर्स कोड में बदलाव किया जा सकता है, प्रोग्राम चलाए जा सकते हैं वगैरह. अगर आपकी स्क्रीन पर जगह कम है, तो कंसोल और आपकी एडिट/टर्मिनल विंडो के बीच की लाइन को बड़ा या छोटा किया जा सकता है. इसके लिए, इन दोनों सेक्शन के बीच मौजूद हॉरिज़ॉन्टल बार को खींचें. इसे यहां हाइलाइट किया गया है:

Open Editor और Open Terminal बटन पर क्लिक करके, एडिटर और टर्मिनल के बीच स्विच किया जा सकता है. अब इन दोनों एनवायरमेंट के बीच स्विच करके देखें.

इसके बाद, एक फ़ोल्डर बनाएं. इसमें आपको इस लैब के लिए अपना काम सेव करना है. इसके लिए, फ़ाइल->नया फ़ोल्डर चुनें, hello डालें, और OK पर क्लिक करें. इस लैब में बनाई गई सभी फ़ाइलें और Cloud Shell में किया गया सारा काम, इसी फ़ोल्डर में सेव होगा.

अब एक requirements.txt फ़ाइल बनाएं. इससे Python को पता चलता है कि आपका ऐप्लिकेशन किन लाइब्रेरी पर निर्भर करता है. इस सामान्य वेब ऐप्लिकेशन के लिए, आपको वेब सर्वर बनाने के लिए Python के लोकप्रिय मॉड्यूल Flask और वेब सर्वर फ़्रेमवर्क gunicorn का इस्तेमाल करना होगा. नई फ़ाइल बनाने के लिए, Cloud Editor विंडो में File->New File मेन्यू पर क्लिक करें. जब आपसे नई फ़ाइल का नाम पूछा जाए, तब requirements.txt डालें और OK बटन दबाएं. पक्का करें कि नई फ़ाइल, hello प्रोजेक्ट फ़ोल्डर में सेव हो.

नई फ़ाइल में ये लाइनें डालें. इससे यह पता चलेगा कि आपका ऐप्लिकेशन, Python Flask पैकेज और gunicorn वेब सर्वर पर निर्भर करता है.

Flask
gunicorn

आपको इस फ़ाइल को सेव करने की ज़रूरत नहीं है, क्योंकि Cloud Editor आपके लिए बदलावों को अपने-आप सेव कर देगा.

वर्शन 1: Hello world!

इसी तरीके का इस्तेमाल करके, main.py नाम की एक और नई फ़ाइल बनाएं. यह आपके ऐप्लिकेशन की मुख्य (और एकमात्र) Python सोर्स फ़ाइल होगी. फिर से, पक्का करें कि नई फ़ाइल hello प्रोजेक्ट फ़ोल्डर में सेव हो.

इस फ़ाइल में यह कोड डालें:

from flask import Flask
import os
import random

app = Flask(__name__)  # Create a Flask object.
PORT = os.environ.get("PORT")  # Get PORT setting from the environment.

# The app.route decorator routes any GET requests sent to the root path
# to this function, which responds with a "Hello world!" HTML document.
@app.route("/", methods=["GET"])
def say_hello():
    html = "<h1>Hello world!</h1>"
    return html


# This code ensures that your Flask app is started and listens for
# incoming connections on the local interface and port 8080.
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=PORT)

टर्मिनल पर वापस जाएं और इस कमांड का इस्तेमाल करके, प्रोजेक्ट फ़ोल्डर में जाएं:

cd hello

अपने प्रोजेक्ट की डिपेंडेंसी इंस्टॉल करने के लिए, यह कमांड चलाएं:

pip3 install -r requirements.txt

अब टर्मिनल में यह निर्देश डालकर, अपना ऐप्लिकेशन लॉन्च करें:

python3 main.py

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

web preview बटन पर क्लिक करें. इसके बाद, Preview on Port 8080 मेन्यू आइटम पर क्लिक करें. जैसे:

इससे आपके चालू ऐप्लिकेशन के लिए एक वेब ब्राउज़र टैब खुलेगा. यह कुछ इस तरह दिखना चाहिए:

दूसरा वर्शन: यूआरएल पाथ को दोहराना

Open Editor बटन की मदद से, Cloud Editor पर वापस जाएं. इसके बाद, अपनी main.py फ़ाइल को इस तरह अपडेट करके, यूआरएल सफ़िक्स को दोहराने की सुविधा जोड़ें:

from flask import Flask
import os
import random

app = Flask(__name__)  # Create a Flask object.
PORT = os.environ.get("PORT")  # Get PORT setting from environment.

# The app.route decorator routes any GET requests sent to the root path
# to this function, which responds with a "Hello world!" HTML document.
# If something is specified as the URL path (after the '/'), say_hello()
# responds with "Hello X", where X is the string at the end of the URL.
@app.route("/", methods=["GET"])
@app.route("/<name>", methods=["GET"])     # ← NEW
def say_hello(name="world"):               # ← MODIFIED
    html = f"<h1>Hello {name}!</h1>"       # ← MODIFIED
    return html


# This code ensures that your Flask app is started and listens for
# incoming connections on the local interface and port 8080.
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=PORT)

Open Terminal बटन की मदद से, वापस टर्मिनल पर जाएं. इसके बाद, चल रहे ऐप्लिकेशन को रोकने के लिए control-C ('C' दबाते समय कंट्रोल कुंजी को दबाकर रखें) डालें. इसके बाद, इसे फिर से शुरू करने के लिए यह डालें:

python3 main.py

फिर से web preview बटन पर क्लिक करें. इसके बाद, Preview on Port 8080 मेन्यू आइटम पर क्लिक करके, चालू ऐप्लिकेशन के लिए वेब ब्राउज़र टैब खोलें. आपको फिर से "Hello world!" मैसेज दिखेगा. हालांकि, अब स्लैश वर्ण के बाद मौजूद यूआरएल टेक्स्ट को अपनी पसंद की किसी भी स्ट्रिंग (जैसे कि /your-name) से बदलें. साथ ही, पुष्टि करें कि आपको कुछ ऐसा दिखे:

तीसरा वर्शन: रैंडम रंग

अब, Cloud Editor (Open Editor बटन के ज़रिए) पर वापस जाकर, बैकग्राउंड के रंगों को रैंडम तरीके से बदलने की सुविधा जोड़ें. इसके लिए, अपनी main.py फ़ाइल को इस तरह अपडेट करें:

from flask import Flask
import os
import random

app = Flask(__name__)  # Create a Flask object.
PORT = os.environ.get("PORT")  # Get PORT setting from the environment.

# This function decides whether foreground text should be
# displayed in black or white, to maximize fg/bg contrast.
def set_text_color(rgb):                      # ← NEW
    sum = round(                              # ← NEW
        (int(rgb[0]) * 0.299)                 # ← NEW
        + (int(rgb[1]) * 0.587)               # ← NEW
        + (int(rgb[2]) * 0.114)               # ← NEW
    )                                         # ← NEW
    return "black" if sum > 186 else "white"  # ← NEW


# The app.route decorator routes any GET requests sent to the root path
# to this function, which responds with a "Hello world!" HTML document.
# If something is specified as the URL path (after the '/'), say_hello()
# responds with "Hello X", where X is the string at the end of the URL.
# To verify each new invocation of these requests, the HTML document
# includes CSS styling to produce a randomly colored background.
@app.route("/", methods=["GET"])
@app.route("/<name>", methods=["GET"])
def say_hello(name="world"):
    bg = random.sample(range(1, 255), 3)                       # ← NEW
    hex = (int(bg[0]) * 256) + (int(bg[1]) * 16) + int(bg[2])  # ← NEW
    fg_color = set_text_color(bg)                              # ← NEW
    bg_color = f"#{hex:06x}"                                   # ← NEW
    style = f"color:{fg_color}; background-color:{bg_color}"   # ← NEW
    html = f'<h1 style="{style}">Hello {name}!</h1>'           # ← MODIFIED
    return html


# This code ensures that your Flask app is started and listens for
# incoming connections on the local interface and port 8080.
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=PORT)

Open Terminal बटन की मदद से, वापस टर्मिनल पर जाएं. इसके बाद, चल रहे ऐप्लिकेशन को रोकने के लिए control-C ('C' दबाते समय कंट्रोल बटन को दबाकर रखें) डालें. इसके बाद, इसे फिर से शुरू करने के लिए यह डालें:

python3 main.py

फिर से web preview बटन पर क्लिक करें. इसके बाद, Preview on Port 8080 मेन्यू आइटम पर क्लिक करके, चालू ऐप्लिकेशन के लिए वेब ब्राउज़र टैब खोलें. आपको जनरेट किया गया टेक्स्ट दिखेगा. इसमें कोई भी तय किया गया प्रत्यय या डिफ़ॉल्ट "Hello world!" स्ट्रिंग, इस तरह से दिखेगी:

पेज को कुछ बार रीलोड करें. इससे आपको पता चलेगा कि ऐप्लिकेशन पर जाने पर, बैकग्राउंड का रंग हर बार बदलता है.

इसके बाद, आपका ऐप्लिकेशन तैयार हो जाएगा. बधाई हो! अगले चरण में, आपको अपने ऐप्लिकेशन को कंटेनर में पैकेज करने का तरीका बताया जाएगा. साथ ही, यह भी बताया जाएगा कि ऐसा करना क्यों फ़ायदेमंद है.

4. अपने ऐप्लिकेशन को कंटेनर में बदलना

कंटेनर क्या होता है?

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

डिपेंडेंसी की बात करें, तो पिछले चरण में, जब डेवलपर एनवायरमेंट में ऐप्लिकेशन चलाया जा रहा था, तब आपको pip3 install -r requirements.txt चलाना पड़ा था. साथ ही, यह पक्का करना पड़ा था कि requirements.txt फ़ाइल में आपकी सभी डिपेंडेंट लाइब्रेरी और उनके वर्शन शामिल हों. कंटेनर इमेज जनरेट करते समय, कंटेनर में ये ज़रूरी शर्तें इंस्टॉल की जाती हैं. इसलिए, कंटेनर का इस्तेमाल करने वाले व्यक्ति को कुछ भी इंस्टॉल करने की ज़रूरत नहीं होती.

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

कंटेनर की मदद से, आपके ऐप्लिकेशन को ये फ़ायदे मिलते हैं:

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

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

अब बहुत हो गई बातें - चलो एक कंटेनर बनाते हैं! कंटेनर बनाने के लिए, Docker नाम की किसी टेक्नोलॉजी का इस्तेमाल किया जाएगा.

Cloud Editor में, Dockerfile नाम की नई फ़ाइल बनाएं. यह फ़ाइल, आपकी इमेज बनाने के लिए ब्लूप्रिंट है. इससे Docker को आपके ऑपरेटिंग एनवायरमेंट और सोर्स कोड के बारे में पता चलता है. साथ ही, यह भी पता चलता है कि आपकी डिपेंडेंसी को कैसे इंस्टॉल करना है, ऐप्लिकेशन को कैसे बनाना है, और कोड को कैसे चलाना है.

# Use an official lightweight Python image.
FROM python:3.9-slim

# Copy local code to the container image.
WORKDIR /app
COPY main.py .
COPY requirements.txt .

# Install dependencies into this container so there's no need to 
# install anything at container run time.
RUN pip install -r requirements.txt

# Service must listen to $PORT environment variable.
# This default value facilitates local development.
ENV PORT 8080

# Run the web service on container startup. Here you use the gunicorn
# server, with one worker process and 8 threads. For environments 
# with multiple CPU cores, increase the number of workers to match 
# the number of cores available.
CMD exec gunicorn --bind 0.0.0.0:$PORT --workers 1 --threads 8 --timeout 0 main:app

Cloud Terminal में, Cloud Build का इस्तेमाल करके अपनी कंटेनर इमेज बनाएं. इसके लिए, यह कमांड चलाएं:

gcloud builds submit --tag $TAG

रजिस्ट्री में पुश करने के बाद, आपको इमेज के नाम वाला SUCCESS मैसेज दिखेगा. यह कुछ इस तरह दिखेगा: gcr.io/<project-id>/hello. यह इमेज अब Google Container Registry में सेव हो गई है. इसे अपनी ज़रूरत के हिसाब से किसी भी समय और कहीं भी फिर से इस्तेमाल किया जा सकता है.

इस कमांड का इस्तेमाल करके, अपने मौजूदा प्रोजेक्ट से जुड़ी सभी कंटेनर इमेज की सूची बनाई जा सकती है:

gcloud container images list

अब Cloud Shell में जाकर, ऐप्लिकेशन को स्थानीय तौर पर चलाएं और उसकी जांच करें. इसके लिए, इन docker कमांड का इस्तेमाल करें:

docker run -p $PORT:$PORT -e PORT=$PORT $TAG

-p $PORT:$PORT विकल्प, Docker को होस्ट एनवायरमेंट में मौजूद बाहरी पोर्ट $PORT (ऊपर 8080 पर सेट किया गया है) को चालू कंटेनर के अंदर मौजूद उसी पोर्ट नंबर पर मैप करने के लिए कहता है. इससे काम करना आसान हो जाता है, क्योंकि आपके लिखे गए सर्वर कोड और ऐप्लिकेशन की जांच करते समय कनेक्ट किए गए बाहरी पोर्ट का नंबर एक ही होगा (8080). हालांकि, -p विकल्प का इस्तेमाल करके, होस्ट पर मौजूद किसी भी बाहरी पोर्ट को कंटेनर के अंदर मौजूद किसी भी पोर्ट पर आसानी से मैप किया जा सकता है.

-e PORT=$PORT विकल्प, Docker को बताता है कि कंटेनर में चल रहे आपके ऐप्लिकेशन के लिए, $PORT एनवायरमेंट वैरिएबल (ऊपर 8080 पर सेट किया गया) उपलब्ध कराएं.

अब कंटेनर में चल रहे Python कोड पर वेब ब्राउज़र को पॉइंट करके, अपने ऐप्लिकेशन की जांच की जा सकती है. Cloud Shell विंडो में, "वेब की झलक" आइकॉन पर क्लिक करें. इसके बाद, पिछले चरण की तरह "पोर्ट 8080 पर झलक देखें" को चुनें.

आपको नतीजे में, जाना-पहचाना लेआउट दिखेगा. आपको जनरेट किया गया टेक्स्ट, रैंडम रंग के बैकग्राउंड के सामने दिखेगा. ठीक वैसे ही जैसे आपने Cloud Shell टर्मिनल में सीधे तौर पर ऐप्लिकेशन को चलाने के दौरान देखा था. पेज को कुछ बार रीलोड करें. इससे आपको पता चलेगा कि ऐप्लिकेशन पर जाने पर, बैकग्राउंड का रंग हर बार बदलता है.

बधाई हो! अब आपने अपने ऐप्लिकेशन का कंटेनर वाला वर्शन चला लिया है. अगले सेक्शन में, कोड की एक भी लाइन में बदलाव किए बिना, कंटेनर इमेज को प्रोडक्शन क्वालिटी वाले वेब ऐप्लिकेशन में बदला जाएगा.

5. क्लाउड पर...

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

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

अपने ऐप्लिकेशन को Google Cloud Run पर डिप्लॉय करने से, आपको ऊपर दी गई सभी सुविधाएं और इसके अलावा और भी कई सुविधाएं मिलती हैं.

अपने ऐप्लिकेशन को Cloud Run पर डिप्लॉय करना

सबसे पहले, हम आपके ऐप्लिकेशन में बदलाव करेंगे, ताकि आपको नए और पुराने वर्शन के बीच का अंतर पता चल सके. इसके लिए, main.py फ़ाइल में बदलाव करें, ताकि डिफ़ॉल्ट मैसेज "Hello world!" से बदलकर "Hello from Cloud Run!" हो जाए. दूसरे शब्दों में, main.py में इस लाइन को इससे बदलें:

def say_hello(name="world"):

इस पर क्लिक करें:

def say_hello(name="from Cloud Run"):

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

अपनी कंटेनर इमेज को फिर से बनाएं और कंटेनर वाले ऐप्लिकेशन को Cloud Run पर डिप्लॉय करें. इसके लिए, यह कमांड डालें:

gcloud builds submit --tag $TAG
gcloud run deploy "$APP"   \
  --image "$TAG"           \
  --platform "managed"     \
  --region "$REGION"       \
  --allow-unauthenticated

gcloud config set run/region $REGION की मदद से, डिफ़ॉल्ट क्षेत्र भी तय किया जा सकता है.
--allow-unauthenticated विकल्प चुनने पर, सेवा सार्वजनिक तौर पर उपलब्ध हो जाती है. बिना पुष्टि वाले अनुरोधों से बचने के लिए, --no-allow-unauthenticated का इस्तेमाल करें.

यहां दी गई इमेज, वह Docker इमेज है जिसे आपने पिछले चरण में बनाया था. Cloud Build सेवा की मदद से, इमेज को Google Container Registry में सेव किया जाता है. इससे Cloud Run सेवा को इमेज मिल जाती है और वह उसे आपके लिए डिप्लॉय कर पाती है.

डिप्लॉयमेंट पूरा होने तक कुछ देर इंतज़ार करें. सफल होने पर, कमांड लाइन में सेवा का यूआरएल दिखता है:

Deploying container to Cloud Run service [hello] in project [PROJECT_ID...
✓ Deploying new service... Done.                                   
  ✓ Creating Revision... Revision deployment finished. Waiting for health check...
  ✓ Routing traffic...
  ✓ Setting IAM Policy...
Done.
Service [hello] revision [hello-...] has been deployed and is serving 100 percent of traffic.
Service URL: https://hello-....a.run.app

इस कमांड का इस्तेमाल करके भी, सेवा का यूआरएल वापस पाया जा सकता है:

gcloud run services describe hello  \
  --platform managed                \
  --region $REGION                  \
  --format "value(status.url)"

यह कुछ इस तरह दिखना चाहिए:

https://hello-....a.run.app

यह लिंक, आपकी Cloud Run सेवा के लिए टीएलएस सुरक्षा वाला एक खास यूआरएल है. यह लिंक हमेशा के लिए होता है. जब तक सेवा बंद नहीं की जाती, तब तक इसका इस्तेमाल किया जा सकता है. साथ ही, इसका इस्तेमाल इंटरनेट पर कहीं भी किया जा सकता है. यह Cloud Shell के प्रॉक्सी मैकेनिज़्म का इस्तेमाल नहीं करता है. यह मैकेनिज़्म, कुछ समय के लिए उपलब्ध वर्चुअल मशीन पर निर्भर करता है.

हाइलाइट किए गए Service URL पर क्लिक करें. इससे आपके ऐप्लिकेशन के लिए वेब ब्राउज़र टैब खुल जाएगा. नतीजे में, आपको "Hello from Cloud Run!" मैसेज दिखेगा. यह मैसेज, रैंडम रंग के बैकग्राउंड के सामने दिखेगा.

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

हालांकि, मुझे लगता है कि इस प्रोसेस को और भी आसान बनाया जा सकता है...

6. कंटेनर अपने-आप बनाना

यह सब काफ़ी अच्छा है, लेकिन अगर मुझे Dockerfile और कंटेनर के बारे में सोचना ही नहीं है, तो क्या होगा. अगर मुझे ज़्यादातर डेवलपर की तरह, सिर्फ़ अपने ऐप्लिकेशन का कोड लिखने पर ध्यान देना है और कंटेनर बनाने की ज़िम्मेदारी किसी और को देनी है, तो क्या होगा. खुशी की बात यह है कि Cloud Run, Buildpacks नाम के ओपन सोर्स स्टैंडर्ड के साथ काम करता है. इसे इसी वजह से बनाया गया है, ताकि सोर्स फ़ाइलों के कलेक्शन से कंटेनर बनाने की प्रोसेस को अपने-आप पूरा किया जा सके.

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

सबसे पहले, हम आपके ऐप्लिकेशन में बदलाव करेंगे, ताकि आपको नए और पुराने वर्शन के बीच का अंतर पता चल सके. इसके लिए, main.py फ़ाइल में बदलाव करें, ताकि डिफ़ॉल्ट मैसेज "Hello from Cloud Run!" से बदलकर "Hello from Cloud Run with Buildpacks!" हो जाए. दूसरे शब्दों में, main.py में मौजूद इस लाइन को इससे बदलें:

def say_hello(name="from Cloud Run"):

इस पर क्लिक करें:

def say_hello(name="from Cloud Run with Buildpacks"):

अब हम Procfile नाम की एक नई फ़ाइल बनाकर, बिल्डपैक का फ़ायदा उठाते हैं. Cloud Editor में जाकर, वह फ़ाइल बनाएं और इस टेक्स्ट की एक लाइन डालें:

web: python3 main.py

इससे बिल्डबैक सिस्टम को यह पता चलता है कि अपने-आप जनरेट हुए कंटेनर में आपके ऐप्लिकेशन को कैसे चलाया जाए. इस निर्देश के बाद, आपको Dockerfile की भी ज़रूरत नहीं पड़ेगी. इसकी पुष्टि करने के लिए, Dockerfile मिटाएं और Cloud Shell टर्मिनल में यह कमांड चलाएं:

gcloud beta run deploy "$APP"  \
    --source .                 \
    --platform "managed"       \
    --region "$REGION"         \
    --allow-unauthenticated

यह कमांड, पिछले चरण में ऐप्लिकेशन को डिप्लॉय करने के लिए इस्तेमाल की गई कमांड जैसी ही है. हालांकि, इस बार आपने --image विकल्प की जगह --source . विकल्प का इस्तेमाल किया है. इससे gcloud कमांड को यह पता चलता है कि आपको कंटेनर इमेज बनाने के लिए, बिल्डपैक का इस्तेमाल करना है. यह इमेज, मौजूदा डायरेक्ट्री में मौजूद सोर्स फ़ाइलों के आधार पर बनाई जाएगी. --source . में मौजूद dot, मौजूदा डायरेक्ट्री के लिए शॉर्टहैंड है. यह सेवा कंटेनर इमेज का ध्यान रखती है. इसलिए, आपको इस gcloud कमांड में इमेज के बारे में जानकारी देने की ज़रूरत नहीं है.

एक बार फिर, पुष्टि करें कि यह डिप्लॉयमेंट काम कर रहा है. इसके लिए, हाइलाइट किए गए Service URL पर क्लिक करें. इससे आपके ऐप्लिकेशन का वेब ब्राउज़र टैब खुलेगा. साथ ही, पक्का करें कि आपकी सेवा, "Hello from Cloud Run with Buildpacks!" को रैंडम रंग वाले बैकग्राउंड के सामने दिखा रही हो.

ध्यान दें कि Dockerfile बनाने के लिए बिल्डपैक का इस्तेमाल करने से, तीन आसान चरणों को दो चरणों में बदल दिया गया है:

अपने डेवलपमेंट एनवायरमेंट में कोई ऐप्लिकेशन बनाएं.
एक कमांड से, क्लाउड पर एक जैसा कोड डिप्लॉय करें.

7. क्या मुझे कमांड लाइन का इस्तेमाल करना होगा?

नहीं! Google Cloud की लगभग हर सेवा की तरह, Cloud Run के साथ इंटरैक्ट करने के तीन तरीके हैं:

gcloud कमांड-लाइन टूल, जिसे आपने अभी देखा है.
Cloud Console के ज़रिए, वेब पर उपलब्ध बेहतर यूज़र इंटरफ़ेस. इसमें पॉइंट और क्लिक करने की सुविधा मिलती है.
प्रोग्राम के हिसाब से, Google की क्लाइंट लाइब्रेरी का इस्तेमाल करके. ये लाइब्रेरी, Java, C#, Python, Go, Javascript, Ruby, C/C++ वगैरह जैसी कई लोकप्रिय भाषाओं के लिए उपलब्ध हैं.

आइए, कंसोल यूज़र इंटरफ़ेस (यूआई) का इस्तेमाल करके, अपने Cloud Run ऐप्लिकेशन का एक और इंस्टेंस डिप्लॉय करें. सबसे ऊपर बाईं ओर मौजूद मेन्यू से, Cloud Run Service के लैंडिंग पेज पर जाएं:

इसके बाद, आपको Cloud Run की सेवाओं की खास जानकारी दिखेगी. जैसे:

डप्लॉयमेंट की प्रोसेस शुरू करने के लिए, "Create Service" लिंक पर क्लिक करें:

सेवा के नाम के तौर पर "hello-again" डालें. डिप्लॉयमेंट प्लैटफ़ॉर्म और क्षेत्र के लिए डिफ़ॉल्ट वैल्यू का इस्तेमाल करें. इसके बाद, "आगे बढ़ें" पर क्लिक करें.

कंटेनर इमेज के लिए यह यूआरएल डालें: gcr.io/cloudrun/hello. यह कंटेनर, Google ने टेस्टिंग के लिए बनाया है. इसके बाद, "ऐडवांस सेटिंग" ड्रॉप-डाउन पर क्लिक करके, कॉन्फ़िगरेशन की कई सेटिंग देखें. यहां कुछ ऐसे कॉम्पोनेंट दिए गए हैं जिन्हें पसंद के मुताबिक बनाया जा सकता है:

पोर्ट नंबर और कंटेनर का एंट्री पॉइंट (यह कंटेनर बनाते समय तय किए गए एंट्री पॉइंट को बदल देगा)
हार्डवेयर: मेमोरी और सीपीयू की संख्या
स्केलिंग: कम से कम और ज़्यादा से ज़्यादा इंस्टेंस
एनवायरमेंट वैरिएबल
अन्य: अनुरोध के समयसीमा खत्म होने की सेटिंग, हर कंटेनर के लिए अनुरोधों की ज़्यादा से ज़्यादा संख्या, HTTP/2

डायलॉग को आगे बढ़ाने के लिए, "आगे बढ़ें" बटन पर क्लिक करें. अगले डायलॉग बॉक्स में, यह तय किया जा सकता है कि आपकी सेवा को कैसे ट्रिगर किया जाए. "Ingress" के लिए, "allow all traffic" चुनें. साथ ही, "Authentication" के लिए, "Allow unauthenticated traffic" चुनें.

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

अब Cloud Run सेवा बनाने के लिए, Create बटन पर क्लिक करें. कुछ सेकंड बाद, आपको Cloud Run सेवाओं की खास जानकारी वाली सूची में अपनी नई सेवा दिखने लगेगी. खास जानकारी वाली लाइन में, सबसे हाल के डिप्लॉयमेंट (तारीख/समय और किसने किया) के साथ-साथ कॉन्फ़िगरेशन की कुछ मुख्य सेटिंग के बारे में जानकारी मिलती है. अपनी नई सेवा के बारे में ज़्यादा जानकारी पाने के लिए, सेवा के नाम वाले लिंक पर क्लिक करें.

अपनी सेवा की पुष्टि करने के लिए, खास जानकारी वाले पेज पर सबसे ऊपर दिए गए यूआरएल पर क्लिक करें. यह यूआरएल, नीचे दिए गए उदाहरण में हाइलाइट किया गया है:

आपको कुछ ऐसा दिखेगा:

अब आपने नई Cloud Run सेवा डिप्लॉय कर दी है. इसलिए, एक से ज़्यादा डिप्लॉयमेंट मैनेज करने के कुछ तरीके देखने के लिए, REVISIONS टैब चुनें.

कंसोल से सीधे तौर पर नए वर्शन डिप्लॉय करने के लिए, EDIT & DEPLOY NEW REVISION बटन पर क्लिक करें. यह बटन, यहां दिए गए उदाहरण के स्क्रीनशॉट में हाइलाइट किया गया है:

नया वर्शन बनाने के लिए, अब उस बटन पर क्लिक करें. कंटेनर यूआरएल के बगल में मौजूद, SELECT बटन पर क्लिक करें. इसे यहां दिखाया गया है:

पॉप-अप होने वाले डायलॉग में, उस सामान्य वेब ऐप्लिकेशन को ढूंढें जिसे आपने पहले Buildpacks का इस्तेमाल करके Cloud Build से डिप्लॉय किया था. इसके बाद, 'चुनें' पर क्लिक करें. पक्का करें कि आपने

gcr.io/<project>/cloud-run-source-deploy

फ़ोल्डर , जैसे कि यह:

फ़ाइल चुन लेने के बाद, सबसे नीचे तक स्क्रोल करें और DEPLOY बटन पर क्लिक करें. आपने अब अपने ऐप्लिकेशन का नया वर्शन डिप्लॉय कर दिया है. पुष्टि करने के लिए, अपने सेवा यूआरएल पर फिर से जाएं और पुष्टि करें कि अब आपको रंगीन "Buildpacks की मदद से Cloud Run से नमस्ते!" वेब ऐप्लिकेशन दिख रहा है.

जैसा कि आप देख सकते हैं, 'बदलाव' टैब में, लागू किए गए हर बदलाव की खास जानकारी दी गई है. अब आपको इस सेवा के लिए दो बदलाव दिखेंगे. किसी दिए गए वर्शन को चुनने के लिए, वर्शन के नाम की बाईं ओर मौजूद रेडियो बटन पर क्लिक करें. इससे स्क्रीन की दाईं ओर, वर्शन की जानकारी की खास जानकारी दिखेगी. इन बटन को चुनने पर, आपको पता चलेगा कि आपके दो वर्शन, दो अलग-अलग कंटेनर इमेज से लिए गए हैं.

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

आने वाले ट्रैफ़िक के छोटे से हिस्से के साथ, अपने ऐप्लिकेशन के नए वर्शन की कैनरी टेस्टिंग करना
समस्या वाली रिलीज़ से ट्रैफ़िक को पिछले वर्शन पर वापस ले जाना
A/B टेस्टिंग

MANAGE TRAFFIC बटन यहां ढूंढें:

अपने दो वर्शन के बीच ट्रैफ़िक को 50/50 के अनुपात में बांटने के लिए, ट्रैफ़िक को 50/50 के अनुपात में इस तरह बांटें:

अब SAVE बटन पर क्लिक करें. इसके बाद, अपनी सेवा के यूआरएल पर बार-बार जाकर, 50/50 स्प्लिट की पुष्टि करें. साथ ही, यह देखें कि औसतन, आपके आधे अनुरोधों को मौजूदा वर्शन ("Hello from Cloud Run with Buildpacks!") और आधे अनुरोधों को पिछले वर्शन ("It's running!") से पूरा किया जा रहा है.

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

प्रोग्रामैटिक इंटरफ़ेस

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

8. अपने ऐप्लिकेशन की जांच करना

इस आखिरी चरण में, आपको आर्टिफ़िशियल लोड टेस्ट चलाना होगा. इससे आपके ऐप्लिकेशन पर लोड बढ़ेगा और आपको यह पता चलेगा कि मांग बढ़ने पर, ऐप्लिकेशन की परफ़ॉर्मेंस कैसी रहती है. आपको hey नाम के टूल का इस्तेमाल करना है. यह Cloud Shell में पहले से इंस्टॉल होता है. इससे हमें लोड टेस्ट चलाने और नतीजे दिखाने की सुविधा मिलती है.

टेस्ट चलाना

लोड टेस्ट चलाने के लिए, Cloud Shell टर्मिनल में यह कमांड चलाएं:

hey -q 1000 -c 200 -z 30s https://hello-...run.app

कमांड आर्ग्युमेंट को इस तरह समझा जाता है:

-q 1000 - हर सेकंड करीब 1,000 अनुरोधों का लोड बढ़ाने की कोशिश करें
-c 200 - 200 पैरलल वर्कर असाइन करें
-z 30s - 30 सेकंड के लिए लोड टेस्ट चलाएं
पक्का करें कि इस कमांड लाइन में, अपनी सेवा के यूआरएल का इस्तेमाल आखिरी आर्ग्युमेंट के तौर पर किया गया हो

जांच के नतीजे कुछ इस तरह दिखने चाहिए:

 Summary:
 Total:        30.2767 secs
 Slowest:      3.3633 secs
 Fastest:      0.1071 secs
 Average:      0.1828 secs
 Requests/sec: 1087.2387
 Total data:   3028456 bytes
 Size/request: 92 bytes

Response time histogram:
 0.107 [1]     |
 0.433 [31346] |■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
 0.758 [1472]  |■■
 1.084 [82]    |
 1.410 [4]     |
...

Latency distribution:
...
 50% in 0.1528 secs
 75% in 0.1949 secs
 90% in 0.2442 secs
 95% in 0.4052 secs
 99% in 0.7062 secs

Details (average, fastest, slowest):
...
 req write:    0.0000 secs, 0.0000 secs, 0.0232 secs
 resp wait:    0.1824 secs, 0.1070 secs, 3.2953 secs
 resp read:    0.0000 secs, 0.0000 secs, 0.0010 secs
Status code distribution:
 [200] 32918 responses

इस जवाब से हमें कई अहम चीज़ों के बारे में पता चलता है:

30 सेकंड में, हर सेकंड में करीब 1,000 अनुरोध भेजे गए. इस तरह, कुल 32,918 अनुरोध भेजे गए.
कोई गड़बड़ी नहीं हुई (सिर्फ़ 200 एचटीटीपी जवाब मिले).
औसत समय 180 मि॰से॰ था.
कम से कम विलंबता 107 मि॰से॰ थी और सबसे ज़्यादा 3.3 सेकंड थी
90वें पर्सेंटाइल के लिए इंतज़ार का समय 244 मि॰से॰ था.

Cloud Run कंसोल में METRICS टैब पर जाकर, सर्वर की परफ़ॉर्मेंस की जानकारी देखी जा सकती है:

9. क्लीन अप करना

Cloud Run, सेवा का इस्तेमाल न किए जाने पर कोई शुल्क नहीं लेता. हालांकि, बनाई गई कंटेनर इमेज को सेव करने के लिए आपसे शुल्क लिया जा सकता है.

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

gcloud container images delete $TAG

Cloud Run की सेवाओं को मिटाने के लिए, इन कमांड का इस्तेमाल करें:

gcloud run services delete hello --platform managed --region $REGION --quiet
gcloud run services delete hello-again --platform managed --region $REGION --quiet

10. आपने कर दिखाया!

बधाई हो - आपने प्रोडक्शन के लिए Cloud Run ऐप्लिकेशन बना लिया है और उसे डिप्लॉय कर दिया है. इस दौरान, आपने कंटेनर के बारे में जाना और अपना कंटेनर बनाने का तरीका सीखा. आपने देखा कि Cloud Run की मदद से, अपने ऐप्लिकेशन को डिप्लॉय करना कितना आसान है. इसके लिए, gcloud कमांड लाइन टूल और Cloud Console, दोनों का इस्तेमाल किया जा सकता है. अब आपको पता चल गया है कि अपनी शानदार रचनाओं को पूरी दुनिया के साथ कैसे शेयर किया जाता है!

हम आपसे एक ज़रूरी सवाल पूछना चाहते हैं:

डेवलपर एनवायरमेंट में ऐप्लिकेशन को चालू करने के बाद, Cloud Run की ओर से ऑफ़र की जाने वाली प्रोडक्शन-ग्रेड की सभी एट्रिब्यूट के साथ, इसे क्लाउड पर डिप्लॉय करने के लिए आपको कोड की कितनी लाइनों में बदलाव करना पड़ा?

ज़ाहिर है, इसका जवाब शून्य है. :)

आजमाए जाने वाले कोडलैब...

अन्य शानदार सुविधाओं के बारे में जानें...

रेफ़रंस दस्तावेज़...

11. कॉल-टू-ऐक्शन

अगर आपको यह कोडलैब पसंद आया है और आपको Google Cloud का इस्तेमाल करने में ज़्यादा समय लगता है, तो आपको आज ही Google Cloud Innovators में शामिल होना चाहिए!

Google Cloud Innovators में शामिल होने के लिए, आपको कोई शुल्क नहीं देना होगा. इसमें ये सुविधाएं शामिल हैं:

Google कर्मचारियों से सीधे तौर पर नई जानकारी पाने के लिए, लाइव चर्चाएं, एएमए, और रोडमैप सेशन
सीधे अपने इनबॉक्स में, Google Cloud से जुड़ी ताज़ा खबरें पाएं
डिजिटल बैज और वीडियो कॉन्फ़्रेंस का बैकग्राउंड
Skills Boost पर, लैब और लर्निंग के लिए 500 क्रेडिट

रजिस्टर करने के लिए, यहां क्लिक करें!