1. Panoramica
Quando crei microservizi o applicazioni multi-agente su Cloud Run, i servizi di backend interni non devono essere aperti a internet pubblico. Devi invece configurare ogni servizio di backend in modo che richieda l'autenticazione (--no-allow-unauthenticated) e concedere il ruolo IAM Invoker di Cloud Run (roles/run.invoker) solo ai chiamanti autorizzati.
In genere, per chiamare un servizio Cloud Run autenticato, l'applicazione chiamante deve eseguire l'inserimento manuale dei token nel codice. Prima di inviare una richiesta HTTP, il codice esegue una query sul server dei metadati Compute per ottenere un token ID OpenID Connect (OIDC) firmato da Google. Questo token ha come ambito l'URL del pubblico del servizio di destinazione e il tuo codice lo associa all'intestazione Authorization: Bearer. La scrittura e la manutenzione del codice di autenticazione all'interno del codice dell'applicazione introducono attriti non necessari:
- Accoppia la logica di business alle librerie di autenticazione di Google Cloud, riducendo la leggibilità e la portabilità tra gli ambienti.
- La logica di acquisizione dei token varia in base ai tipi di destinazione e alle modalità di sicurezza. Ad esempio, Cloud Run prevede token ID OIDC, le API di Google prevedono token di accesso OAuth 2.0 e mTLS richiede token associati.
Cloud Run Express Link (anteprima) rimuove l'inserimento manuale dei token dal codice dell'applicazione. Attiva Ambient Networking sul servizio Cloud Run chiamante (origine) e crea una risorsa ExpressLink dichiarativa che associa il servizio di origine al servizio di destinazione. Un proxy sidecar gestito da Google intercetta le richieste HTTP in testo non crittografato in uscita verso la destinazione, inserisce automaticamente il token di identità del servizio chiamante e cripta la connessione alla destinazione.
In questo codelab, confronterai entrambi gli approcci con lo stesso servizio di backend privato:
- Esegui il deployment di un servizio di destinazione privato e di un servizio chiamante (caller-oidc) che recupera un token ID OIDC dal server dei metadati Compute in Python. Questo passaggio conferma la connettività end-to-end al backend e mostra il codice di autenticazione richiesto senza collegamento rapido.
- Esegui il deployment di un secondo servizio chiamante (caller-express-link) senza il codice di recupero dei token dei metadati e connettilo al servizio di destinazione utilizzando Ambient Networking e un collegamento rapido.
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) | +----------------------------------------------+ +-----------------+
Prerequisiti
- Conoscenza di base di Python e dei servizi web HTTP
- Familiarità di base con i service account IAM di Google Cloud e i deployment di Cloud Run
Obiettivi didattici
- Come eseguire il deployment di un servizio Cloud Run di destinazione privato che applica l'autenticazione IAM
- Come autenticare manualmente le richieste service-to-service in Python utilizzando i token ID OIDC
google-authdal server di metadati per verificare la connettività di base - Come rimuovere il codice di recupero manuale dei token ed eseguire il deployment di un servizio chiamante Cloud Run con Ambient Networking abilitato
- Come creare un collegamento rapido a Cloud Run in modo che il servizio chiamante possa richiamare un servizio di destinazione autenticato senza codice di autenticazione
Cosa creerai
- destination: un servizio Python Flask privato su Cloud Run che espone un endpoint
/ping - caller-oidc: un servizio Python Flask che chiama destination recuperando e inserendo manualmente i token ID OIDC nel codice dell'applicazione
- caller-express-link: un servizio Python Flask affiancato senza codice di inserimento dei token che chiama lo stesso servizio destination tramite un collegamento rapido
Che cosa ti serve
- Un browser web, ad esempio Chrome
- Un progetto Google Cloud con fatturazione abilitata e autorizzazioni per creare service account IAM, servizi Cloud Run e risorse di servizi di rete
2. Configura l'ambiente
Configura un progetto Google Cloud
- Se non hai ancora un Account Google, devi crearne uno.
- Utilizza un account personale anziché un account di lavoro o della scuola. Gli account di lavoro e della scuola potrebbero avere restrizioni che impediscono di abilitare le API necessarie per questo lab.
- Accedi alla console Google Cloud.
- Abilita la fatturazione nella console Cloud.
- Il completamento di questo lab dovrebbe costare meno di 1 $in risorse cloud.
- Puoi seguire i passaggi alla fine di questo lab per eliminare le risorse ed evitare ulteriori addebiti.
- I nuovi utenti sono idonei alla prova senza costi di 300 $.
- Crea un nuovo progetto o scegli di riutilizzare un progetto esistente.
- Se visualizzi un errore relativo alla quota di progetti, riutilizza un progetto esistente o eliminalo per crearne uno nuovo.
Avvia Cloud Shell
In questo codelab utilizzerai Cloud Shell, un ambiente a riga di comando basato su browser in cui sono preinstallati Google Cloud CLI (gcloud), Python e curl.
- Nella console Google Cloud, fai clic su Attiva Cloud Shell nella barra di navigazione in alto. Se richiesto, fai clic su Autorizza.
- Esporta l'ID progetto e la regione di deployment e configura
gcloudper utilizzare$PROJECT_ID. SostituisciYOUR_PROJECT_IDcon l'ID progetto e, facoltativamente, sostituiscius-west1con un'altra regione Cloud Run:
export PROJECT_ID="YOUR_PROJECT_ID"
export REGION="us-west1"
gcloud config set project "$PROJECT_ID"
- Esporta il numero di progetto e l'account Google Cloud attivo e verifica che tutte e quattro le variabili siano compilate:
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"
Aggiorna gcloud e abilita le API
- Aggiorna i componenti
gcloudin modo da avere i comandibetapiù recenti per Ambient Networking e collegamento rapido:
gcloud components update --quiet
- Abilita le API Cloud richieste per i deployment di origine Cloud Run, i service account IAM, Ambient Networking e Network Services collegamento rapido:
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 una directory del workspace
Crea una directory di lavoro per contenere le tre cartelle di servizi che creerai in questo codelab:
mkdir -p ~/express-link-codelab
cd ~/express-link-codelab
3. Esegui il deployment del servizio di destinazione privato
Innanzitutto, eseguirai il deployment di un servizio Cloud Run privato denominato destination. Riutilizzerai questo singolo servizio di destinazione per entrambe le parti del codelab:
- Un servizio di destinazione non esegue mai l'inserimento di token in uscita.
- Un servizio di destinazione non deve avere Ambient Networking abilitato per ricevere traffico su un collegamento rapido.
- Crea un service account IAM dedicato per il servizio di destinazione:
gcloud iam service-accounts create destination-identity \
--display-name="Cloud Run destination service account"
- Crea una cartella
destinatione spostati al suo interno:
mkdir -p ~/express-link-codelab/destination
cd ~/express-link-codelab/destination
- Esegui il comando seguente per creare un file
requirements.txtcon Flask e Gunicorn:
cat << 'EOF' > requirements.txt
Flask==3.0.0
gunicorn==21.2.0
EOF
- Esegui questo comando per creare un file
main.pyche espone un endpoint/pingche restituisce il nome del servizio Cloud Run dalla variabile di ambienteK_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
- Esegui il deployment di
destinationdal codice sorgente con--no-allow-unauthenticatedin modo che Cloud Run rifiuti le richieste non autenticate:
gcloud run deploy destination \
--source . \
--region="$REGION" \
--service-account="destination-identity@${PROJECT_ID}.iam.gserviceaccount.com" \
--no-allow-unauthenticated
- Memorizza l'URL deterministico e l'URI completo della risorsa del servizio di destinazione nelle variabili di ambiente:
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"
- Concedi al tuo account utente il ruolo Cloud Run Invoker (
roles/run.invoker) sudestinationin modo da poterlo testare direttamente da Cloud Shell:
gcloud run services add-iam-policy-binding destination \
--member="user:$ACTIVE_ACCOUNT" \
--role="roles/run.invoker" \
--region="$REGION"
- Invia una richiesta autenticata a
/pingutilizzando il tuo token di identità per confermare chedestinationè in esecuzione:
TOKEN=$(gcloud auth print-identity-token)
curl -H "Authorization: Bearer $TOKEN" "$DESTINATION_URL/ping"
Dovresti vedere la seguente risposta:
Hello from destination
4. Chiama la destinazione senza collegamento rapido
Prima di introdurre il collegamento rapido, crea caller-oidc per vedere cosa richiede oggi l'autenticazione service-to-service e verifica che un servizio chiamante possa raggiungere destination. To call destination securely without Express Link, you must configure two layers:
- Autorizzazione IAM: concedi al service account
caller-oidcil ruoloroles/run.invokersudestination. - Inserimento di token a livello di applicazione: aggiungi la libreria
google-authacaller-oidce analizza l'URL di destinazione per estrarre l'audience OIDC principale. Quindi, recupera un token ID firmato dal server dei metadati e allegaAuthorization: Bearer ID_TOKENalla richiesta HTTPS in uscita.
Segui questi passaggi per configurare ed eseguire il deployment di caller-oidc:
- Crea un account di servizio dedicato per
caller-oidc:
gcloud iam service-accounts create caller-oidc-identity \
--display-name="Cloud Run OIDC caller service account"
- Autorizza
caller-oidc-identitya richiamaredestination:
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 la directory
caller-oidcinsieme adestination:
mkdir -p ~/express-link-codelab/caller-oidc
cd ~/express-link-codelab/caller-oidc
- Esegui il comando seguente per creare un file
requirements.txt. Tieni presente che devi aggiungeregoogle-authin modo specifico per gestire il recupero dei token nel container dell'applicazione:
cat << 'EOF' > requirements.txt
Flask==3.0.0
google-auth==2.23.0
requests==2.31.0
gunicorn==21.2.0
EOF
- Esegui il comando seguente per creare un file
main.pycon l'inserimento manuale del token 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
- Esegui il deployment di
caller-oidcin Cloud Run:
gcloud run deploy caller-oidc \
--source . \
--region="$REGION" \
--service-account="caller-oidc-identity@${PROJECT_ID}.iam.gserviceaccount.com" \
--no-allow-unauthenticated
- Concedi al tuo account utente l'autorizzazione per richiamare
caller-oidc:
gcloud run services add-iam-policy-binding caller-oidc \
--member="user:$ACTIVE_ACCOUNT" \
--role="roles/run.invoker" \
--region="$REGION"
- Archivia l'URL deterministico di
caller-oidce richiamalo, passando l'URL HTTPS$DESTINATION_URL/pingcometarget_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"
Dovresti ricevere una risposta positiva da destination:
I called the destination and it replied: 'Hello from destination'
5. Esegui il deployment del servizio chiamante per il collegamento rapido
Ora creerai un secondo servizio chiamante denominato caller-express-link in una directory di pari livello. Con il collegamento rapido, caller-express-link non ha bisogno di alcun codice di inserimento dei token: chiama direttamente requests.get(target_url, timeout=10).
- Crea un account di servizio dedicato per
caller-express-link:
gcloud iam service-accounts create caller-express-link-identity \
--display-name="Cloud Run Express Link caller service account"
- Concedi a
caller-express-link-identityil ruoloroles/trafficdirector.clientin modo che il sidecar Ambient Networking gestito possa scaricare la configurazione di sicurezza e routing di collegamento rapido. Concedi ancheroles/cloudtrace.agentin modo che il sidecar possa esportare gli intervalli di traccia:
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 la directory
caller-express-linkinsieme acaller-oidc:
mkdir -p ~/express-link-codelab/caller-express-link
cd ~/express-link-codelab/caller-express-link
- Esegui il comando seguente per creare un file
requirements.txtsenzagoogle-auth:
cat << 'EOF' > requirements.txt
Flask==3.0.0
requests==2.31.0
gunicorn==21.2.0
EOF
- Esegui il comando seguente per creare un file
main.pycon una semplice chiamatarequests.get(target_url, timeout=10)e nessuna logica di inserimento dei token:
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
- Esegui
diffsu../caller-oidc/main.pyper visualizzare il boilerplate di autenticazione che hai eliminato:
diff -u ../caller-oidc/main.py main.py || true
- Esegui il deployment di
caller-express-linkutilizzandogcloud beta run deploycon--ambient-networkinge--ambient-scope=globalabilitati:
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 che Ambient Networking sia attivo su
caller-express-link:
gcloud run services describe caller-express-link --region="$REGION"
Alla fine del riepilogo della revisione, verifica che vengano visualizzati Ambient Networking e Ambient Scope:
Ambient Networking: Enabled Ambient Scope: global
- Concedi al tuo account utente l'autorizzazione per richiamare
caller-express-linke autorizzacaller-express-link-identitya richiamaredestination:
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"
- Memorizza l'URL e l'URI della risorsa di
caller-express-link, insieme all'URL deterministico HTTP (http://) didestination:
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"
- Testa le chiamate da
destinationacaller-express-linkprima di creare un collegamento rapido:
TOKEN=$(gcloud auth print-identity-token)
curl -H "Authorization: Bearer $TOKEN" "$CALLER_EL_URL/?target_url=$DESTINATION_HTTP_URL/ping"
Come previsto, la chiamata non va a buon fine con 403 Forbidden perché non esiste ancora un collegamento rapido per intercettare la richiesta e inserire le credenziali:
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. Connetti i servizi con un collegamento rapido
Ora dichiarerai una risorsa ExpressLink che connette caller-express-link (il servizio di origine) a destination, senza modificare una singola riga di codice o rifare il deployment di uno dei servizi Cloud Run.
- Crea la risorsa collegamento rapido nella località
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"
- Elenca i tuoi collegamenti rapidi per confermare che la risorsa esiste:
gcloud beta network-services express-links list --location=global
Output comando:
NAME caller-to-destination
- Esamina i dettagli di configurazione del collegamento rapido:
gcloud beta network-services express-links describe caller-to-destination --location=global
Output 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'
- Esegui di nuovo la stessa identica richiesta
curlsucaller-express-link:
TOKEN=$(gcloud auth print-identity-token)
curl -H "Authorization: Bearer $TOKEN" "$CALLER_EL_URL/?target_url=$DESTINATION_HTTP_URL/ping"
Questa volta, il sidecar Ambient intercetta la richiesta HTTP a destination, inserisce il token di identità per caller-express-link-identity, esegue l'upgrade della connessione a TLS e restituisce la risposta della destinazione:
I called the destination and it replied: 'Hello from destination'
Confronta l'inserimento manuale dei token con il collegamento rapido
La seguente tabella riassume le modifiche tra caller-oidc e caller-express-link:
Dimensione | Senza collegamento rapido ( | Con collegamento rapido ( |
Librerie Auth in | Richiede | Nessuno (solo |
Chiamata in uscita tra | Analizza l'URL del pubblico, chiama | Semplice |
Schema URL target nell'app |
|
|
Configurazione di Cloud Run per il chiamante | Deployment standard |
|
Configurazione di Cloud Run di destinazione |
| Invariati ( |
7. Esegui la pulizia
Per evitare che al tuo account Google Cloud vengano addebitati costi, elimina le risorse che hai creato durante questo codelab.
- Elimina la risorsa di collegamento rapido:
gcloud beta network-services express-links delete caller-to-destination --location=global --quiet
- Elimina i tre servizi 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
- Rimuovi le associazioni delle policy IAM a livello di progetto ed elimina i tre service account:
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
- (Facoltativo) Se hai creato un progetto Google Cloud dedicato esclusivamente a questo codelab, puoi eliminare l'intero progetto:
# Run only if you want to delete the entire project and all its resources
gcloud projects delete "$PROJECT_ID"
8. Complimenti
Hai eseguito il deployment di un servizio di backend Cloud Run privato e lo hai chiamato utilizzando l'inserimento manuale dei token OIDC in Python. Poi hai sostituito tutto il codice di autenticazione a livello di applicazione con un collegamento rapido a Cloud Run dichiarativo.
Che cosa hai imparato
- Perché l'inserimento manuale dei token OIDC accoppia la logica di business dell'applicazione alle librerie di autenticazione e alle modalità di sicurezza della piattaforma
- Come eseguire il deployment di un servizio Cloud Run di destinazione autenticato che funziona invariato con o senza collegamento rapido
- Come abilitare Ambient Networking (
--ambient-networkingcon--ambient-scope=global) e concedere le autorizzazioni client di Traffic Director (roles/trafficdirector.client) su un servizio Cloud Run chiamante - Come creare e ispezionare una risorsa Network Services
ExpressLinkche inserisce automaticamente i token di identità ed esegue l'upgrade delle chiamatehttp://in testo non crittografato dal container alle connessioni TLS criptate
Passaggi successivi
- Leggi Autenticazione tra servizi nella documentazione di Cloud Run.
- Consulta le note di rilascio di Cloud Run per gli ultimi aggiornamenti su Ambient Networking e collegamento rapido.