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

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

1. परिचय

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

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

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

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

ऊपर बताई गई एडमिन से जुड़ी चुनौतियों के अलावा, आपको ये काम भी करने होंगे:

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

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

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

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

आपको इनके बारे में जानकारी मिलेगी...

Python में आसानी से वेब सर्वर ऐप्लिकेशन बनाने का तरीका
अपने ऐप्लिकेशन को कहीं भी चलने वाले Docker कंटेनर में कैसे पैकेज करें
अपने ऐप्लिकेशन को क्लाउड पर डिप्लॉय करने का तरीका, ताकि कोई भी आपके नए ऐप्लिकेशन को आज़मा सके
Buildpack इस्तेमाल करके ऊपर दिए गए चरणों को आसान बनाने का तरीका
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 से कनेक्ट होने में कुछ ही समय लगेगा.

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

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

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. कोई आसान वेब ऐप्लिकेशन बनाएं

अपने क्लाउड शेल पैनल के सबसे ऊपर मौजूद Open Editor बटन पर क्लिक करके शुरू करें. यह ऐसा दिखता है:

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

आप क्रम से Open Editor और Open Terminal बटन पर क्लिक करके Editor और टर्मिनल के बीच आगे और पीछे स्विच कर सकते हैं. अब इन दो परिवेशों के बीच आगे और आगे स्विच करके देखें.

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

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

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

Flask
gunicorn

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

वर्शन 1: नमस्ते दुनिया!

इसी तकनीक का इस्तेमाल करके, 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

अगर Cloud Shell में चीज़ें काम नहीं कर रही हैं, तो हो सकता है कि वह रीस्टार्ट हुआ और आपके होम (मुख्य) डायरेक्ट्री में वापस आ गया हो. इसकी जांच करने के लिए, pwd (प्रिंट वर्किंग डायरेक्ट्री) डालें और देखें कि आप अभी अपनी होम डायरेक्ट्री में हैं या नहीं. अगर ऐसा है, तो अपने प्रोजेक्ट फ़ोल्डर में बदलाव करने के लिए cd hello कमांड चलाएं.

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

pip3 install -r requirements.txt

अब टर्मिनल में इस निर्देश को चलाकर अपना ऐप्लिकेशन लॉन्च करें:

python3 main.py

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

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

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

वर्शन 2: यूआरएल पाथ को इको करना

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 मेन्यू आइटम पर क्लिक करें. आपको फिर से "नमस्ते दुनिया!" मैसेज लिखें, लेकिन अब यूआरएल टेक्स्ट को स्लैश वर्ण के बाद अपनी पसंद की किसी भी स्ट्रिंग से बदल दें (जैसे, /your-name) और पुष्टि करें कि आपको कुछ ऐसा दिखता है:

वर्शन 3: रैंडम कलर

अब 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)

python3 main.py

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

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

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

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

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

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

डिपेंडेंसी के तौर पर बात करें, तो पिछले चरण में, जब डेवलपर एनवायरमेंट में अपना ऐप्लिकेशन चलाया जा रहा था, तब आपको pip3 install -r requirements.txt चलाना पड़ता था. साथ ही, यह भी पक्का करना पड़ता था कि ज़रूरी शर्तों.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 कंटेनर रजिस्ट्री में सेव कर दिया गया है. आप जब चाहें, तब इसका इस्तेमाल कर सकते हैं.

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

gcloud container images list

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

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. क्लाउड के लिए...

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

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

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

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

सबसे पहले, अपने ऐप्लिकेशन में बदलाव करते हैं, ताकि आप नए संशोधन को पुराने से बता सकें. main.py फ़ाइल में इस तरह बदलाव करके ऐसा करें कि डिफ़ॉल्ट मैसेज "हैलो दुनिया!" "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 का इस्तेमाल करें.

यहां दी गई इमेज, वह डॉकर इमेज है जिसे आपने आखिरी चरण में बनाया था. 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 सेवा के लिए TLS सुरक्षा के साथ एक खास यूआरएल है. यह लिंक स्थायी है (जब तक कि आप अपनी सेवा अक्षम नहीं करते) और इंटरनेट पर कहीं भी उपयोग करने योग्य है. यह प्रोसेस, Cloud Shell के उस प्रॉक्सी तरीके का इस्तेमाल नहीं करती है जो कुछ समय के लिए उपलब्ध वर्चुअल मशीन पर निर्भर करता है.

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

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

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

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

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

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

सबसे पहले, अपने ऐप्लिकेशन में बदलाव करते हैं, ताकि आप नए संशोधन को पुराने से बता सकें. main.py फ़ाइल में इस तरह से बदलाव करें कि डिफ़ॉल्ट मैसेज "Cloud Run से हैलो!" में बदल जाए " Buildpack के साथ Cloud Run की ओर से नमस्ते!" दूसरे शब्दों में, 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 Terminal में यहां दिया गया कमांड चलाएं:

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

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

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

ध्यान दें कि अपने 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 सेवाओं की खास जानकारी दिखेगी, इस तरह:

"सेवा बनाएं" पर क्लिक करें डिप्लॉयमेंट प्रोसेस शुरू करने के लिए इस लिंक पर क्लिक करें:

"नमस्ते" डालें डिफ़ॉल्ट डिप्लॉयमेंट प्लैटफ़ॉर्म और क्षेत्र चुनें और "आगे बढ़ें" पर क्लिक करें.

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

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

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

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

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

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

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

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

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

एक नया संशोधन बनाने के लिए अब उस बटन पर क्लिक करें. कंटेनर यूआरएल के पास, SELECT बटन पर क्लिक करें, जैसा कि नीचे दिखाया गया है:

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

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

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

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

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

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

आपके ऐप्लिकेशन के नए वर्शन की कैनरी से जांच की जा रही है. इसमें आने वाले ट्रैफ़िक के छोटे से हिस्से का इस्तेमाल किया जा रहा है
ट्रैफ़िक को समस्या वाले रिलीज़ से पिछले संशोधन पर वापस लाना
A/B टेस्टिंग

MANAGE TRAFFIC बटन यहां देखें:

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

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

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

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

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

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

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

टेस्ट करें

Cloud Shell Terminal में, लोड टेस्ट करने के लिए इस निर्देश को चलाएं:

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

इस खास जानकारी से हमें कई ज़रूरी आइटम के बारे में पता चलता है:

32,918 अनुरोध, 30 सेकंड के लिए करीब 1K/प्रति सेकंड की दर से भेजे गए.
कोई गड़बड़ी नहीं थी (सिर्फ़ 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 ऐप्लिकेशन बनाने के साथ-साथ उसे डिप्लॉय कर लिया है. इस दौरान, आपको कंटेनर और अपना कंटेनर बनाने का तरीका भी पता चला. साथ ही, आपको पता चला कि gcloud कमांड लाइन टूल और Cloud Console, दोनों का इस्तेमाल करके, Cloud Run की मदद से आपके ऐप्लिकेशन को डिप्लॉय करना कितना आसान है. अब आप जानते हैं कि अपने शानदार क्रिएशन पूरी दुनिया के साथ कैसे शेयर करें!

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

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

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

कोड लैब के ज़रिए चेक आउट करें...

एक्सप्लोर करने के लिए अन्य शानदार सुविधाएं...

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

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

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

Google Cloud Innovators मुफ़्त है और इसमें ये सुविधाएं शामिल हैं:

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

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