איך לפשט את האימות בין שירותים ב-Cloud Run באמצעות קישור מהיר

1. סקירה כללית

כשמפתחים מיקרו-שירותים או אפליקציות עם כמה סוכנים ב-Cloud Run, שירותי הקצה העורפי הפנימיים לא צריכים להיות פתוחים לאינטרנט הציבורי. במקום זאת, מגדירים כל שירות לקצה העורפי כך שידרוש אימות (--no-allow-unauthenticated) ומקצים את התפקיד Cloud Run Invoker‏ (roles/run.invoker) ב-IAM רק לגורמים מורשים.

באופן מסורתי, כדי לקרוא לשירות Cloud Run מאומת, האפליקציה שקוראת לשירות צריכה לבצע הזרקת אסימון ידנית בקוד. לפני שליחת בקשת HTTP, הקוד שולח שאילתה לשרת המטא-נתונים של Compute כדי לקבל טוקן של מזהה OpenID Connect ‏(OIDC) בחתימת Google. האסימון הזה מוגדר לכתובת ה-URL של הקהל של שירות היעד, והקוד שלכם מצרף אותו לכותרת Authorization: Bearer. כתיבה ותחזוקה של תשתית האימות בתוך קוד האפליקציה יוצרות חיכוך מיותר:

  • היא מצמידה את הלוגיקה העסקית שלכם לספריות האימות של Google Cloud, וכך מפחיתה את הקריאוּת והניידוּת בין סביבות.
  • הלוגיקה של קבלת הטוקן משתנה בהתאם לסוגי היעדים ולמצבי האבטחה. לדוגמה, ב-Cloud Run נדרשים טוקנים של מזהה של OIDC, ב-Google APIs נדרשים טוקני גישה של OAuth 2.0 וב-mTLS נדרשים אסימונים מקושרים.

ב-Cloud Run Express Link (גרסת טרום-השקה) לא צריך להוסיף אסימונים באופן ידני לקוד האפליקציה. מפעילים את Ambient Networking בשירות Cloud Run שמבצע את הקריאה (המקור), ויוצרים משאב ExpressLink הצהרתי שמקשר בין שירות המקור לשירות היעד. קובץ עזר חיצוני בניהול Google מיירט בקשות HTTP יוצאות בטקסט פשוט אל היעד, מוסיף באופן אוטומטי את אסימון הזהות של השירות שמבצע את הקריאה החוזרת ומצפין את החיבור ליעד.

ב-Codelab הזה נשווה בין שתי הגישות לאותו שירות קצה עורפי פרטי:

  1. פורסים שירות יעד פרטי ושירות מבצע קריאה (caller-oidc) שמאחזר טוקן של מזהה OIDC משרת המטא-נתונים של Compute ב-Python. השלב הזה מאשר את הקישוריות מקצה לקצה לקצה העורפי ומציג את קוד האימות שנדרש בלי Express Link.
  2. פורסים שירות מבצע קריאה חוזרת שני (caller-express-link) בלי הקוד לאחזור אסימונים מהמטא-נתונים, ומחברים אותו לשירות היעד באמצעות Ambient Networking וקישור מהיר.
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 ושירותי אינטרנט מסוג HTTP
  • היכרות בסיסית עם חשבונות שירות של Google Cloud IAM ועם פריסות של Cloud Run

מה תלמדו

  • איך פורסים שירות יעד פרטי של Cloud Run שאוכף אימות IAM
  • איך לאמת בקשות בין שירותים באופן ידני ב-Python באמצעות טוקנים של מזהה OIDC של google-auth משרת המטא-נתונים כדי לאמת את הקישוריות הבסיסית
  • איך מסירים קוד ידני לאחזור טוקנים ופורסים שירות מבצע קריאה ב-Cloud Run עם Ambient Networking מופעל
  • איך יוצרים קישור מהיר ל-Cloud Run כדי ששירות הקריאה יוכל להפעיל שירות יעד מאומת בלי קוד אימות

מה תפתחו

  • ‫destination: שירות פרטי של Python Flask ב-Cloud Run שחושף נקודת קצה (endpoint) מסוג /ping
  • ‫caller-oidc: שירות Python Flask שקורא ל-destination על ידי אחזור ידני והזרקה של טוקנים של מזהה OIDC בקוד האפליקציה
  • ‫caller-express-link: שירות Python Flask מקביל עם אפס קוד להזרקת אסימונים, שקורא לאותו שירות destination דרך קישור מהיר.

הדרישות

  • דפדפן אינטרנט, כמו Chrome
  • פרויקט ב-Google Cloud עם חיוב מופעל והרשאות ליצירת חשבונות שירות של IAM, שירותי Cloud Run ומשאבים של Network Services

2. הגדרת הסביבה

הגדרת פרויקט בענן ב-Google Cloud

  1. אם אין לכם עדיין חשבון Google, אתם צריכים ליצור חשבון Google.
    • להשתמש בחשבון לשימוש אישי במקום בחשבון של מקום עבודה או מוסד לימודים. בחשבונות של מקומות עבודה ומוסדות לימודים יכולות להיות הגבלות שמונעות הפעלה של ממשקי ה-API שנדרשים ל-Lab הזה.
  2. נכנסים למסוף Google Cloud.
  3. מפעילים את החיוב במסוף Cloud.
    • השלמת ה-Lab הזה אמורה לעלות פחות מ-1 דולר ארה"ב במשאבי Cloud.
    • כדי למנוע חיובים נוספים, אתם יכולים לפעול לפי השלבים שבסוף ה-Lab הזה כדי למחוק משאבים.
    • משתמשים חדשים זכאים לתקופת ניסיון בחינם בשווי 300$‎.
  4. יוצרים פרויקט חדש או בוחרים להשתמש בפרויקט קיים.
    • אם מופיעה שגיאה לגבי מכסת הפרויקטים, צריך להשתמש מחדש בפרויקט קיים או למחוק פרויקט קיים כדי ליצור פרויקט חדש.

הפעלת Cloud Shell

ב-Codelab הזה תשתמשו ב-Cloud Shell, סביבת שורת פקודה מבוססת-דפדפן שמותקנים בה מראש Google Cloud CLI‏ (gcloud),‏ Python ו-curl.

  1. במסוף Google Cloud, לוחצים על Activate Cloud Shell בסרגל הניווט העליון. אם מתבקשים, לוחצים על Authorize.
  2. מייצאים את מזהה הפרויקט ואת אזור הפריסה, ומגדירים את gcloud לשימוש ב-$PROJECT_ID. מחליפים את 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 והפעלת ממשקי API

  1. מעדכנים את הרכיבים של gcloud כדי לקבל את הפקודות העדכניות של beta ל-Ambient Networking ולקישור מהיר:
gcloud components update --quiet
  1. מפעילים את Cloud APIs הנדרשים של Google Cloud לפריסות של קוד מקור ב-Cloud Run, לחשבונות שירות של IAM, ל-Ambient Networking ול-Network Services Express Link:
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

יצירת ספריית סביבת עבודה

יוצרים ספריית עבודה שתכיל את שלוש תיקיות השירות שתיצרו ב-Codelab הזה:

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

3. פריסת שירות היעד הפרטי

קודם פורסים שירות פרטי של Cloud Run בשם destination. תשתמשו שוב בשירות היעד היחיד הזה בשני החלקים של ה-Codelab:

  • שירות היעד אף פעם לא מבצע הזרקת אסימון יוצא.
  • לא צריך להפעיל את Ambient Networking בשירות היעד כדי לקבל תנועה דרך קישור מהיר.
  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. מריצים את הפקודה הבאה כדי ליצור קובץ requirements.txt עם Flask ו-Gunicorn:
cat << 'EOF' > requirements.txt
Flask==3.0.0
gunicorn==21.2.0
EOF
  1. מריצים את הפקודה הבאה כדי ליצור קובץ main.py שחושף נקודת קצה (endpoint) מסוג /ping שמחזירה את שם השירות של Cloud Run ממשתנה הסביבה K_SERVICE:
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. פורסים את destination מקוד המקור באמצעות --no-allow-unauthenticated כדי ש-Cloud Run ידחה בקשות לא מאומתות:
gcloud run deploy destination \
    --source . \
    --region="$REGION" \
    --service-account="destination-identity@${PROJECT_ID}.iam.gserviceaccount.com" \
    --no-allow-unauthenticated
  1. שומרים את כתובת ה-URL הדטרמיניסטית של שירות היעד ואת ה-URI המלא של המשאב במשתני סביבה:
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. מקצים לחשבון המשתמש את התפקיד Cloud Run Invoker‏ (roles/run.invoker) ב-destination כדי שתוכלו לבדוק אותו ישירות מ-Cloud Shell:
gcloud run services add-iam-policy-binding destination \
    --member="user:$ACTIVE_ACCOUNT" \
    --role="roles/run.invoker" \
    --region="$REGION"
  1. שולחים בקשה מאומתת אל /ping באמצעות אסימון הזהות שלכם כדי לוודא ש-destination פועל:
TOKEN=$(gcloud auth print-identity-token)
curl -H "Authorization: Bearer $TOKEN" "$DESTINATION_URL/ping"

התגובה הבאה אמורה להופיע:

Hello from destination

4. שליחת קריאה ליעד בלי קישור מהיר

לפני שאתם מציגים את Express Link, בנו את caller-oidc כדי לראות מה נדרש היום לאימות בין שירותים, וודאו ששירות קורא יכול להגיע אל destination. כדי להתקשר אל destination באופן מאובטח בלי קישור מהיר, צריך להגדיר שתי שכבות:

  • הרשאת IAM: מקצים לחשבון השירות caller-oidc את התפקיד roles/run.invoker ב-destination.
  • הזרקת טוקן ברמת האפליקציה: מוסיפים את הספרייה google-auth אל caller-oidc ומנתחים את כתובת ה-URL של היעד כדי לחלץ את קהל היעד הבסיסי של OIDC. אחרי זה, מאחזרים טוקן של מזהה חתום משרת המטא-נתונים ומצרפים את Authorization: Bearer ID_TOKEN לבקשת ה-HTTPS היוצאת.

כדי להגדיר ולפרוס את 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. יוצרים את הספרייה caller-oidc לצד destination:
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. מריצים את הפקודה הבאה כדי ליצור קובץ main.py עם הזרקה ידנית של אסימון OIDC:
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. שומרים את כתובת ה-URL הדטרמיניסטית של caller-oidc ומפעילים אותה, ומעבירים את כתובת ה-URL מסוג HTTPS‏ $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. פריסת שירות המתקשר לקישור מהיר

עכשיו תיצרו שירות מתקשר שני בשם caller-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 כדי שה-sidecar המנוהל של Ambient Networking יוכל להוריד את הגדרות הניתוב והאבטחה של Express Link. צריך גם להעניק את ההרשאה roles/cloudtrace.agent כדי שה-sidecar יוכל לייצא את טווחי המעקב:
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-express-link לצד caller-oidc:
mkdir -p ~/express-link-codelab/caller-express-link
cd ~/express-link-codelab/caller-express-link
  1. מריצים את הפקודה הבאה כדי ליצור קובץ requirements.txt בלי google-auth:
cat << 'EOF' > requirements.txt
Flask==3.0.0
requests==2.31.0
gunicorn==21.2.0
EOF
  1. מריצים את הפקודה הבאה כדי ליצור קובץ main.py עם קריאת requests.get(target_url, timeout=10) פשוטה וללא לוגיקה של הזרקת טוקן:
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. מריצים את diff מול ../caller-oidc/main.py כדי לראות את קוד התבנית של האימות שהוסר:
diff -u ../caller-oidc/main.py main.py || true
  1. פורסים את caller-express-link באמצעות gcloud beta run deploy כש---ambient-networking ו---ambient-scope=global מופעלים:
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. מוודאים ש-Ambient Networking פעיל ב-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. שומרים את כתובת ה-URL ואת ה-URI של המשאב של caller-express-link, יחד עם כתובת ה-URL הדטרמיניסטית של HTTP (http://) של destination:
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. בודקים את השיחה אל destination דרך caller-express-link לפני שיוצרים קישור מהיר:
TOKEN=$(gcloud auth print-identity-token)
curl -H "Authorization: Bearer $TOKEN" "$CALLER_EL_URL/?target_url=$DESTINATION_HTTP_URL/ping"

כצפוי, הקריאה נכשלת עם השגיאה 403 Forbidden כי עדיין לא קיים קישור מהיר שיכול ליירט את הבקשה ולהוסיף את פרטי הכניסה:

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:
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. מציגים את רשימת הקישורים המהירים כדי לוודא שהמשאב קיים:
gcloud beta network-services express-links list --location=global

פלט פקודה:

NAME
caller-to-destination
  1. בודקים את פרטי ההגדרות של הקישור המהיר:
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. מריצים מחדש את אותה בקשת curl בדיוק מול caller-express-link:
TOKEN=$(gcloud auth print-identity-token)
curl -H "Authorization: Bearer $TOKEN" "$CALLER_EL_URL/?target_url=$DESTINATION_HTTP_URL/ping"

הפעם, ה-sidecar של Ambient מיירט את בקשת ה-HTTP אל destination, מוסיף את אסימון הזהות של caller-express-link-identity, משדרג את החיבור ל-TLS ומחזיר את התגובה של היעד:

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

בטבלה הבאה מפורטים השינויים בין caller-oidc ל-caller-express-link:

מאפיין

בלי קישור מהיר (caller-oidc)

עם קישור מהיר (caller-express-link)

ספריות אימות ב-requirements.txt

העמודה google-auth היא חובה

ללא (Flask, requests, gunicorn בלבד)

שיחה יוצאת ללקוח בעוד main.py

ניתוח כתובת ה-URL של הקהל, קריאה ל-id_token.fetch_id_token(), צירוף כותרת Authorization: Bearer

requests.get(target_url, timeout=10) פשוט

סכמת כתובת ה-URL לטירגוט באפליקציה

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

http://destination-PROJECT_NUMBER.REGION.run.app (שודרג ל-TLS על ידי Ambient sidecar)

הגדרת Cloud Run של הגורם שמבצע את הקריאה

פריסה רגילה

‫--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, מחקו את המשאבים שיצרתם במהלך ה-Codelab הזה.

  1. מוחקים את המשאב של הקישור המהיר:
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 רק בשביל ה-Codelab הזה, אתם יכולים למחוק את הפרויקט כולו:
# Run only if you want to delete the entire project and all its resources
gcloud projects delete "$PROJECT_ID"

8. מזל טוב

פרסתם שירות פרטי לקצה העורפי ב-Cloud Run וקראתם לו באמצעות הזרקה ידנית של אסימון OIDC ב-Python. אחר כך החלפתם את כל קוד האימות ברמת האפליקציה בקישור מהיר דקלרטיבי של Cloud Run.

מה למדתם

  • למה הזרקה ידנית של אסימוני OIDC מקשרת בין הלוגיקה העסקית של האפליקציה לבין ספריות האימות ומצבי האבטחה של הפלטפורמה
  • איך פורסים שירות יעד מאומת של Cloud Run שעובד בלי שינויים עם או בלי קישור מהיר
  • איך מפעילים את Ambient Networking (--ambient-networking עם --ambient-scope=global) ונותנים הרשאות לקוח של Traffic Director‏ (roles/trafficdirector.client) בשירות Cloud Run ששולח את הקריאה
  • איך יוצרים ובודקים משאב של Network Services ExpressLink שמזריק באופן אוטומטי אסימוני זהות ומשדרג קריאות http:// בטקסט פשוט מהקונטיינר לחיבורי TLS מוצפנים

השלבים הבאים