Simplifier l'authentification de service à service Cloud Run avec un lien express

1. Présentation

Lorsque vous créez des microservices ou des applications multi-agents sur Cloud Run, les services de backend internes ne doivent pas être accessibles sur l'Internet public. À la place, vous configurez chaque service de backend pour qu'il exige une authentification (--no-allow-unauthenticated) et vous n'accordez le rôle IAM de demandeur Cloud Run (roles/run.invoker) qu'aux appelants autorisés.

En règle générale, pour appeler un service Cloud Run authentifié, votre application appelante doit effectuer une injection manuelle de jeton dans le code. Avant d'envoyer une requête HTTP, votre code interroge le serveur Compute Metadata pour obtenir un jeton d'ID OpenID Connect (OIDC) signé par Google. Ce jeton est limité à l'URL d'audience du service de destination, et votre code l'associe à l'en-tête Authorization: Bearer. L'écriture et la maintenance de la plomberie d'authentification dans le code de l'application introduisent des frictions inutiles :

  • Elle associe votre logique métier aux bibliothèques d'authentification Google Cloud, ce qui réduit la lisibilité et la portabilité entre les environnements.
  • La logique d'acquisition des jetons varie selon les types de destinations et les modes de sécurité. Par exemple, Cloud Run attend des jetons d'ID OIDC, les API Google attendent des jetons d'accès OAuth 2.0 et mTLS nécessite des jetons liés.

Le lien express Cloud Run (preview) supprime l'injection manuelle de jetons du code de votre application. Vous activez mise en réseau ambiant sur le service Cloud Run appelant (source) et créez une ressource ExpressLink déclarative qui lie le service source au service de destination. Un proxy side-car géré par Google intercepte les requêtes HTTP sortantes en texte brut vers la destination, injecte automatiquement le jeton d'identité du service appelant et chiffre la connexion à la destination.

Dans cet atelier de programmation, vous allez comparer les deux approches avec le même service de backend privé :

  1. Déployez un service de destination privé et un service d'appelant (caller-oidc) qui récupère un jeton d'ID OIDC à partir du serveur Compute Metadata en Python. Cette étape confirme la connectivité de bout en bout au backend et affiche le code d'authentification requis sans lien express.
  2. Déployez un deuxième service appelant (caller-express-link) sans le code de récupération des jetons de métadonnées, et connectez-le au service de destination à l'aide de la mise en réseau ambiant et d'un lien express.
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)     |
+----------------------------------------------+          +-----------------+

Prérequis

  • Connaissances de base de Python et des services Web HTTP
  • Connaissances de base sur les comptes de service Google Cloud IAM et les déploiements Cloud Run

Points abordés

  • Déployer un service de destination Cloud Run privé qui applique l'authentification IAM
  • Comment authentifier manuellement les requêtes de service à service en Python à l'aide de jetons d'ID OIDC google-auth du serveur de métadonnées pour vérifier la connectivité de base
  • Supprimer le code de récupération manuelle des jetons et déployer un service d'appelant Cloud Run avec la mise en réseau ambiante activée
  • Créer un lien express Cloud Run pour que votre service appelant puisse appeler un service de destination authentifié sans code d'authentification

Ce que vous allez faire

  • destination : un service Python Flask privé sur Cloud Run qui expose un point de terminaison /ping
  • caller-oidc : service Python Flask qui appelle destination en récupérant et en injectant manuellement des jetons d'ID OIDC dans le code de l'application.
  • caller-express-link : un service Python Flask côte à côte sans code d'injection de jeton qui appelle le même service de destination via un lien express.

Prérequis

  • Un navigateur Web (par exemple, Chrome)
  • Un projet Google Cloud avec la facturation activée et les autorisations nécessaires pour créer des comptes de service IAM, des services Cloud Run et des ressources Network Services

2. Configurer votre environnement

Configurer un projet Google Cloud

  1. Si vous n'avez pas encore de compte Google, vous devez en créer un.
    • Utilisez un compte personnel au lieu d'un compte professionnel ou scolaire. Les comptes professionnels et scolaires peuvent être soumis à des restrictions qui vous empêchent d'activer les API nécessaires pour cet atelier.
  2. Connectez-vous à la console Google Cloud.
  3. Activez la facturation dans la console Cloud.
    • La réalisation de cet atelier devrait coûter moins de 1 $ en ressources cloud.
    • Vous pouvez suivre les étapes à la fin de cet atelier pour supprimer les ressources afin d'éviter des frais supplémentaires.
    • Les nouveaux utilisateurs peuvent bénéficier d'un essai sans frais de 300 $.
  4. Créez un projet ou choisissez de réutiliser un projet existant.
    • Si une erreur concernant le quota de projets s'affiche, réutilisez un projet existant ou supprimez-en un pour en créer un autre.

Démarrer Cloud Shell

Dans cet atelier de programmation, vous allez utiliser Cloud Shell, un environnement de ligne de commande basé sur un navigateur dans lequel Google Cloud CLI (gcloud), Python et curl sont préinstallés.

  1. Dans la console Google Cloud, cliquez sur Activer Cloud Shell dans la barre de navigation supérieure. Cliquez sur Autoriser si vous y êtes invité.
  2. Exportez l'ID de votre projet et la région de déploiement, puis configurez gcloud pour utiliser $PROJECT_ID. Remplacez YOUR_PROJECT_ID par l'ID de votre projet et, si vous le souhaitez, remplacez us-west1 par une autre région Cloud Run :
export PROJECT_ID="YOUR_PROJECT_ID"
export REGION="us-west1"
gcloud config set project "$PROJECT_ID"
  1. Exportez votre numéro de projet et votre compte Google Cloud actif, puis vérifiez que les quatre variables sont renseignées :
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"

Mettre à jour gcloud et activer les API

  1. Mettez à jour vos composants gcloud pour disposer des dernières commandes beta pour la mise en réseau ambiant et le lien express :
gcloud components update --quiet
  1. Activez les API Google Cloud requises pour les déploiements sources Cloud Run, les comptes de service IAM, la mise en réseau ambiant et 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

Créer un répertoire d'espace de travail

Créez un répertoire de travail pour stocker les trois dossiers de service que vous allez créer dans cet atelier de programmation :

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

3. Déployer le service de destination privé

Vous allez d'abord déployer un service Cloud Run privé nommé destination. Vous réutiliserez ce service de destination unique pour les deux parties de l'atelier de programmation :

  • Un service de destination n'effectue jamais d'injection de jeton sortant.
  • Il n'est pas nécessaire d'activer la mise en réseau ambiant sur un service de destination pour qu'il reçoive du trafic via un lien express.
  1. Créez un compte de service IAM dédié pour le service de destination :
gcloud iam service-accounts create destination-identity \
    --display-name="Cloud Run destination service account"
  1. Créez un dossier destination et accédez-y :
mkdir -p ~/express-link-codelab/destination
cd ~/express-link-codelab/destination
  1. Exécutez la commande suivante pour créer un fichier requirements.txt avec Flask et Gunicorn :
cat << 'EOF' > requirements.txt
Flask==3.0.0
gunicorn==21.2.0
EOF
  1. Exécutez la commande suivante pour créer un fichier main.py qui expose un point de terminaison /ping renvoyant le nom du service Cloud Run à partir de la variable d'environnement 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. Déployez destination à partir de la source avec --no-allow-unauthenticated afin que Cloud Run rejette les requêtes non authentifiées :
gcloud run deploy destination \
    --source . \
    --region="$REGION" \
    --service-account="destination-identity@${PROJECT_ID}.iam.gserviceaccount.com" \
    --no-allow-unauthenticated
  1. Stockez l'URL déterministe et l'URI de ressource complet du service de destination dans des variables d'environnement :
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. Attribuez à votre compte utilisateur le rôle Demandeur Cloud Run (roles/run.invoker) sur destination pour pouvoir le tester directement depuis Cloud Shell :
gcloud run services add-iam-policy-binding destination \
    --member="user:$ACTIVE_ACCOUNT" \
    --role="roles/run.invoker" \
    --region="$REGION"
  1. Envoyez une requête authentifiée à /ping à l'aide de votre propre jeton d'identité pour confirmer que destination est en cours d'exécution :
TOKEN=$(gcloud auth print-identity-token)
curl -H "Authorization: Bearer $TOKEN" "$DESTINATION_URL/ping"

La réponse suivante devrait s'afficher :

Hello from destination

4. Appeler la destination sans lien express

Avant de présenter Express Link, créez caller-oidc pour voir ce que l'authentification de service à service nécessite aujourd'hui et vérifiez qu'un service appelant peut atteindre destination. Pour appeler destination de manière sécurisée sans lien express, vous devez configurer deux couches :

  • Autorisation IAM : accordez au compte de service caller-oidc le rôle roles/run.invoker sur destination.
  • Injection de jeton au niveau de l'application : ajoutez la bibliothèque google-auth à caller-oidc et analysez l'URL cible pour extraire l'audience OIDC racine. Ensuite, récupérez un jeton d'ID signé à partir du serveur de métadonnées et associez Authorization: Bearer ID_TOKEN à la requête HTTPS sortante.

Pour configurer et déployer caller-oidc, procédez comme suit :

  1. Créez un compte de service dédié pour caller-oidc :
gcloud iam service-accounts create caller-oidc-identity \
    --display-name="Cloud Run OIDC caller service account"
  1. Autorisez caller-oidc-identity à appeler 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. Créez le répertoire caller-oidc à côté de destination :
mkdir -p ~/express-link-codelab/caller-oidc
cd ~/express-link-codelab/caller-oidc
  1. Exécutez la commande suivante pour créer un fichier requirements.txt. Notez que vous devez ajouter google-auth spécifiquement pour gérer la récupération des jetons dans le conteneur de votre application :
cat << 'EOF' > requirements.txt
Flask==3.0.0
google-auth==2.23.0
requests==2.31.0
gunicorn==21.2.0
EOF
  1. Exécutez la commande suivante pour créer un fichier main.py avec injection manuelle de jeton 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. Déployez caller-oidc sur Cloud Run :
gcloud run deploy caller-oidc \
    --source . \
    --region="$REGION" \
    --service-account="caller-oidc-identity@${PROJECT_ID}.iam.gserviceaccount.com" \
    --no-allow-unauthenticated
  1. Accordez à votre compte utilisateur l'autorisation d'appeler caller-oidc :
gcloud run services add-iam-policy-binding caller-oidc \
    --member="user:$ACTIVE_ACCOUNT" \
    --role="roles/run.invoker" \
    --region="$REGION"
  1. Stockez l'URL déterministe de caller-oidc et appelez-la en transmettant l'URL HTTPS $DESTINATION_URL/ping en tant que 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"

Vous devriez recevoir une réponse de réussite de destination :

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

5. Déployer le service d'appel pour le lien express

Vous allez maintenant créer un deuxième service d'appelant nommé caller-express-link dans un répertoire frère. Avec le lien express, caller-express-link n'a besoin d'aucun code d'injection de jeton : il appelle directement requests.get(target_url, timeout=10).

  1. Créez un compte de service dédié pour caller-express-link :
gcloud iam service-accounts create caller-express-link-identity \
    --display-name="Cloud Run Express Link caller service account"
  1. Attribuez le rôle roles/trafficdirector.client à caller-express-link-identity pour que le side-car de mise en réseau ambiant géré puisse télécharger la configuration de routage et de sécurité du lien express. Accordez également roles/cloudtrace.agent pour que le side-car puisse exporter des segments de trace :
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. Créez le répertoire caller-express-link à côté de caller-oidc :
mkdir -p ~/express-link-codelab/caller-express-link
cd ~/express-link-codelab/caller-express-link
  1. Exécutez la commande suivante pour créer un fichier requirements.txt sans google-auth :
cat << 'EOF' > requirements.txt
Flask==3.0.0
requests==2.31.0
gunicorn==21.2.0
EOF
  1. Exécutez la commande suivante pour créer un fichier main.py avec un appel requests.get(target_url, timeout=10) simple et sans logique d'injection de jeton :
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. Exécutez diff sur ../caller-oidc/main.py pour afficher le code récurrent d'authentification que vous avez éliminé :
diff -u ../caller-oidc/main.py main.py || true
  1. Déployez caller-express-link à l'aide de gcloud beta run deploy avec --ambient-networking et --ambient-scope=global activés :
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. Vérifiez que la mise en réseau ambiante est active sur caller-express-link :
gcloud run services describe caller-express-link --region="$REGION"

À la fin du résumé de la révision, vérifiez que Ambient Networking et Ambient Scope s'affichent :

  Ambient Networking: Enabled
  Ambient Scope:     global
  1. Accordez à votre compte utilisateur l'autorisation d'appeler caller-express-link et autorisez caller-express-link-identity à appeler 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. Stockez l'URL et l'URI de ressource de caller-express-link, ainsi que l'URL déterministe HTTP (http://) de 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. Testez l'appel de destination via caller-express-link avant de créer un lien express :
TOKEN=$(gcloud auth print-identity-token)
curl -H "Authorization: Bearer $TOKEN" "$CALLER_EL_URL/?target_url=$DESTINATION_HTTP_URL/ping"

Comme prévu, l'appel échoue avec 403 Forbidden, car aucun lien express n'existe encore pour intercepter la requête et injecter les identifiants :

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. Connecter les services avec un lien express

Vous allez maintenant déclarer une ressource ExpressLink connectant caller-express-link (le service source) à destination, sans modifier une seule ligne de code ni redéployer l'un des services Cloud Run.

  1. Créez la ressource de lien express dans l'emplacement 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. Répertoriez vos liens express pour confirmer que la ressource existe :
gcloud beta network-services express-links list --location=global

Résultat de la commande :

NAME
caller-to-destination
  1. Inspectez les détails de la configuration du lien express :
gcloud beta network-services express-links describe caller-to-destination --location=global

Résultat de la commande :

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. Exécutez à nouveau la même requête curl sur caller-express-link :
TOKEN=$(gcloud auth print-identity-token)
curl -H "Authorization: Bearer $TOKEN" "$CALLER_EL_URL/?target_url=$DESTINATION_HTTP_URL/ping"

Cette fois, le side-car Ambient intercepte la requête HTTP vers destination, injecte le jeton d'identité pour caller-express-link-identity, met à niveau la connexion vers TLS et renvoie la réponse de la destination :

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

Le tableau suivant récapitule les modifications apportées entre caller-oidc et caller-express-link :

Dimension

Sans lien express (caller-oidc)

Avec un lien express (caller-express-link)

Bibliothèques d'authentification dans requirements.txt

La colonne "google-auth" est obligatoire

Aucun (Flask, requests, gunicorn uniquement)

Appel sortant dans main.py

Analyser l'URL de l'audience, appeler id_token.fetch_id_token(), associer l'en-tête Authorization: Bearer

requests.get(target_url, timeout=10) brut

Schéma d'URL cible dans l'application

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

http://destination-PROJECT_NUMBER.REGION.run.app (mis à niveau vers TLS par le side-car Ambient)

Configuration de l'appelant Cloud Run

Déploiement standard

--ambient-networking --ambient-scope=global + roles/trafficdirector.client sur le compte de service de l'appelant

Configuration de la destination Cloud Run

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

Inchangés (--no-allow-unauthenticated + roles/run.invoker)

7. Effectuer un nettoyage

Pour éviter que des frais ne soient facturés sur votre compte Google Cloud, supprimez les ressources que vous avez créées lors de cet atelier de programmation.

  1. Supprimez la ressource de lien express :
gcloud beta network-services express-links delete caller-to-destination --location=global --quiet
  1. Supprimez les trois services 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. Supprimez les liaisons de stratégie IAM au niveau du projet et supprimez les trois comptes de service :
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. (Facultatif) Si vous avez créé un projet Google Cloud dédié uniquement à cet atelier de programmation, vous pouvez supprimer l'intégralité du projet :
# Run only if you want to delete the entire project and all its resources
gcloud projects delete "$PROJECT_ID"

8. Félicitations

Vous avez déployé un service de backend Cloud Run privé et l'avez appelé à l'aide de l'injection manuelle de jetons OIDC en Python. Vous avez ensuite remplacé tout le code d'authentification au niveau de l'application par un lien express Cloud Run déclaratif.

Ce que vous avez appris

  • Pourquoi l'injection manuelle de jetons OIDC associe la logique métier de l'application aux bibliothèques d'authentification et aux modes de sécurité de la plate-forme
  • Déployer un service de destination Cloud Run authentifié qui fonctionne sans modification avec ou sans lien express
  • Activer la mise en réseau ambiant (--ambient-networking avec --ambient-scope=global) et accorder des autorisations de client Traffic Director (roles/trafficdirector.client) sur un service Cloud Run appelant
  • Créer et inspecter une ressource Network Services ExpressLink qui injecte automatiquement des jetons d'identité et met à niveau les appels http:// en texte brut de votre conteneur vers des connexions TLS chiffrées

Étapes suivantes