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:
- 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.
- 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-authdel 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
- 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.
- Accede a la consola de Google Cloud.
- 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.
- 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.
- 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.
- Exporta el ID del proyecto y la región de implementación, y configura
gcloudpara usar$PROJECT_ID. ReemplazaYOUR_PROJECT_IDpor el ID de tu proyecto y, de manera opcional, reemplazaus-west1por otra región de Cloud Run:
export PROJECT_ID="YOUR_PROJECT_ID"
export REGION="us-west1"
gcloud config set project "$PROJECT_ID"
- 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
- Actualiza tus componentes de
gcloudpara tener los comandos debetamás recientes para Ambient Networking y Express Link:
gcloud components update --quiet
- 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.
- 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"
- Crea una carpeta
destinationy muévete a ella:
mkdir -p ~/express-link-codelab/destination
cd ~/express-link-codelab/destination
- Ejecuta el siguiente comando para crear un archivo
requirements.txtcon Flask y Gunicorn:
cat << 'EOF' > requirements.txt
Flask==3.0.0
gunicorn==21.2.0
EOF
- Ejecuta el siguiente comando para crear un archivo
main.pyque exponga un extremo/pingque devuelva el nombre del servicio de Cloud Run desde la variable de entornoK_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
- Implementa
destinationdesde la fuente con--no-allow-unauthenticatedpara 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
- 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"
- Otorga a tu cuenta de usuario el rol de Invocador de Cloud Run (
roles/run.invoker) endestinationpara 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"
- Envía una solicitud autenticada a
/pingcon tu propio token de identidad para confirmar quedestinationse 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-oidcel rolroles/run.invokerendestination. - Inyección de tokens a nivel de la aplicación: Agrega la biblioteca
google-authacaller-oidcy 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 adjuntaAuthorization: Bearer ID_TOKENa la solicitud HTTPS saliente.
Sigue estos pasos para configurar e implementar caller-oidc:
- 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"
- Autoriza a
caller-oidc-identitypara que invoquedestination:
gcloud run services add-iam-policy-binding destination \
--member="serviceAccount:caller-oidc-identity@${PROJECT_ID}.iam.gserviceaccount.com" \
--role="roles/run.invoker" \
--region="$REGION"
- Crea el directorio
caller-oidcjunto adestination:
mkdir -p ~/express-link-codelab/caller-oidc
cd ~/express-link-codelab/caller-oidc
- Ejecuta el siguiente comando para crear un archivo
requirements.txt. Ten en cuenta que debes agregargoogle-authespecí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
- Ejecuta el siguiente comando para crear un archivo
main.pycon 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
- Implementa
caller-oidcen Cloud Run:
gcloud run deploy caller-oidc \
--source . \
--region="$REGION" \
--service-account="caller-oidc-identity@${PROJECT_ID}.iam.gserviceaccount.com" \
--no-allow-unauthenticated
- 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"
- Almacena la URL determinística de
caller-oidcy, luego, invócala pasando la URL HTTPS$DESTINATION_URL/pingcomotarget_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.
- 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"
- Otorga a
caller-express-link-identityel rolroles/trafficdirector.clientpara que el sidecar de Ambient Networking administrado pueda descargar la configuración de seguridad y enrutamiento de enlace exprés. También otorgaroles/cloudtrace.agentpara 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"
- Crea el directorio
caller-express-linkjunto acaller-oidc:
mkdir -p ~/express-link-codelab/caller-express-link
cd ~/express-link-codelab/caller-express-link
- Ejecuta el siguiente comando para crear un archivo
requirements.txtsingoogle-auth:
cat << 'EOF' > requirements.txt
Flask==3.0.0
requests==2.31.0
gunicorn==21.2.0
EOF
- Ejecuta el siguiente comando para crear un archivo
main.pycon una llamadarequests.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
- Ejecuta
diffen../caller-oidc/main.pypara ver el código estándar de autenticación que eliminaste:
diff -u ../caller-oidc/main.py main.py || true
- Implementa
caller-express-linkcongcloud beta run deploycon--ambient-networkingy--ambient-scope=globalhabilitados:
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
- 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
- Otorga permiso a tu cuenta de usuario para invocar
caller-express-linky autoriza acaller-express-link-identitya invocardestination:
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"
- Almacena la URL y el URI del recurso de
caller-express-link, junto con la URL determinística HTTP (http://) dedestination:
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"
- Prueba llamar a
destinationa través decaller-express-linkantes 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.
- 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"
- 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
- 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'
- Vuelve a ejecutar exactamente la misma solicitud
curlencaller-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'
Compara la inserción manual de tokens con el enlace exprés
En la siguiente tabla, se resumen los cambios entre caller-oidc y caller-express-link:
Dimensión | Sin enlace exprés ( | Con Express Link ( |
Bibliotecas de autenticación en | Requiere | Ninguno (solo |
Llamada saliente en | Analiza la URL del público, llama a | Liso |
Esquema de URL de destino en la app |
|
|
Configuración de Cloud Run del emisor | Implementación estándar |
|
Configuración de Cloud Run de destino |
| Sin cambios ( |
7. Limpia
Para evitar que se apliquen cargos continuos a tu cuenta de Google Cloud, borra los recursos que creaste durante este codelab.
- Borra el recurso de enlace exprés:
gcloud beta network-services express-links delete caller-to-destination --location=global --quiet
- 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
- 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
- (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-networkingcon--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
ExpressLinkde Network Services que inserte automáticamente tokens de identidad y actualice las llamadashttp://de texto simple desde tu contenedor a conexiones TLS encriptadas
Próximos pasos
- Lee Autenticación de servicio a servicio en la documentación de Cloud Run.
- Consulta las notas de la versión de Cloud Run para conocer las actualizaciones más recientes sobre Ambient Networking y enlace exprés.