Simplifica la autenticación de servicio a servicio de Cloud Run con enlace exprés

1. Descripción general

Cuando compilas microservicios o aplicaciones de varios agentes en Cloud Run, los servicios de backend internos no deben estar abiertos a la Internet pública. En su lugar, configura cada servicio de backend para que requiera autenticación (--no-allow-unauthenticated) y otorga el rol de IAM de invocador de Cloud Run (roles/run.invoker) solo a los emisores autorizados.

Tradicionalmente, para llamar a un servicio de Cloud Run autenticado, la aplicación que realiza la llamada debe realizar una inserción manual de tokens en el código. Antes de enviar una solicitud HTTP, tu código consulta al servidor de metadatos de Compute para obtener un token de ID de OpenID Connect (OIDC) firmado por Google. Ese token tiene como alcance la URL del público del servicio de destino, y tu código lo adjunta al encabezado Authorization: Bearer. Escribir y mantener la infraestructura de autenticación dentro del código de la aplicación genera una fricción innecesaria:

  • Acopla tu lógica empresarial a las bibliotecas de autenticación de Google Cloud, lo que reduce la legibilidad y la portabilidad entre entornos.
  • La lógica de adquisición de tokens varía según los tipos de destino y los modos de seguridad. Por ejemplo, Cloud Run espera tokens de ID de OIDC, las APIs de Google esperan tokens de acceso de OAuth 2.0 y mTLS requiere tokens vinculados.

Cloud Run Express Link (versión preliminar) quita la inserción manual de tokens del código de tu aplicación. Habilitas Ambient Networking en el servicio de Cloud Run que realiza la llamada (origen) y creas un recurso ExpressLink declarativo que vincula el servicio de origen con el de destino. Un proxy sidecar administrado por Google intercepta las solicitudes HTTP de texto sin formato salientes al destino, inserta automáticamente el token de identidad del servicio emisor y encripta la conexión al destino.

En este codelab, compararás ambos enfoques con el mismo servicio de backend privado:

  1. Implementa un servicio de destino privado y un servicio de emisor (caller-oidc) que recupere un token de ID de OIDC del servidor de metadatos de Compute en Python. Este paso confirma la conectividad de extremo a extremo con el backend y muestra el código de autenticación requerido sin enlace exprés.
  2. Implementar un segundo servicio de emisor (caller-express-link) sin el código de recuperación de tokens de metadatos y conectarlo al servicio de destino con Ambient Networking y un enlace exprés
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)     |
+----------------------------------------------+          +-----------------+

Requisitos previos

  • Conocimientos básicos sobre Python y los servicios web HTTP
  • Conocimiento básico de las cuentas de servicio de Cloud IAM de Google Cloud y las implementaciones de Cloud Run

Qué aprenderás

  • Cómo implementar un servicio de destino privado de Cloud Run que aplique de manera forzosa la autenticación de IAM
  • Cómo autenticar solicitudes de servicio a servicio de forma manual en Python con tokens de ID de OIDC de google-auth del servidor de metadatos para verificar la conectividad de referencia
  • Cómo quitar el código de recuperación manual de tokens y, luego, implementar un servicio de emisor de Cloud Run con Ambient Networking habilitado
  • Cómo crear un enlace exprés de Cloud Run para que tu servicio emisor pueda invocar un servicio de destino autenticado sin código de autenticación

Qué compilarás

  • destination: Es un servicio privado de Python Flask en Cloud Run que expone un extremo /ping.
  • caller-oidc: Es un servicio de Flask de Python que llama a destination recuperando e insertando de forma manual tokens de ID de OIDC en el código de la aplicación.
  • caller-express-link: Es un servicio de Flask de Python en paralelo con cero código de inserción de tokens que llama al mismo servicio de destino a través de un enlace exprés.

Requisitos

  • Un navegador web, como Chrome
  • Un proyecto de Google Cloud con la facturación habilitada y permisos para crear cuentas de servicio de IAM, servicios de Cloud Run y recursos de Network Services

2. Configura tu entorno

Configura un proyecto de Google Cloud

  1. Si aún no tienes una Cuenta de Google, debes crear una.
    • Usa una cuenta personal en lugar de una laboral o educativa. Es posible que las cuentas laborales y educativas tengan restricciones que te impidan habilitar las APIs necesarias para este lab.
  2. Accede a la consola de Google Cloud.
  3. Habilita la facturación en la consola de Cloud.
    • Completar este lab debería costar menos de USD 1 en recursos de Cloud.
    • Puedes seguir los pasos que se indican al final de este lab para borrar recursos y evitar cargos adicionales.
    • Los usuarios nuevos son aptos para participar en la Prueba gratuita de USD 300.
  4. Crea un proyecto nuevo o elige reutilizar uno existente.
    • Si ves un error sobre la cuota de proyectos, vuelve a usar un proyecto existente o borra uno para crear uno nuevo.

Inicie Cloud Shell

En este codelab, usarás Cloud Shell, un entorno de línea de comandos basado en el navegador que tiene preinstaladas Google Cloud CLI (gcloud), Python y curl.

  1. En la consola de Google Cloud, haz clic en Activar Cloud Shell en la barra de navegación superior. Si se te solicita, haz clic en Autorizar.
  2. Exporta el ID del proyecto y la región de implementación, y configura gcloud para usar $PROJECT_ID. Reemplaza YOUR_PROJECT_ID por el ID de tu proyecto y, de manera opcional, reemplaza us-west1 por otra región de Cloud Run:
export PROJECT_ID="YOUR_PROJECT_ID"
export REGION="us-west1"
gcloud config set project "$PROJECT_ID"
  1. Exporta tu número de proyecto y la cuenta de Google Cloud activa, y confirma que se propaguen las cuatro variables:
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"

Actualiza gcloud y habilita las APIs

  1. Actualiza tus componentes de gcloud para tener los comandos de beta más recientes para Ambient Networking y Express Link:
gcloud components update --quiet
  1. Habilita las APIs de Google Cloud necesarias para las implementaciones de fuentes de Cloud Run, las cuentas de servicio de IAM, Ambient Networking y el enlace exprés de Network Services:
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

Crea un directorio del espacio de trabajo.

Crea un directorio de trabajo para almacenar las tres carpetas de servicio que crearás en este codelab:

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

3. Implementa el servicio de destino privado

Primero, implementarás un servicio privado de Cloud Run llamado destination. Volverás a usar este servicio de destino único para ambas partes del codelab:

  • Un servicio de destino nunca realiza la inserción de tokens salientes.
  • Un servicio de destino no necesita tener habilitado Ambient Networking para recibir tráfico a través de un enlace exprés.
  1. Crea una cuenta de servicio de IAM dedicada para el servicio de destino:
gcloud iam service-accounts create destination-identity \
    --display-name="Cloud Run destination service account"
  1. Crea una carpeta destination y muévete a ella:
mkdir -p ~/express-link-codelab/destination
cd ~/express-link-codelab/destination
  1. Ejecuta el siguiente comando para crear un archivo requirements.txt con Flask y Gunicorn:
cat << 'EOF' > requirements.txt
Flask==3.0.0
gunicorn==21.2.0
EOF
  1. Ejecuta el siguiente comando para crear un archivo main.py que exponga un extremo /ping que devuelva el nombre del servicio de Cloud Run desde la variable de entorno 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. Implementa destination desde la fuente con --no-allow-unauthenticated para que Cloud Run rechace las solicitudes no autenticadas:
gcloud run deploy destination \
    --source . \
    --region="$REGION" \
    --service-account="destination-identity@${PROJECT_ID}.iam.gserviceaccount.com" \
    --no-allow-unauthenticated
  1. Almacena la URL determinística del servicio de destino y el URI completo del recurso en variables de entorno:
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. Otorga a tu cuenta de usuario el rol de Invocador de Cloud Run (roles/run.invoker) en destination para que puedas probarlo directamente desde Cloud Shell:
gcloud run services add-iam-policy-binding destination \
    --member="user:$ACTIVE_ACCOUNT" \
    --role="roles/run.invoker" \
    --region="$REGION"
  1. Envía una solicitud autenticada a /ping con tu propio token de identidad para confirmar que destination se está ejecutando:
TOKEN=$(gcloud auth print-identity-token)
curl -H "Authorization: Bearer $TOKEN" "$DESTINATION_URL/ping"

Deberías ver la siguiente respuesta:

Hello from destination

4. Llama al destino sin enlace exprés

Antes de presentar el enlace exprés, compila caller-oidc para ver qué requiere la autenticación de servicio a servicio hoy en día y verificar que un servicio de llamada pueda llegar a destination. Para llamar a destination de forma segura sin enlace exprés, debes configurar dos capas:

  • Autorización de IAM: Otorga a la cuenta de servicio caller-oidc el rol roles/run.invoker en destination.
  • Inyección de tokens a nivel de la aplicación: Agrega la biblioteca google-auth a caller-oidc y analiza la URL de destino para extraer el público de OIDC raíz. Luego, recupera un token de ID firmado del servidor de metadatos y adjunta Authorization: Bearer ID_TOKEN a la solicitud HTTPS saliente.

Sigue estos pasos para configurar e implementar caller-oidc:

  1. Crea una cuenta de servicio dedicada para caller-oidc:
gcloud iam service-accounts create caller-oidc-identity \
    --display-name="Cloud Run OIDC caller service account"
  1. Autoriza a caller-oidc-identity para que invoque 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. Crea el directorio caller-oidc junto a destination:
mkdir -p ~/express-link-codelab/caller-oidc
cd ~/express-link-codelab/caller-oidc
  1. Ejecuta el siguiente comando para crear un archivo requirements.txt. Ten en cuenta que debes agregar google-auth específicamente para controlar la recuperación de tokens en el contenedor de tu aplicación:
cat << 'EOF' > requirements.txt
Flask==3.0.0
google-auth==2.23.0
requests==2.31.0
gunicorn==21.2.0
EOF
  1. Ejecuta el siguiente comando para crear un archivo main.py con la inserción manual de tokens de 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. Implementa caller-oidc en Cloud Run:
gcloud run deploy caller-oidc \
    --source . \
    --region="$REGION" \
    --service-account="caller-oidc-identity@${PROJECT_ID}.iam.gserviceaccount.com" \
    --no-allow-unauthenticated
  1. Otorga permiso a tu cuenta de usuario para invocar caller-oidc:
gcloud run services add-iam-policy-binding caller-oidc \
    --member="user:$ACTIVE_ACCOUNT" \
    --role="roles/run.invoker" \
    --region="$REGION"
  1. Almacena la URL determinística de caller-oidc y, luego, invócala pasando la URL HTTPS $DESTINATION_URL/ping como 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"

Deberías recibir una respuesta correcta de destination:

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

5. Implementa el servicio de emisor para el enlace exprés

Ahora, compilarás un segundo servicio de emisor llamado caller-express-link en un directorio hermano. Con el enlace exprés, caller-express-link no necesita ningún código de inserción de tokens, ya que llama a requests.get(target_url, timeout=10) directamente.

  1. Crea una cuenta de servicio dedicada para caller-express-link:
gcloud iam service-accounts create caller-express-link-identity \
    --display-name="Cloud Run Express Link caller service account"
  1. Otorga a caller-express-link-identity el rol roles/trafficdirector.client para que el sidecar de Ambient Networking administrado pueda descargar la configuración de seguridad y enrutamiento de enlace exprés. También otorga roles/cloudtrace.agent para que el archivo adicional pueda exportar intervalos de seguimiento:
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. Crea el directorio caller-express-link junto a caller-oidc:
mkdir -p ~/express-link-codelab/caller-express-link
cd ~/express-link-codelab/caller-express-link
  1. Ejecuta el siguiente comando para crear un archivo requirements.txt sin google-auth:
cat << 'EOF' > requirements.txt
Flask==3.0.0
requests==2.31.0
gunicorn==21.2.0
EOF
  1. Ejecuta el siguiente comando para crear un archivo main.py con una llamada requests.get(target_url, timeout=10) simple y sin lógica de inserción de tokens:
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. Ejecuta diff en ../caller-oidc/main.py para ver el código estándar de autenticación que eliminaste:
diff -u ../caller-oidc/main.py main.py || true
  1. Implementa caller-express-link con gcloud beta run deploy con --ambient-networking y --ambient-scope=global habilitados:
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. Verifica que Ambient Networking esté activo en caller-express-link:
gcloud run services describe caller-express-link --region="$REGION"

Al final del resumen de la revisión, verifica que aparezcan Ambient Networking y Ambient Scope:

  Ambient Networking: Enabled
  Ambient Scope:     global
  1. Otorga permiso a tu cuenta de usuario para invocar caller-express-link y autoriza a caller-express-link-identity a invocar 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. Almacena la URL y el URI del recurso de caller-express-link, junto con la URL determinística 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. Prueba llamar a destination a través de caller-express-link antes de crear un enlace exprés:
TOKEN=$(gcloud auth print-identity-token)
curl -H "Authorization: Bearer $TOKEN" "$CALLER_EL_URL/?target_url=$DESTINATION_HTTP_URL/ping"

Como se esperaba, la llamada falla con 403 Forbidden porque aún no existe un enlace exprés para interceptar la solicitud y, luego, insertar las credenciales:

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. Conecta los servicios con un enlace exprés

Ahora, declararás un recurso ExpressLink que conecte caller-express-link (el servicio de origen) a destination, sin cambiar ni una sola línea de código ni volver a implementar ninguno de los servicios de Cloud Run.

  1. Crea el recurso de enlace exprés en la ubicación 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. Enumera tus enlaces exprés para confirmar que el recurso existe:
gcloud beta network-services express-links list --location=global

Resultado del comando:

NAME
caller-to-destination
  1. Inspecciona los detalles de configuración del enlace exprés:
gcloud beta network-services express-links describe caller-to-destination --location=global

Resultado del comando:

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. Vuelve a ejecutar exactamente la misma solicitud curl en caller-express-link:
TOKEN=$(gcloud auth print-identity-token)
curl -H "Authorization: Bearer $TOKEN" "$CALLER_EL_URL/?target_url=$DESTINATION_HTTP_URL/ping"

Esta vez, el sidecar de Ambient intercepta la solicitud HTTP a destination, inserta el token de identidad para caller-express-link-identity, actualiza la conexión a TLS y devuelve la respuesta del destino:

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

En la siguiente tabla, se resumen los cambios entre caller-oidc y caller-express-link:

Dimensión

Sin enlace exprés (caller-oidc)

Con Express Link (caller-express-link)

Bibliotecas de autenticación en requirements.txt

Requiere google-auth

Ninguno (solo Flask, requests y gunicorn)

Llamada saliente en main.py

Analiza la URL del público, llama a id_token.fetch_id_token() y adjunta el encabezado Authorization: Bearer

Liso requests.get(target_url, timeout=10)

Esquema de URL de destino en la app

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

http://destination-PROJECT_NUMBER.REGION.run.app (actualizado a TLS por el sidecar de Ambient)

Configuración de Cloud Run del emisor

Implementación estándar

--ambient-networking --ambient-scope=global + roles/trafficdirector.client en la cuenta de servicio del emisor

Configuración de Cloud Run de destino

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

Sin cambios (--no-allow-unauthenticated + roles/run.invoker)

7. Limpia

Para evitar que se apliquen cargos continuos a tu cuenta de Google Cloud, borra los recursos que creaste durante este codelab.

  1. Borra el recurso de enlace exprés:
gcloud beta network-services express-links delete caller-to-destination --location=global --quiet
  1. Borra los tres servicios de 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. Quita las vinculaciones de políticas de IAM a nivel de proyecto y borra las tres cuentas de servicio:
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. (Opcional) Si creaste un proyecto de Google Cloud dedicado exclusivamente para este codelab, puedes borrarlo por completo:
# Run only if you want to delete the entire project and all its resources
gcloud projects delete "$PROJECT_ID"

8. Felicitaciones

Implementaste un servicio de backend privado de Cloud Run y lo llamaste con la inserción manual de tokens de OIDC en Python. Luego, reemplazaste todo el código de autenticación a nivel de la aplicación por un enlace exprés de Cloud Run declarativo.

Qué aprendiste

  • Por qué la inserción manual de tokens de OIDC vincula la lógica empresarial de la aplicación con las bibliotecas de autenticación y los modos de seguridad de la plataforma
  • Cómo implementar un servicio de destino de Cloud Run autenticado que funcione sin cambios con o sin enlace exprés
  • Cómo habilitar Ambient Networking (--ambient-networking con --ambient-scope=global) y otorgar permisos de cliente de Traffic Director (roles/trafficdirector.client) en un servicio de Cloud Run que realiza llamadas
  • Cómo crear e inspeccionar un recurso ExpressLink de Network Services que inserte automáticamente tokens de identidad y actualice las llamadas http:// de texto simple desde tu contenedor a conexiones TLS encriptadas

Próximos pasos