Dienst-zu-Dienst-Authentifizierung in Cloud Run mit Express Link vereinfachen

1. Übersicht

Wenn Sie Mikrodienste oder Multi-Agent-Anwendungen in Cloud Run erstellen, sollten interne Backend-Dienste nicht über das öffentliche Internet zugänglich sein. Stattdessen konfigurieren Sie jeden Backend-Dienst so, dass eine Authentifizierung (--no-allow-unauthenticated) erforderlich ist, und weisen die IAM-Rolle „Cloud Run Invoker“ (roles/run.invoker) nur autorisierten Aufrufern zu.

Traditionell erfordert der Aufruf eines authentifizierten Cloud Run-Dienstes, dass die aufrufende Anwendung eine manuelle Token-Injektion im Code durchführt. Bevor eine HTTP-Anfrage gesendet wird, fragt Ihr Code den Compute Metadata Server nach einem von Google signierten OpenID Connect-ID-Token (OIDC) ab. Dieses Token ist auf die Zielgruppen-URL des Zieldienstes beschränkt und wird von Ihrem Code an den Header Authorization: Bearer angehängt. Das Schreiben und Verwalten von Authentifizierungscode im Anwendungscode führt zu unnötigem Aufwand:

  • Ihre Geschäftslogik wird mit Google Cloud-Authentifizierungsbibliotheken verknüpft, was die Lesbarkeit und Portabilität in verschiedenen Umgebungen beeinträchtigt.
  • Die Logik für die Token-Erfassung variiert je nach Zieltyp und Sicherheitsmodus. Cloud Run erwartet beispielsweise OIDC-ID-Tokens, Google APIs erwarten OAuth 2.0-Zugriffstokens und mTLS erfordert gebundene Tokens.

Mit Cloud Run Express Link (Vorabversion) wird die manuelle Token-Injektion aus Ihrem Anwendungscode entfernt. Sie aktivieren Ambient Networking für den aufrufenden Cloud Run-Dienst (Quelle) und erstellen eine deklarative ExpressLink-Ressource, die den Quelldienst an den Zieldienst bindet. Ein von Google verwalteter Sidecar-Proxy fängt ausgehende HTTP-Anfragen im Klartext an das Ziel ab, fügt automatisch das Identitätstoken des aufrufenden Dienstes ein und verschlüsselt die Verbindung zum Ziel.

In diesem Codelab vergleichen Sie beide Ansätze mit demselben privaten Backend-Dienst:

  1. Stellen Sie einen privaten Zieldienst und einen Aufruferdienst (caller-oidc) bereit, der ein OIDC-ID-Token vom Compute Metadata Server in Python abruft. In diesem Schritt wird die End-to-End-Verbindung zum Backend bestätigt und der Authentifizierungscode angezeigt, der ohne Express Link erforderlich ist.
  2. Stellen Sie einen zweiten Aufrufdienst (caller-express-link) bereit, bei dem der Code zum Abrufen von Metadatentokens entfernt wurde, und verbinden Sie ihn über Ambient Networking und einen Express Link mit dem Zieldienst.
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)     |
+----------------------------------------------+          +-----------------+

Vorbereitung

  • Grundkenntnisse in Python und HTTP-Webdiensten
  • Grundkenntnisse in Google Cloud IAM-Dienstkonten und Cloud Run-Bereitstellungen

Lerninhalte

  • Privaten Cloud Run-Zieldienst bereitstellen, der die IAM-Authentifizierung erzwingt
  • Dienst-zu-Dienst-Anfragen manuell in Python mit google-auth-OIDC-ID-Tokens vom Metadatenserver authentifizieren, um die grundlegende Verbindung zu prüfen
  • Code zum manuellen Abrufen von Tokens entfernen und einen Cloud Run-Aufrufdienst mit aktiviertem Ambient Networking bereitstellen
  • Cloud Run Express Link erstellen, damit Ihr Aufrufdienst einen authentifizierten Zieldienst ohne Authentifizierungscode aufrufen kann

Aufgaben

  • destination: Ein privater Python Flask-Dienst in Cloud Run, der einen /ping-Endpunkt bereitstellt.
  • caller-oidc: Ein Python Flask-Dienst, der destination aufruft, indem er OIDC-ID-Tokens manuell abruft und in den Anwendungscode einfügt.
  • caller-express-link: Ein paralleler Python Flask-Dienst ohne Token-Injektionscode, der denselben destination-Dienst über einen Express Link aufruft.

Voraussetzungen

  • Ein Webbrowser wie Chrome
  • Ein Google Cloud-Projekt mit aktivierter Abrechnung und Berechtigungen zum Erstellen von IAM-Dienstkonten, Cloud Run-Diensten und Netzwerkdienstressourcen

2. Umgebung einrichten

Google Cloud-Projekt einrichten

  1. Wenn Sie noch kein Google-Konto haben, müssen Sie eines erstellen.
    • Verwenden Sie ein privates Konto anstelle eines Arbeitskontos oder eines Kontos einer Bildungseinrichtung. Bei Arbeitskonten und Konten einer Bildungseinrichtung gelten möglicherweise Einschränkungen, die verhindern, dass Sie die für dieses Lab erforderlichen APIs aktivieren können.
  2. Melden Sie sich in der Google Cloud Console an.
  3. Abrechnung in der Cloud Console aktivieren
    • Die Kosten für die Cloud-Ressourcen, die Sie für dieses Lab benötigen, sollten unter 1 $ liegen.
    • Am Ende dieses Labs finden Sie eine Anleitung zum Löschen von Ressourcen, um weitere Kosten zu vermeiden.
    • Neue Nutzer können den kostenlosen Testzeitraum mit einem Guthaben von 300 $ in Anspruch nehmen.
  4. Erstellen Sie ein neues Projekt oder verwenden Sie ein vorhandenes Projekt.
    • Wenn Sie eine Fehlermeldung zum Projektkontingent erhalten, verwenden Sie ein vorhandenes Projekt oder löschen Sie ein vorhandenes Projekt, um ein neues zu erstellen.

Cloud Shell starten

In diesem Codelab verwenden Sie Cloud Shell, eine browserbasierte Befehlszeilenumgebung, in der die Google Cloud CLI (gcloud), Python und curl vorinstalliert sind.

  1. Klicken Sie in der Google Cloud Console in der oberen Navigationsleiste auf Cloud Shell aktivieren. Klicken Sie auf Autorisieren, wenn Sie dazu aufgefordert werden.
  2. Exportieren Sie Ihre Projekt-ID und die Bereitstellungsregion und konfigurieren Sie gcloud für die Verwendung von $PROJECT_ID. Ersetzen Sie YOUR_PROJECT_ID durch Ihre Projekt-ID und optional us-west1 durch eine andere Cloud Run-Region:
export PROJECT_ID="YOUR_PROJECT_ID"
export REGION="us-west1"
gcloud config set project "$PROJECT_ID"
  1. Exportieren Sie Ihre Projektnummer und Ihr aktives Google Cloud-Konto und prüfen Sie, ob alle vier Variablen ausgefüllt sind:
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 aktualisieren und APIs aktivieren

  1. Aktualisieren Sie Ihre gcloud-Komponenten, damit Sie die neuesten beta-Befehle für Ambient Networking und Express Link haben:
gcloud components update --quiet
  1. Aktivieren Sie die erforderlichen Google Cloud APIs für Cloud Run-Quellbereitstellungen, IAM-Dienstkonten, Ambient Networking und 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

Arbeitsbereichsverzeichnis erstellen

Erstellen Sie ein Arbeitsverzeichnis für die drei Dienstordner, die Sie in diesem Codelab erstellen:

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

3. Privaten Zieldienst bereitstellen

Zuerst stellen Sie einen privaten Cloud Run-Dienst mit dem Namen destination bereit. Sie verwenden diesen einzelnen Zieldienst für beide Teile des Codelabs wieder:

  • Ein Zieldienst führt niemals eine ausgehende Token-Injektion durch.
  • Für einen Zieldienst muss Ambient Networking nicht aktiviert sein, um Traffic über einen Express Link zu empfangen.
  1. Erstellen Sie ein dediziertes IAM-Dienstkonto für den Zieldienst:
gcloud iam service-accounts create destination-identity \
    --display-name="Cloud Run destination service account"
  1. Erstellen Sie einen Ordner destination und wechseln Sie dorthin:
mkdir -p ~/express-link-codelab/destination
cd ~/express-link-codelab/destination
  1. Führen Sie den folgenden Befehl aus, um eine requirements.txt-Datei mit Flask und Gunicorn zu erstellen:
cat << 'EOF' > requirements.txt
Flask==3.0.0
gunicorn==21.2.0
EOF
  1. Führen Sie den folgenden Befehl aus, um eine main.py-Datei zu erstellen, die einen /ping-Endpunkt verfügbar macht, der den Cloud Run-Dienstnamen aus der Umgebungsvariable K_SERVICE zurückgibt:
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. Stellen Sie destination aus der Quelle mit --no-allow-unauthenticated bereit, damit Cloud Run nicht authentifizierte Anfragen ablehnt:
gcloud run deploy destination \
    --source . \
    --region="$REGION" \
    --service-account="destination-identity@${PROJECT_ID}.iam.gserviceaccount.com" \
    --no-allow-unauthenticated
  1. Speichern Sie die deterministische URL und den vollständigen Ressourcen-URI des Zieldienstes in Umgebungsvariablen:
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. Weisen Sie Ihrem Nutzerkonto die Rolle „Cloud Run-Aufrufer“ (roles/run.invoker) für destination zu, damit Sie sie direkt über Cloud Shell testen können:
gcloud run services add-iam-policy-binding destination \
    --member="user:$ACTIVE_ACCOUNT" \
    --role="roles/run.invoker" \
    --region="$REGION"
  1. Senden Sie eine authentifizierte Anfrage an /ping mit Ihrem eigenen Identitätstoken, um zu bestätigen, dass destination ausgeführt wird:
TOKEN=$(gcloud auth print-identity-token)
curl -H "Authorization: Bearer $TOKEN" "$DESTINATION_URL/ping"

Sie sollten die folgende Antwort sehen:

Hello from destination

4. Ziel ohne Express Link aufrufen

Bevor Sie Express Link einführen, erstellen Sie caller-oidc, um zu sehen, was für die Dienst-zu-Dienst-Authentifizierung heute erforderlich ist, und prüfen Sie, ob ein aufrufender Dienst destination erreichen kann. Wenn Sie destination ohne Express Link sicher aufrufen möchten, müssen Sie zwei Ebenen konfigurieren:

  • IAM-Autorisierung: Weisen Sie dem Dienstkonto caller-oidc die Rolle roles/run.invoker für destination zu.
  • Token-Injektion auf Anwendungsebene: Fügen Sie die Bibliothek google-auth zu caller-oidc hinzu und parsen Sie die Ziel-URL, um die OIDC-Stammzielgruppe zu extrahieren. Rufen Sie dann ein signiertes ID-Token vom Metadatenserver ab und hängen Sie Authorization: Bearer ID_TOKEN an die ausgehende HTTPS-Anfrage an.

So konfigurieren und stellen Sie caller-oidc bereit:

  1. Erstellen Sie ein dediziertes Dienstkonto für caller-oidc:
gcloud iam service-accounts create caller-oidc-identity \
    --display-name="Cloud Run OIDC caller service account"
  1. Autorisieren Sie caller-oidc-identity, um destination aufzurufen:
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. Erstellen Sie das Verzeichnis caller-oidc neben destination:
mkdir -p ~/express-link-codelab/caller-oidc
cd ~/express-link-codelab/caller-oidc
  1. Führen Sie den folgenden Befehl aus, um eine requirements.txt-Datei zu erstellen. Beachten Sie, dass Sie google-auth speziell für den Tokenabruf in Ihrem Anwendungscontainer hinzufügen müssen:
cat << 'EOF' > requirements.txt
Flask==3.0.0
google-auth==2.23.0
requests==2.31.0
gunicorn==21.2.0
EOF
  1. Führen Sie den folgenden Befehl aus, um eine main.py-Datei mit manueller OIDC-Token-Injektion zu erstellen:
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. Stellen Sie caller-oidc in Cloud Run bereit:
gcloud run deploy caller-oidc \
    --source . \
    --region="$REGION" \
    --service-account="caller-oidc-identity@${PROJECT_ID}.iam.gserviceaccount.com" \
    --no-allow-unauthenticated
  1. Gewähren Sie Ihrem Nutzerkonto die Berechtigung zum Aufrufen von caller-oidc:
gcloud run services add-iam-policy-binding caller-oidc \
    --member="user:$ACTIVE_ACCOUNT" \
    --role="roles/run.invoker" \
    --region="$REGION"
  1. Speichern Sie die deterministische URL von caller-oidc und rufen Sie sie auf. Übergeben Sie dabei die HTTPS-URL $DESTINATION_URL/ping als 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"

Sie sollten eine Erfolgsmeldung von destination erhalten:

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

5. Caller-Dienst für Express Link bereitstellen

Jetzt erstellen Sie einen zweiten Aufrufdienst mit dem Namen caller-express-link in einem gleichgeordneten Verzeichnis. Mit Express Link benötigt caller-express-link keinen Code für die Token-Injektion, sondern ruft requests.get(target_url, timeout=10) direkt auf.

  1. Erstellen Sie ein dediziertes Dienstkonto für caller-express-link:
gcloud iam service-accounts create caller-express-link-identity \
    --display-name="Cloud Run Express Link caller service account"
  1. Weisen Sie caller-express-link-identity die Rolle roles/trafficdirector.client zu, damit die verwaltete Ambient Networking-Sidecar-Konfiguration die Routing- und Sicherheitskonfiguration für Express Link herunterladen kann. Gewähren Sie außerdem roles/cloudtrace.agent, damit der Sidecar Trace-Spans exportieren kann:
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. Erstellen Sie das Verzeichnis caller-express-link neben caller-oidc:
mkdir -p ~/express-link-codelab/caller-express-link
cd ~/express-link-codelab/caller-express-link
  1. Führen Sie den folgenden Befehl aus, um eine requirements.txt-Datei ohne google-auth zu erstellen:
cat << 'EOF' > requirements.txt
Flask==3.0.0
requests==2.31.0
gunicorn==21.2.0
EOF
  1. Führen Sie den folgenden Befehl aus, um eine main.py-Datei mit einem einfachen requests.get(target_url, timeout=10)-Aufruf und ohne Token-Injektionslogik zu erstellen:
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. Führen Sie diff für ../caller-oidc/main.py aus, um den Authentifizierungs-Boilerplate-Code zu sehen, den Sie entfernt haben:
diff -u ../caller-oidc/main.py main.py || true
  1. Stellen Sie caller-express-link mit gcloud beta run deploy bereit, wobei --ambient-networking und --ambient-scope=global aktiviert sind:
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. Prüfen Sie, ob Ambient Networking auf caller-express-link aktiv ist:
gcloud run services describe caller-express-link --region="$REGION"

Prüfen Sie am Ende der Versionszusammenfassung, ob Ambient Networking und Ambient Scope angezeigt werden:

  Ambient Networking: Enabled
  Ambient Scope:     global
  1. Gewähren Sie Ihrem Nutzerkonto die Berechtigung zum Aufrufen von caller-express-link und autorisieren Sie caller-express-link-identity zum Aufrufen von 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. Speichern Sie die URL und den Ressourcen-URI von caller-express-link zusammen mit der deterministischen HTTP-URL (http://) von 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. Testen Sie den Aufruf von destination über caller-express-link, bevor Sie einen Express Link erstellen:
TOKEN=$(gcloud auth print-identity-token)
curl -H "Authorization: Bearer $TOKEN" "$CALLER_EL_URL/?target_url=$DESTINATION_HTTP_URL/ping"

Wie erwartet schlägt der Aufruf mit 403 Forbidden fehl, da noch kein Express Link vorhanden ist, um die Anfrage abzufangen und Anmeldedaten einzufügen:

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. Dienste mit einem Express Link verbinden

Jetzt deklarieren Sie eine ExpressLink-Ressource, die caller-express-link (den Quelldienst) mit destination verbindet, ohne eine einzige Codezeile zu ändern oder einen der Cloud Run-Dienste neu bereitzustellen.

  1. Erstellen Sie die Express Link-Ressource am Standort 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. Listen Sie Ihre Express Links auf, um zu prüfen, ob die Ressource vorhanden ist:
gcloud beta network-services express-links list --location=global

Befehlsausgabe:

NAME
caller-to-destination
  1. Prüfen Sie die Konfigurationsdetails für Express Link:
gcloud beta network-services express-links describe caller-to-destination --location=global

Befehlsausgabe:

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. Führen Sie dieselbe curl-Anfrage noch einmal für caller-express-link aus:
TOKEN=$(gcloud auth print-identity-token)
curl -H "Authorization: Bearer $TOKEN" "$CALLER_EL_URL/?target_url=$DESTINATION_HTTP_URL/ping"

Dieses Mal fängt der Ambient-Sidecar die HTTP-Anfrage an destination ab, fügt das Identitätstoken für caller-express-link-identity ein, aktualisiert die Verbindung auf TLS und gibt die Antwort des Ziels zurück:

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

In der folgenden Tabelle sind die Änderungen zwischen caller-oidc und caller-express-link zusammengefasst:

Dimension

Ohne Express Link (caller-oidc)

Mit Express Link (caller-express-link)

Authentifizierungsbibliotheken in requirements.txt

Die Spalte „google-auth“ ist erforderlich

Keine (nur Flask, requests, gunicorn)

Ausgehender Anruf in main.py

Zielgruppen-URL parsen, id_token.fetch_id_token() aufrufen, Authorization: Bearer-Header anhängen

Einfach requests.get(target_url, timeout=10)

Ziel-URL-Schema in der App

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

http://destination-PROJECT_NUMBER.REGION.run.app (durch Ambient-Sidecar auf TLS aktualisiert)

Cloud Run-Konfiguration des Aufrufers

Standardmäßige Bereitstellung

--ambient-networking --ambient-scope=global + roles/trafficdirector.client für das Dienstkonto des Aufrufers

Cloud Run-Zielkonfiguration

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

Unverändert (--no-allow-unauthenticated + roles/run.invoker)

7. Bereinigen

Damit Ihrem Google Cloud-Konto keine laufenden Gebühren in Rechnung gestellt werden, löschen Sie die Ressourcen, die Sie in diesem Codelab erstellt haben.

  1. Löschen Sie die Express Link-Ressource:
gcloud beta network-services express-links delete caller-to-destination --location=global --quiet
  1. Löschen Sie die drei Cloud Run-Dienste:
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. Entfernen Sie die IAM-Richtlinienbindungen auf Projektebene und löschen Sie die drei Dienstkonten:
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. (Optional) Wenn Sie ein dediziertes Google Cloud-Projekt nur für dieses Codelab erstellt haben, können Sie das gesamte Projekt löschen:
# Run only if you want to delete the entire project and all its resources
gcloud projects delete "$PROJECT_ID"

8. Glückwunsch

Sie haben einen privaten Cloud Run-Backend-Dienst bereitgestellt und ihn mit manueller OIDC-Token-Injektion in Python aufgerufen. Anschließend haben Sie den gesamten Authentifizierungscode auf Anwendungsebene durch einen deklarativen Cloud Run Express Link ersetzt.

Das haben Sie gelernt

  • Warum die manuelle OIDC-Token-Injektion die Geschäftslogik der Anwendung mit den Authentifizierungsbibliotheken und Sicherheitsmodi der Plattform verknüpft
  • Authentifizierten Cloud Run-Zieldienst bereitstellen, der unverändert mit oder ohne Express Link funktioniert
  • So aktivieren Sie Ambient Networking (--ambient-networking mit --ambient-scope=global) und gewähren Traffic Director-Clientberechtigungen (roles/trafficdirector.client) für einen aufrufenden Cloud Run-Dienst
  • Network Services-ExpressLink-Ressource erstellen und prüfen, die automatisch Identitätstokens einfügt und Klartext-http://-Aufrufe von Ihrem Container auf verschlüsselte TLS-Verbindungen aktualisiert

Nächste Schritte