Express Link की मदद से, Cloud Run की एक सेवा से दूसरी सेवा की पुष्टि करने की प्रोसेस को आसान बनाना

1. खास जानकारी

Cloud Run पर माइक्रोसर्विस या मल्टी-एजेंट ऐप्लिकेशन बनाते समय, इंटरनल बैकएंड सेवाओं को सार्वजनिक इंटरनेट के लिए उपलब्ध नहीं कराया जाना चाहिए. इसके बजाय, हर बैकएंड सेवा को इस तरह कॉन्फ़िगर किया जाता है कि उसे ऐक्सेस करने के लिए पुष्टि (--no-allow-unauthenticated) की ज़रूरत पड़े. साथ ही, Cloud Run Invoker (roles/run.invoker) आईएएम भूमिका सिर्फ़ उन कॉलर को दी जाती है जिनके पास अनुमति है.

आम तौर पर, पुष्टि की गई Cloud Run सेवा को कॉल करने के लिए, आपके कॉल करने वाले ऐप्लिकेशन को कोड में मैन्युअल तरीके से टोकन इंजेक्शन करना पड़ता है. एचटीटीपी अनुरोध भेजने से पहले, आपका कोड Google के हस्ताक्षर वाले OpenID Connect (OIDC) आईडी टोकन के लिए, Compute Metadata Server से क्वेरी करता है. उस टोकन का दायरा, डेस्टिनेशन सेवा के ऑडियंस यूआरएल तक सीमित होता है. साथ ही, आपका कोड उसे Authorization: Bearer हेडर से अटैच करता है. ऐप्लिकेशन कोड में पुष्टि करने की प्रोसेस को लिखना और उसे बनाए रखना, बिना वजह की परेशानी पैदा करता है:

  • यह आपके कारोबारी नियम को Google Cloud की पुष्टि करने वाली लाइब्रेरी से जोड़ता है. इससे अलग-अलग एनवायरमेंट में, कोड को पढ़ने और उसे पोर्ट करने में मुश्किल होती है.
  • टोकन हासिल करने का लॉजिक, डेस्टिनेशन टाइप और सुरक्षा मोड के हिसाब से अलग-अलग होता है. उदाहरण के लिए, Cloud Run को ओआईडीसी आईडी टोकन की ज़रूरत होती है, Google API को OAuth 2.0 ऐक्सेस टोकन की ज़रूरत होती है, और एमटीएलएस को बाउंड टोकन की ज़रूरत होती है.

Cloud Run Express Link (झलक) की मदद से, आपके ऐप्लिकेशन कोड से मैन्युअल तरीके से टोकन डालने की सुविधा हट जाती है. कॉल करने वाली (सोर्स) Cloud Run सेवा पर ऐंबियंट नेटवर्किंग चालू करें. साथ ही, एक डिक्लेरेटिव ExpressLink संसाधन बनाएं, जो सोर्स सेवा को डेस्टिनेशन सेवा से बाइंड करता हो. Google की ओर से मैनेज की जाने वाली साइडकार प्रॉक्सी, डेस्टिनेशन पर जाने वाले सादे टेक्स्ट वाले एचटीटीपी अनुरोधों को इंटरसेप्ट करती है. साथ ही, कॉल करने वाली सेवा के आइडेंटिटी टोकन को अपने-आप इंजेक्ट करती है और डेस्टिनेशन के कनेक्शन को एन्क्रिप्ट (सुरक्षित) करती है.

इस कोडलैब में, दोनों तरीकों की तुलना एक ही निजी बैकएंड सेवा से की जाएगी:

  1. Python में, Compute Metadata Server से ओआईडीसी आईडी टोकन फ़ेच करने वाली कॉलर सेवा (caller-oidc) और निजी डेस्टिनेशन सेवा को डिप्लॉय करें. इस चरण से, बैकएंड से एंड-टू-एंड कनेक्टिविटी की पुष्टि होती है. साथ ही, एक्सप्रेस लिंक के बिना ज़रूरी पुष्टि करने वाला कोड दिखता है.
  2. मेटाडेटा टोकन फ़ेच करने वाले कोड को हटाकर, दूसरी कॉलर सेवा (caller-express-link) को डिप्लॉय करें. इसके बाद, एंबियंट नेटवर्किंग और एक्सप्रेस लिंक का इस्तेमाल करके, इसे डेस्टिनेशन सेवा से कनेक्ट करें.
PART 1: WITHOUT EXPRESS LINK (caller-oidc)
+----------------------------------------------+          +-----------------+
| Caller Service (caller-oidc)                 |  HTTPS   | Destination     |
|                                              | + token  | (destination)   |
|  App Container                               | -------> |                 |
|   1. Parse audience URL with urllib.parse    |          | Verifies caller |
|   2. Fetch OIDC ID token via google-auth     |          | has IAM role    |
|   3. Set Authorization: Bearer header        |          | run.invoker     |
+----------------------------------------------+          +-----------------+

PART 2: WITH EXPRESS LINK (caller-express-link)
+----------------------------------------------+          +-----------------+
| Caller Service (caller-express-link)         |  HTTPS   | Destination     |
|  +----------------+      +----------------+  | + token  | (destination)   |
|  | App Container  | HTTP | Ambient        |  | -------> |                 |
|  | requests.get() | ---> | Sidecar Proxy  |  |          | Same service    |
|  | (no auth code) |      | (Express Link) |  |          | as Part 1       |
|  +----------------+      +----------------+  |          | (unchanged)     |
+----------------------------------------------+          +-----------------+

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

  • Python और एचटीटीपी वेब सेवाओं के बारे में बुनियादी जानकारी
  • Google Cloud IAM सेवा खातों और Cloud Run डिप्लॉयमेंट के बारे में बुनियादी जानकारी

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

  • Cloud Run की ऐसी निजी डेस्टिनेशन सेवा को डिप्लॉय करने का तरीका जो आईएएम की पुष्टि की सुविधा लागू करती है
  • बेसलाइन कनेक्टिविटी की पुष्टि करने के लिए, मेटाडेटा सर्वर से google-auth ओआईडीसी आईडी टोकन का इस्तेमाल करके, Python में सर्विस-टू-सर्विस अनुरोधों की मैन्युअल तरीके से पुष्टि करने का तरीका
  • मैन्युअल तरीके से टोकन फ़ेच करने वाले कोड को हटाने और एंबियंट नेटवर्किंग की सुविधा चालू करके, Cloud Run कॉलर सेवा को डिप्लॉय करने का तरीका
  • Cloud Run एक्सप्रेस लिंक बनाने का तरीका, ताकि कॉलर सेवा, पुष्टि किए गए डेस्टिनेशन की सेवा को बिना किसी ऑथेंटिकेशन कोड के शुरू कर सके

आपको क्या बनाना होगा

  • destination: Cloud Run पर मौजूद एक निजी Python Flask सेवा, जो /ping एंडपॉइंट को एक्सपोज़ करती है
  • caller-oidc: यह Python Flask सेवा है, जो ऐप्लिकेशन कोड में ओआईडीसी आईडी टोकन को मैन्युअल तरीके से फ़ेच और इंजेक्ट करके, destination को कॉल करती है
  • caller-express-link: यह एक Python Flask सेवा है, जो बिना किसी टोकन-इंजेक्शन कोड के, Express Link के ज़रिए उसी डेस्टिनेशन सेवा को कॉल करती है

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

  • Chrome जैसा कोई वेब ब्राउज़र
  • बिलिंग की सुविधा वाला Google Cloud प्रोजेक्ट. साथ ही, इसमें आईएएम सेवा खाते, Cloud Run की सेवाएं, और नेटवर्क सेवाओं के संसाधन बनाने की अनुमतियां होनी चाहिए

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

Google Cloud प्रोजेक्ट सेट अप करना

  1. अगर आपके पास पहले से कोई Google खाता नहीं है, तो आपको Google खाता बनाना होगा.
    • ऑफ़िस या स्कूल वाले खाते के बजाय, निजी खाते का इस्तेमाल करें. ऑफ़िस और स्कूल वाले खातों पर कुछ पाबंदियां हो सकती हैं. इनकी वजह से, इस लैब के लिए ज़रूरी एपीआई चालू नहीं किए जा सकते.
  2. Google Cloud Console में साइन-इन करें.
  3. Cloud Console में जाकर, बिलिंग की सुविधा चालू करें.
    • इस लैब को पूरा करने में, Cloud के संसाधनों पर एक डॉलर से कम खर्च होना चाहिए.
    • इस लैब के आखिर में दिए गए तरीके का इस्तेमाल करके, संसाधनों को मिटाया जा सकता है, ताकि आगे कोई शुल्क न लगे.
    • नए उपयोगकर्ताओं को 300 डॉलर का क्रेडिट मुफ़्त में आज़माने के लिए मिलेगा.
  4. नया प्रोजेक्ट बनाएं या किसी मौजूदा प्रोजेक्ट को फिर से इस्तेमाल करने का विकल्प चुनें.
    • अगर आपको प्रोजेक्ट कोटा से जुड़ी कोई गड़बड़ी दिखती है, तो किसी मौजूदा प्रोजेक्ट का फिर से इस्तेमाल करें या नया प्रोजेक्ट बनाने के लिए किसी मौजूदा प्रोजेक्ट को मिटाएं.

Cloud Shell शुरू करना

इस कोडलैब में, Cloud Shell का इस्तेमाल किया जाता है. यह ब्राउज़र पर आधारित कमांड-लाइन एनवायरमेंट है. इसमें Google Cloud CLI (gcloud), Python, और curl पहले से इंस्टॉल होते हैं.

  1. Google Cloud console में, सबसे ऊपर मौजूद नेविगेशन बार में जाकर, Cloud Shell चालू करें पर क्लिक करें. जब कहा जाए, तब अनुमति दें पर क्लिक करें.
  2. अपना प्रोजेक्ट आईडी और डिप्लॉयमेंट रीजन एक्सपोर्ट करें. इसके बाद, $PROJECT_ID का इस्तेमाल करने के लिए gcloud को कॉन्फ़िगर करें. YOUR_PROJECT_ID को अपने प्रोजेक्ट आईडी से बदलें. इसके अलावा, us-west1 को Cloud Run के किसी अन्य क्षेत्र से बदला जा सकता है:
export PROJECT_ID="YOUR_PROJECT_ID"
export REGION="us-west1"
gcloud config set project "$PROJECT_ID"
  1. अपना प्रोजेक्ट नंबर और चालू Google Cloud खाता एक्सपोर्ट करें. साथ ही, पुष्टि करें कि चारों वैरिएबल भरे गए हैं:
export PROJECT_NUMBER=$(gcloud projects describe "$PROJECT_ID" --format="value(projectNumber)")
export ACTIVE_ACCOUNT=$(gcloud config get-value account 2>/dev/null)
echo "PROJECT_ID: $PROJECT_ID | PROJECT_NUMBER: $PROJECT_NUMBER | ACCOUNT: $ACTIVE_ACCOUNT | REGION: $REGION"

gcloud को अपडेट करना और एपीआई चालू करना

  1. gcloud कॉम्पोनेंट को अपडेट करें, ताकि आपके पास ऐंबियंट नेटवर्किंग और एक्सप्रेस लिंक के लिए, नए beta कमांड हों:
gcloud components update --quiet
  1. Cloud Run सोर्स डिप्लॉयमेंट, आईएएम सेवा खातों, एंबियंट नेटवर्किंग, और नेटवर्क सर्विसेज़ एक्सप्रेस लिंक के लिए, ज़रूरी Google Cloud एपीआई चालू करें:
gcloud services enable \
    iam.googleapis.com \
    run.googleapis.com \
    cloudbuild.googleapis.com \
    artifactregistry.googleapis.com \
    networkservices.googleapis.com \
    networksecurity.googleapis.com \
    trafficdirector.googleapis.com \
    cloudtrace.googleapis.com

वर्कस्पेस डायरेक्ट्री बनाना

इस कोडलैब में बनाए जाने वाले तीन सर्विस फ़ोल्डर को सेव करने के लिए, एक वर्किंग डायरेक्ट्री बनाएं:

mkdir -p ~/express-link-codelab
cd ~/express-link-codelab

3. प्राइवेट डेस्टिनेशन सेवा को डिप्लॉय करना

सबसे पहले, आपको destination नाम की Cloud Run की एक निजी सेवा डिप्लॉय करनी होगी. कोड लैब के दोनों हिस्सों के लिए, इस सिंगल डेस्टिनेशन सर्विस का फिर से इस्तेमाल किया जाएगा:

  • डेस्टिनेशन सेवा, आउटबाउंड टोकन इंजेक्शन कभी नहीं करती.
  • एक्सप्रेस लिंक से ट्रैफ़िक पाने के लिए, डेस्टिनेशन सेवा में एंबियंट नेटवर्किंग की सुविधा चालू करने की ज़रूरत नहीं होती.
  1. डेस्टिनेशन सेवा के लिए, एक खास IAM सेवा खाता बनाएं:
gcloud iam service-accounts create destination-identity \
    --display-name="Cloud Run destination service account"
  1. destination फ़ोल्डर बनाएं और उसमें ले जाएं:
mkdir -p ~/express-link-codelab/destination
cd ~/express-link-codelab/destination
  1. Flask और Gunicorn की मदद से requirements.txt फ़ाइल बनाने के लिए, यह कमांड चलाएं:
cat << 'EOF' > requirements.txt
Flask==3.0.0
gunicorn==21.2.0
EOF
  1. main.py फ़ाइल बनाने के लिए, यह कमांड चलाएं. यह फ़ाइल, /ping एंडपॉइंट को एक्सपोज़ करती है. यह एंडपॉइंट, K_SERVICE एनवायरमेंट वैरिएबल से Cloud Run सेवा का नाम दिखाता है:
cat << 'EOF' > main.py
import os
from flask import Flask

app = Flask(__name__)

@app.route("/ping")
def ping():
    service_name = os.environ.get("K_SERVICE", "unknown")
    return f"Hello from {service_name}"

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=int(os.environ.get("PORT", 8080)))
EOF
  1. --no-allow-unauthenticated का इस्तेमाल करके, सोर्स से destination डिप्लॉय करें, ताकि Cloud Run बिना पुष्टि वाले अनुरोधों को अस्वीकार कर सके:
gcloud run deploy destination \
    --source . \
    --region="$REGION" \
    --service-account="destination-identity@${PROJECT_ID}.iam.gserviceaccount.com" \
    --no-allow-unauthenticated
  1. डेस्टिनेशन सेवा के डिटरमिनिस्टिक यूआरएल और पूरे रिसॉर्स यूआरआई को एनवायरमेंट वैरिएबल में सेव करें:
export DESTINATION_URL="https://destination-${PROJECT_NUMBER}.${REGION}.run.app"
export DESTINATION_URI="//run.googleapis.com/projects/${PROJECT_NUMBER}/locations/${REGION}/services/destination"
echo "DESTINATION_URL: $DESTINATION_URL"
echo "DESTINATION_URI: $DESTINATION_URI"
  1. अपने उपयोगकर्ता खाते को destination पर Cloud Run Invoker (roles/run.invoker) की भूमिका दें, ताकि Cloud Shell से सीधे इसकी जांच की जा सके:
gcloud run services add-iam-policy-binding destination \
    --member="user:$ACTIVE_ACCOUNT" \
    --role="roles/run.invoker" \
    --region="$REGION"
  1. destination चल रहा है, इसकी पुष्टि करने के लिए अपने आइडेंटिटी टोकन का इस्तेमाल करके, /ping को पुष्टि किया गया अनुरोध भेजें:
TOKEN=$(gcloud auth print-identity-token)
curl -H "Authorization: Bearer $TOKEN" "$DESTINATION_URL/ping"

आपको यह जवाब दिखेगा:

Hello from destination

4. एक्सप्रेस लिंक के बिना डेस्टिनेशन को कॉल करना

Express Link को लॉन्च करने से पहले, caller-oidc बनाएं. इससे आपको यह पता चलेगा कि मौजूदा समय में, एक सेवा से दूसरी सेवा की पुष्टि करने के लिए क्या ज़रूरी है. साथ ही, यह पुष्टि करें कि कॉल करने वाली सेवा, destination तक पहुंच सकती है. एक्सप्रेस लिंक के बिना destination को सुरक्षित तरीके से कॉल करने के लिए, आपको दो लेयर कॉन्फ़िगर करनी होंगी:

  • आईएएम की अनुमति: caller-oidc सेवा खाते को destination पर roles/run.invoker की भूमिका दें.
  • ऐप्लिकेशन-लेवल पर टोकन इंजेक्शन: google-auth लाइब्रेरी को caller-oidc में जोड़ें और टारगेट यूआरएल को पार्स करके, रूट ओआईडीसी ऑडियंस को निकालें. इसके बाद, मेटाडेटा सर्वर से साइन किया गया आईडी टोकन फ़ेच करें और आउटबाउंड एचटीटीपीएस अनुरोध में Authorization: Bearer ID_TOKEN अटैच करें.

caller-oidc को कॉन्फ़िगर और डिप्लॉय करने के लिए, यह तरीका अपनाएं:

  1. caller-oidc के लिए एक खास सेवा खाता बनाएं:
gcloud iam service-accounts create caller-oidc-identity \
    --display-name="Cloud Run OIDC caller service account"
  1. caller-oidc-identity को destination को शुरू करने की अनुमति दें:
gcloud run services add-iam-policy-binding destination \
    --member="serviceAccount:caller-oidc-identity@${PROJECT_ID}.iam.gserviceaccount.com" \
    --role="roles/run.invoker" \
    --region="$REGION"
  1. destination के साथ caller-oidc डायरेक्ट्री बनाएं:
mkdir -p ~/express-link-codelab/caller-oidc
cd ~/express-link-codelab/caller-oidc
  1. requirements.txt फ़ाइल बनाने के लिए, यह कमांड चलाएं. ध्यान दें कि आपको अपने ऐप्लिकेशन कंटेनर में टोकन वापस पाने की प्रोसेस को मैनेज करने के लिए, खास तौर पर google-auth जोड़ना होगा:
cat << 'EOF' > requirements.txt
Flask==3.0.0
google-auth==2.23.0
requests==2.31.0
gunicorn==21.2.0
EOF
  1. मैन्युअल तरीके से OIDC टोकन इंजेक्शन वाली main.py फ़ाइल बनाने के लिए, यह कमांड चलाएं:
cat << 'EOF' > main.py
import os
from urllib.parse import urlparse
from flask import Flask, request
from google.auth.transport.requests import Request as GoogleAuthRequest
from google.oauth2 import id_token
import requests

app = Flask(__name__)

@app.route("/ping")
def ping():
    service_name = os.environ.get("K_SERVICE", "unknown")
    return f"Hello from {service_name}"

@app.route("/")
def call_destination():
    target_url = request.args.get("target_url")
    if not target_url:
        return "Error: target_url query parameter not set.", 400

    try:
        # 1. Extract the root service URL (scheme + host) for the OIDC audience claim
        parsed_url = urlparse(target_url)
        target_audience = f"{parsed_url.scheme}://{parsed_url.netloc}"

        # 2. Fetch a Google-signed OIDC ID token from the metadata server
        auth_req = GoogleAuthRequest()
        token = id_token.fetch_id_token(auth_req, target_audience)

        # 3. Inject the token as an HTTP Bearer header
        headers = {"Authorization": f"Bearer {token}"}
        response = requests.get(target_url, headers=headers, timeout=10)
        return f"I called the destination and it replied: '{response.text}'"
    except Exception as e:
        return f"Error calling destination: {str(e)}", 500

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=int(os.environ.get("PORT", 8080)))
EOF
  1. caller-oidc को Cloud Run पर डिप्लॉय करें:
gcloud run deploy caller-oidc \
    --source . \
    --region="$REGION" \
    --service-account="caller-oidc-identity@${PROJECT_ID}.iam.gserviceaccount.com" \
    --no-allow-unauthenticated
  1. अपने उपयोगकर्ता खाते को caller-oidc को शुरू करने की अनुमति दें:
gcloud run services add-iam-policy-binding caller-oidc \
    --member="user:$ACTIVE_ACCOUNT" \
    --role="roles/run.invoker" \
    --region="$REGION"
  1. caller-oidc के डिटरमिनिस्टिक यूआरएल को सेव करें और उसे शुरू करें. इसके लिए, एचटीटीपीएस यूआरएल $DESTINATION_URL/ping को target_url के तौर पर पास करें:
export CALLER_OIDC_URL="https://caller-oidc-${PROJECT_NUMBER}.${REGION}.run.app"
TOKEN=$(gcloud auth print-identity-token)
curl -H "Authorization: Bearer $TOKEN" "$CALLER_OIDC_URL/?target_url=$DESTINATION_URL/ping"

आपको destination से जवाब मिल जाएगा:

I called the destination and it replied: 'Hello from destination'

5. Express Link के लिए कॉलर सेवा डिप्लॉय करना

अब आपको सिबलिंग डायरेक्ट्री में, caller-express-link नाम की दूसरी कॉलर सेवा बनानी होगी. Express Link की मदद से, caller-express-link को टोकन-इंजेक्शन कोड की ज़रूरत नहीं पड़ती—यह सीधे requests.get(target_url, timeout=10) को कॉल करता है.

  1. caller-express-link के लिए एक खास सेवा खाता बनाएं:
gcloud iam service-accounts create caller-express-link-identity \
    --display-name="Cloud Run Express Link caller service account"
  1. caller-express-link-identity को roles/trafficdirector.client की भूमिका दें, ताकि मैनेज किया जा रहा Ambient Networking साइडकार, Express Link की रूटिंग और सुरक्षा कॉन्फ़िगरेशन को डाउनलोड कर सके. roles/cloudtrace.agent को भी अनुमति दें, ताकि साइडकार, ट्रेस स्पैन एक्सपोर्ट कर सके:
gcloud projects add-iam-policy-binding "$PROJECT_ID" \
    --member="serviceAccount:caller-express-link-identity@${PROJECT_ID}.iam.gserviceaccount.com" \
    --role="roles/trafficdirector.client"

gcloud projects add-iam-policy-binding "$PROJECT_ID" \
    --member="serviceAccount:caller-express-link-identity@${PROJECT_ID}.iam.gserviceaccount.com" \
    --role="roles/cloudtrace.agent"
  1. caller-oidc के साथ caller-express-link डायरेक्ट्री बनाएं:
mkdir -p ~/express-link-codelab/caller-express-link
cd ~/express-link-codelab/caller-express-link
  1. google-auth के बिना requirements.txt फ़ाइल बनाने के लिए, यह कमांड चलाएं:
cat << 'EOF' > requirements.txt
Flask==3.0.0
requests==2.31.0
gunicorn==21.2.0
EOF
  1. बिना टोकन-इंजेक्शन लॉजिक के, सामान्य requests.get(target_url, timeout=10) कॉल वाली main.py फ़ाइल बनाने के लिए, यह कमांड चलाएं:
cat << 'EOF' > main.py
import os
from flask import Flask, request
import requests

app = Flask(__name__)

@app.route("/ping")
def ping():
    service_name = os.environ.get("K_SERVICE", "unknown")
    return f"Hello from {service_name}"

@app.route("/")
def call_destination():
    target_url = request.args.get("target_url")
    if not target_url:
        return "Error: target_url query parameter not set.", 400

    try:
        response = requests.get(target_url, timeout=10)
        return f"I called the destination and it replied: '{response.text}'"
    except Exception as e:
        return f"Error calling destination: {str(e)}", 500

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=int(os.environ.get("PORT", 8080)))
EOF
  1. ../caller-oidc/main.py के ख़िलाफ़ diff चलाएं, ताकि आपको पुष्टि करने के लिए इस्तेमाल किया जाने वाला वह बॉयलरप्लेट दिखे जिसे आपने हटा दिया है:
diff -u ../caller-oidc/main.py main.py || true
  1. --ambient-networking और --ambient-scope=global को चालू करके, gcloud beta run deploy का इस्तेमाल करके caller-express-link को डिप्लॉय करें:
gcloud beta run deploy caller-express-link \
    --source . \
    --region="$REGION" \
    --service-account="caller-express-link-identity@${PROJECT_ID}.iam.gserviceaccount.com" \
    --no-allow-unauthenticated \
    --ambient-networking \
    --ambient-scope=global
  1. पुष्टि करें कि caller-express-link पर ऐंबियंट नेटवर्किंग की सुविधा चालू है:
gcloud run services describe caller-express-link --region="$REGION"

बदलाव की खास जानकारी के आखिर में, पुष्टि करें कि Ambient Networking और Ambient Scope दिख रहे हैं:

  Ambient Networking: Enabled
  Ambient Scope:     global
  1. अपने उपयोगकर्ता खाते को caller-express-link को शुरू करने की अनुमति दें. साथ ही, caller-express-link-identity को destination को शुरू करने की अनुमति दें:
gcloud run services add-iam-policy-binding caller-express-link \
    --member="user:$ACTIVE_ACCOUNT" \
    --role="roles/run.invoker" \
    --region="$REGION"

gcloud run services add-iam-policy-binding destination \
    --member="serviceAccount:caller-express-link-identity@${PROJECT_ID}.iam.gserviceaccount.com" \
    --role="roles/run.invoker" \
    --region="$REGION"
  1. caller-express-link के यूआरएल और संसाधन यूआरआई को destination के HTTP (http://) डिटरमिनिस्टिक यूआरएल के साथ सेव करें:
export CALLER_EL_URL="https://caller-express-link-${PROJECT_NUMBER}.${REGION}.run.app"
export CALLER_EL_URI="//run.googleapis.com/projects/${PROJECT_NUMBER}/locations/${REGION}/services/caller-express-link"
export DESTINATION_HTTP_URL="http://destination-${PROJECT_NUMBER}.${REGION}.run.app"
echo "CALLER_EL_URL: $CALLER_EL_URL"
echo "CALLER_EL_URI: $CALLER_EL_URI"
echo "DESTINATION_HTTP_URL: $DESTINATION_HTTP_URL"
  1. एक्सप्रेस लिंक बनाने से पहले, caller-express-link के ज़रिए destination को कॉल करके देखें:
TOKEN=$(gcloud auth print-identity-token)
curl -H "Authorization: Bearer $TOKEN" "$CALLER_EL_URL/?target_url=$DESTINATION_HTTP_URL/ping"

उम्मीद के मुताबिक, कॉल 403 Forbidden के साथ फ़ेल हो जाता है, क्योंकि अनुरोध को इंटरसेप्ट करने और क्रेडेंशियल इंजेक्ट करने के लिए, अब तक कोई Express Link मौजूद नहीं है:

I called the destination and it replied: '
<html><head>
<meta http-equiv="content-type" content="text/html;charset=utf-8">
<title>403 Forbidden</title>
</head>
<body text=#000000 bgcolor=#ffffff>
<h1>Error: Forbidden</h1>
<h2>Your client does not have permission to get URL <code>/ping</code> from this server.</h2>
<h2></h2>
</body></html>
'

6. एक्सप्रेस लिंक की मदद से सेवाओं को कनेक्ट करना

अब आपको ExpressLink संसाधन का एलान करना होगा, जो caller-express-link (सोर्स सेवा) को destination से कनेक्ट करता है. इसके लिए, आपको कोड की एक भी लाइन बदलने या Cloud Run की किसी भी सेवा को फिर से डिप्लॉय करने की ज़रूरत नहीं है.

  1. global जगह पर Express Link संसाधन बनाएं:
gcloud beta network-services express-links create caller-to-destination \
    --location=global \
    --description="Express Link from caller-express-link to destination" \
    --source-services="$CALLER_EL_URI" \
    --destination-services="$DESTINATION_URI"
  1. संसाधन के मौजूद होने की पुष्टि करने के लिए, अपने Express लिंक की सूची बनाएं:
gcloud beta network-services express-links list --location=global

कमांड आउटपुट:

NAME
caller-to-destination
  1. Express Link के कॉन्फ़िगरेशन की जानकारी देखें:
gcloud beta network-services express-links describe caller-to-destination --location=global

कमांड आउटपुट:

createTime: '2026-10-27T19:30:04.492105068Z'
description: Express Link from caller-express-link to destination
destination:
  services:
  - //run.googleapis.com/projects/PROJECT_NUMBER/locations/us-west1/services/destination
etag: ...
name: projects/PROJECT_ID/locations/global/expressLinks/caller-to-destination
source:
  services:
  - //run.googleapis.com/projects/PROJECT_NUMBER/locations/us-west1/services/caller-express-link
updateTime: '2026-10-27T19:30:11.309054865Z'
  1. caller-express-link के लिए, curl अनुरोध को फिर से चलाएं:
TOKEN=$(gcloud auth print-identity-token)
curl -H "Authorization: Bearer $TOKEN" "$CALLER_EL_URL/?target_url=$DESTINATION_HTTP_URL/ping"

इस बार, एंबियंट साइडकार destination को भेजे गए एचटीटीपी अनुरोध को इंटरसेप्ट करता है, caller-express-link-identity के लिए आइडेंटिटी टोकन इंजेक्ट करता है, कनेक्शन को टीएलएस पर अपग्रेड करता है, और डेस्टिनेशन का रिस्पॉन्स दिखाता है:

I called the destination and it replied: 'Hello from destination'

यहां दी गई टेबल में, caller-oidc और caller-express-link के बीच हुए बदलावों की खास जानकारी दी गई है:

डाइमेंशन

Express Link के बिना (caller-oidc)

Express Link (caller-express-link) के साथ

requirements.txt में ऑथ लाइब्रेरी

google-auth की ज़रूरत है

कोई नहीं (सिर्फ़ Flask, requests, gunicorn)

main.py में आउटबाउंड कॉल

ऑडियंस का यूआरएल पार्स करें, id_token.fetch_id_token() को कॉल करें, और Authorization: Bearer हेडर अटैच करें

सादा requests.get(target_url, timeout=10)

ऐप्लिकेशन में टारगेट यूआरएल स्कीम

https://destination-PROJECT_NUMBER.REGION.run.app

http://destination-PROJECT_NUMBER.REGION.run.app (Ambient साइडकार ने टीएलएस पर अपग्रेड किया)

कॉलर क्लाउड रन कॉन्फ़िगरेशन

स्टैंडर्ड डिप्लॉयमेंट

कॉलर सेवा खाते पर --ambient-networking --ambient-scope=global + roles/trafficdirector.client

डेस्टिनेशन Cloud Run का कॉन्फ़िगरेशन

--no-allow-unauthenticated + roles/run.invoker

कोई बदलाव नहीं किया गया (--no-allow-unauthenticated + roles/run.invoker)

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

अपने Google Cloud खाते पर लगातार लगने वाले शुल्कों से बचने के लिए, इस कोडलैब के दौरान बनाए गए संसाधनों को मिटा दें.

  1. Express Link संसाधन को मिटाना:
gcloud beta network-services express-links delete caller-to-destination --location=global --quiet
  1. Cloud Run की ये तीन सेवाएं मिटाएं:
gcloud run services delete caller-express-link --region="$REGION" --quiet
gcloud run services delete caller-oidc --region="$REGION" --quiet
gcloud run services delete destination --region="$REGION" --quiet
  1. प्रोजेक्ट-लेवल की IAM नीति की बाइंडिंग हटाएं और तीनों सेवा खातों को मिटाएं:
gcloud projects remove-iam-policy-binding "$PROJECT_ID" \
    --member="serviceAccount:caller-express-link-identity@${PROJECT_ID}.iam.gserviceaccount.com" \
    --role="roles/trafficdirector.client" \
    --quiet

gcloud projects remove-iam-policy-binding "$PROJECT_ID" \
    --member="serviceAccount:caller-express-link-identity@${PROJECT_ID}.iam.gserviceaccount.com" \
    --role="roles/cloudtrace.agent" \
    --quiet

gcloud iam service-accounts delete "caller-express-link-identity@${PROJECT_ID}.iam.gserviceaccount.com" --quiet
gcloud iam service-accounts delete "caller-oidc-identity@${PROJECT_ID}.iam.gserviceaccount.com" --quiet
gcloud iam service-accounts delete "destination-identity@${PROJECT_ID}.iam.gserviceaccount.com" --quiet
  1. (ज़रूरी नहीं) अगर आपने सिर्फ़ इस कोडलैब के लिए कोई Google Cloud प्रोजेक्ट बनाया है, तो पूरे प्रोजेक्ट को मिटाया जा सकता है:
# Run only if you want to delete the entire project and all its resources
gcloud projects delete "$PROJECT_ID"

8. बधाई हो

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

आपने क्या सीखा

  • मैन्युअल तरीके से ओआईडीसी टोकन इंजेक्शन, ऐप्लिकेशन के कारोबारी नियम को प्लैटफ़ॉर्म की पुष्टि करने वाली लाइब्रेरी और सुरक्षा मोड से क्यों जोड़ता है
  • पुष्टि की गई Cloud Run डेस्टिनेशन सेवा को डिप्लॉय करने का तरीका, जो एक्सप्रेस लिंक के साथ या उसके बिना काम करती है
  • कॉल करने वाली Cloud Run सेवा पर, एंबियंट नेटवर्किंग (--ambient-networking के साथ --ambient-scope=global) को चालू करने और Traffic Director क्लाइंट को अनुमतियां (roles/trafficdirector.client) देने का तरीका
  • नेटवर्क सेवाओं का ExpressLink संसाधन बनाने और उसकी जांच करने का तरीका. यह संसाधन, आपके कंटेनर से एन्क्रिप्ट किए गए टीएलएस कनेक्शन पर, आइडेंटिटी टोकन अपने-आप इंजेक्ट करता है और प्लेनटेक्स्ट http:// कॉल को अपग्रेड करता है

अगले चरण