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:
- 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.
- 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
- 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.
- Melden Sie sich in der Google Cloud Console an.
- 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.
- 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.
- Klicken Sie in der Google Cloud Console in der oberen Navigationsleiste auf Cloud Shell aktivieren. Klicken Sie auf Autorisieren, wenn Sie dazu aufgefordert werden.
- Exportieren Sie Ihre Projekt-ID und die Bereitstellungsregion und konfigurieren Sie
gcloudfür die Verwendung von$PROJECT_ID. Ersetzen SieYOUR_PROJECT_IDdurch Ihre Projekt-ID und optionalus-west1durch eine andere Cloud Run-Region:
export PROJECT_ID="YOUR_PROJECT_ID"
export REGION="us-west1"
gcloud config set project "$PROJECT_ID"
- 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
- Aktualisieren Sie Ihre
gcloud-Komponenten, damit Sie die neuestenbeta-Befehle für Ambient Networking und Express Link haben:
gcloud components update --quiet
- 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.
- Erstellen Sie ein dediziertes IAM-Dienstkonto für den Zieldienst:
gcloud iam service-accounts create destination-identity \
--display-name="Cloud Run destination service account"
- Erstellen Sie einen Ordner
destinationund wechseln Sie dorthin:
mkdir -p ~/express-link-codelab/destination
cd ~/express-link-codelab/destination
- 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
- 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 UmgebungsvariableK_SERVICEzurü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
- Stellen Sie
destinationaus der Quelle mit--no-allow-unauthenticatedbereit, 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
- 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"
- Weisen Sie Ihrem Nutzerkonto die Rolle „Cloud Run-Aufrufer“ (
roles/run.invoker) fürdestinationzu, 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"
- Senden Sie eine authentifizierte Anfrage an
/pingmit Ihrem eigenen Identitätstoken, um zu bestätigen, dassdestinationausgefü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-oidcdie Rolleroles/run.invokerfürdestinationzu. - Token-Injektion auf Anwendungsebene: Fügen Sie die Bibliothek
google-authzucaller-oidchinzu 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 SieAuthorization: Bearer ID_TOKENan die ausgehende HTTPS-Anfrage an.
So konfigurieren und stellen Sie caller-oidc bereit:
- 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"
- Autorisieren Sie
caller-oidc-identity, umdestinationaufzurufen:
gcloud run services add-iam-policy-binding destination \
--member="serviceAccount:caller-oidc-identity@${PROJECT_ID}.iam.gserviceaccount.com" \
--role="roles/run.invoker" \
--region="$REGION"
- Erstellen Sie das Verzeichnis
caller-oidcnebendestination:
mkdir -p ~/express-link-codelab/caller-oidc
cd ~/express-link-codelab/caller-oidc
- Führen Sie den folgenden Befehl aus, um eine
requirements.txt-Datei zu erstellen. Beachten Sie, dass Siegoogle-authspeziell 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
- 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
- Stellen Sie
caller-oidcin Cloud Run bereit:
gcloud run deploy caller-oidc \
--source . \
--region="$REGION" \
--service-account="caller-oidc-identity@${PROJECT_ID}.iam.gserviceaccount.com" \
--no-allow-unauthenticated
- 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"
- Speichern Sie die deterministische URL von
caller-oidcund rufen Sie sie auf. Übergeben Sie dabei die HTTPS-URL$DESTINATION_URL/pingalstarget_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.
- 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"
- Weisen Sie
caller-express-link-identitydie Rolleroles/trafficdirector.clientzu, damit die verwaltete Ambient Networking-Sidecar-Konfiguration die Routing- und Sicherheitskonfiguration für Express Link herunterladen kann. Gewähren Sie außerdemroles/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"
- Erstellen Sie das Verzeichnis
caller-express-linknebencaller-oidc:
mkdir -p ~/express-link-codelab/caller-express-link
cd ~/express-link-codelab/caller-express-link
- Führen Sie den folgenden Befehl aus, um eine
requirements.txt-Datei ohnegoogle-authzu erstellen:
cat << 'EOF' > requirements.txt
Flask==3.0.0
requests==2.31.0
gunicorn==21.2.0
EOF
- Führen Sie den folgenden Befehl aus, um eine
main.py-Datei mit einem einfachenrequests.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
- Führen Sie
difffür../caller-oidc/main.pyaus, um den Authentifizierungs-Boilerplate-Code zu sehen, den Sie entfernt haben:
diff -u ../caller-oidc/main.py main.py || true
- Stellen Sie
caller-express-linkmitgcloud beta run deploybereit, wobei--ambient-networkingund--ambient-scope=globalaktiviert 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
- Prüfen Sie, ob Ambient Networking auf
caller-express-linkaktiv 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
- Gewähren Sie Ihrem Nutzerkonto die Berechtigung zum Aufrufen von
caller-express-linkund autorisieren Siecaller-express-link-identityzum Aufrufen vondestination:
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"
- Speichern Sie die URL und den Ressourcen-URI von
caller-express-linkzusammen mit der deterministischen HTTP-URL (http://) vondestination:
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"
- Testen Sie den Aufruf von
destinationübercaller-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.
- 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"
- 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
- 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'
- Führen Sie dieselbe
curl-Anfrage noch einmal fürcaller-express-linkaus:
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'
Manuelle Token-Injektion mit Express Link vergleichen
In der folgenden Tabelle sind die Änderungen zwischen caller-oidc und caller-express-link zusammengefasst:
Dimension | Ohne Express Link ( | Mit Express Link ( |
Authentifizierungsbibliotheken in | Die Spalte „ | Keine (nur |
Ausgehender Anruf in | Zielgruppen-URL parsen, | Einfach |
Ziel-URL-Schema in der App |
|
|
Cloud Run-Konfiguration des Aufrufers | Standardmäßige Bereitstellung |
|
Cloud Run-Zielkonfiguration |
| Unverändert ( |
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.
- Löschen Sie die Express Link-Ressource:
gcloud beta network-services express-links delete caller-to-destination --location=global --quiet
- 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
- 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
- (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-networkingmit--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
- Lesen Sie den Abschnitt Dienst-zu-Dienst-Authentifizierung in der Cloud Run-Dokumentation.
- In den Cloud Run-Versionshinweisen finden Sie die neuesten Informationen zu Ambient Networking und Express Link.