Private Service Connect: utilizzo di Private Service Connect per pubblicare e utilizzare servizi con Cloud Run

1. Introduzione

Private Service Connect (PSC) è una funzionalità di networking di Google Cloud che consente ai consumer di accedere ai servizi gestiti privatamente dall'interno della propria rete VPC. Allo stesso modo, consente ai producer di servizi gestiti di ospitare questi servizi nelle proprie reti VPC separate e di offrire una connessione privata ai propri consumer.

Cloud Run è una piattaforma di computing gestita che ti consente di eseguire container direttamente sull'infrastruttura scalabile di Google.

Cloud Run può essere utilizzato come servizio PSC in due modi diversi.

1. Tramite PSC per le API di Google chiamando Cloud Run tramite l'URL run.app fornito da Cloud Run
2. Tramite un servizio di produzione PSC personalizzato in cui Cloud Run viene esposto tramite un collegamento di servizio tramite un bilanciatore del carico delle applicazioni interno con un NEG serverless.

Questo codelab esplorerà come configurare Cloud Run con PSC per entrambi gli scenari

Cosa imparerai a fare

• Deployment di app di base su Cloud Run
• Controlli in entrata e in uscita di Cloud Run
• Deployment di Cloud Run tramite un bilanciatore del carico delle applicazioni interno con un NEG serverless
• Configurazione di un servizio producer PSC tramite un collegamento di servizio
• Deployment degli endpoint PSC

Che cosa ti serve

• Progetto Google Cloud con autorizzazioni di proprietario

2. Topologia del codelab

In questo codelab, eseguirai il deployment di due servizi Cloud Run accessibili tramite PSC: il primo come servizio pubblicato personalizzato con PSC e il secondo come PSC per le API di Google. Creerai due VPC, consumer-vpc e producer-vpc. Innanzitutto, esegui il deployment del servizio Cloud Run Hello World e rendilo accessibile tramite un bilanciatore del carico delle applicazioni interno regionale e un NEG serverless in producer-vpc. Verificherai che il servizio funzioni tramite il bilanciatore del carico tramite il produttore-client prima di configurare il servizio Cloud Run in modo che sia accessibile come servizio di produzione PSC tramite un collegamento al servizio.

Passando a consumer-vpc, devi eseguire il deployment di un endpoint PSC che punta al collegamento di servizio Cloud Run che abbiamo configurato in producer-vpc. Quindi verificherai che il servizio sia accessibile tramite PSC da un client consumer nel VPC consumer. Successivamente, creerai un altro servizio Cloud Run che chiama l'endpoint PSC. Infine, eseguirai il deployment di un endpoint PSC per le API di Google. Dal client consumer, accederai a Cloud Run tramite l'URL fornito da Cloud Run, che utilizzerà l'endpoint PSC per le API di Google.

3. Configurazione e requisiti

Configurazione dell'ambiente autonomo

1. Accedi alla console Google Cloud e crea un nuovo progetto o riutilizzane uno esistente. Se non hai ancora un account Gmail o Google Workspace, devi crearne uno.

• Il nome del progetto è il nome visualizzato per i partecipanti a questo progetto. È una stringa di caratteri non utilizzata dalle API di Google. Puoi sempre aggiornarlo.
• L'ID progetto è univoco in tutti i progetti Google Cloud ed è immutabile (non può essere modificato dopo l'impostazione). La console Cloud genera automaticamente una stringa univoca, di solito non ti interessa di cosa si tratta. Nella maggior parte dei codelab, dovrai fare riferimento all'ID progetto (in genere identificato come PROJECT_ID). Se l'ID generato non ti piace, puoi generarne un altro casuale. In alternativa, puoi provare a crearne uno e vedere se è disponibile. Non può essere modificato dopo questo passaggio e rimane per tutta la durata del progetto.
• Per tua informazione, esiste un terzo valore, un numero di progetto, utilizzato da alcune API. Scopri di più su tutti e tre questi valori nella documentazione.

Attenzione:un ID progetto è univoco a livello globale e non può essere utilizzato da altri dopo che lo hai selezionato. Sei l'unico utente di questo ID. Anche se un progetto viene eliminato, l'ID non può essere riutilizzato

Nota:se utilizzi un account Gmail, puoi lasciare la posizione predefinita impostata su Nessuna organizzazione. Se utilizzi un account Google Workspace, scegli una posizione adatta alla tua organizzazione.

2. Successivamente, devi abilitare la fatturazione in Cloud Console per utilizzare le risorse/API Cloud. Completare questo codelab non costa molto, se non nulla. Per arrestare le risorse ed evitare addebiti oltre a quelli previsti in questo tutorial, puoi eliminare le risorse che hai creato o il progetto. I nuovi utenti di Google Cloud possono beneficiare del programma prova senza costi di 300$.

Avvia Cloud Shell

Sebbene Google Cloud possa essere gestito da remoto dal tuo laptop, in questo codelab utilizzerai Google Cloud Shell, un ambiente a riga di comando in esecuzione nel cloud.

Nella console Google Cloud, fai clic sull'icona di Cloud Shell nella barra degli strumenti in alto a destra:

Bastano pochi istanti per eseguire il provisioning e connettersi all'ambiente. Al termine, dovresti vedere un risultato simile a questo:

Questa macchina virtuale è caricata con tutti gli strumenti per sviluppatori di cui avrai bisogno. Offre una home directory permanente da 5 GB e viene eseguita su Google Cloud, migliorando notevolmente le prestazioni e l'autenticazione della rete. Tutto il lavoro in questo codelab può essere svolto all'interno di un browser. Non devi installare nulla.

4. Prima di iniziare

Abilita API

In Cloud Shell, assicurati che il progetto sia configurato e configura le variabili.

gcloud auth login
gcloud config list project
gcloud config set project [YOUR-PROJECT-ID]
export projectid=[YOUR-PROJECT-ID]
export projectnum=[YOUR-PROJECT-NUM]
export region=us-central1
export zone=us-central1-a
echo $projectid
echo $projectnum
echo $region
echo $zone

Attiva tutti i servizi necessari

gcloud services enable compute.googleapis.com
gcloud services enable run.googleapis.com
gcloud services enable servicedirectory.googleapis.com
gcloud services enable dns.googleapis.com
gcloud services enable cloudbuild.googleapis.com
gcloud services enable cloudresourcemanager.googleapis.com

5. Crea rete VPC producer

Rete VPC

Da Cloud Shell

gcloud compute networks create producer-vpc --subnet-mode custom

Crea subnet

Da Cloud Shell

gcloud compute networks subnets create producer-subnet \
    --network=producer-vpc \
    --range=10.0.0.0/28 \
    --region=$region

gcloud compute networks subnets create lb-proxy-subnet \
    --network=producer-vpc \
    --range=10.100.100.0/24 \
    --region=$region \
    --purpose=REGIONAL_MANAGED_PROXY \
    --role=ACTIVE

gcloud compute networks subnets create psc-nat-subnet \
    --network=producer-vpc \
    --region=$region \
    --range=10.100.101.0/24 \
    --purpose=PRIVATE_SERVICE_CONNECT

La subnet PSC verrà associata al collegamento del servizio PSC ai fini della Network Address Translation. Per i casi d'uso di produzione, le dimensioni di questa subnet devono essere adeguate per supportare il numero di endpoint collegati. Per saperne di più, consulta la documentazione sul dimensionamento della subnet NAT PSC.

Crea la policy firewall di rete del produttore e le regole firewall

Da Cloud Shell

gcloud compute network-firewall-policies create producer-vpc-policy --global

gcloud compute network-firewall-policies associations create \
    --firewall-policy producer-vpc-policy \
    --network producer-vpc \
    --name network-producer-vpc \
    --global-firewall-policy

Per consentire a IAP di connettersi alle tue istanze VM, crea una regola firewall che:

• Si applichi a tutte le istanze VM a cui vuoi accedere tramite IAP.
• Consente il traffico in entrata dall'intervallo IP 35.235.240.0/20. Questo intervallo contiene tutti gli indirizzi IP che utilizzati da IAP per l'inoltro TCP.

Da Cloud Shell

gcloud compute network-firewall-policies rules create 1000 \
    --action ALLOW \
    --firewall-policy producer-vpc-policy \
    --description "SSH with IAP" \
    --direction INGRESS \
    --src-ip-ranges 35.235.240.0/20 \
    --layer4-configs tcp:22  \
    --global-firewall-policy

6. Crea Hello World Cloud Run

Segui le istruzioni qui per scrivere un'applicazione di esempio in Python. Esegui questi comandi in Cloud Shell. Dopo aver completato il passaggio 3 di "Scrivi l'applicazione di esempio", torna a questo codelab e segui le istruzioni riportate di seguito per eseguire il deployment in Cloud Run dal codice sorgente.

Prima di eseguire il deployment del servizio Cloud Run, assicurati che il service account Compute predefinito disponga delle autorizzazioni appropriate eseguendo il seguente comando.

Da Cloud Shell

gcloud projects add-iam-policy-binding $projectid --member=serviceAccount:$[e-mail] --role=roles/run.builder

NOTA: questo codelab presuppone che la tua organizzazione non abbia attivato il criterio dell'organizzazione per la condivisione con limitazioni del dominio. Se questa norma è abilitata, dovrai eseguire passaggi aggiuntivi per eseguire il deployment di Cloud Run con l'autenticazione, configurare una schermata per il consenso OAuth e configurare IAP per il backend del bilanciatore del carico. Ti consigliamo di seguire tutti questi passaggi di configurazione in un ambiente di produzione.

Da Cloud Shell

gcloud beta run deploy helloworld \
    --source . \
    --platform=managed \
    --ingress=internal \
    --allow-unauthenticated \
    --no-default-url \
    --region=$region

L'utilizzo del flag --no-default-url eseguirà il deployment del servizio Cloud Run senza l'URL run.app fornito. Non utilizzeremo l'URL per questo servizio. Al momento della pubblicazione di questo codelab, questa funzionalità è ancora in anteprima.

Prima di continuare, torna alla directory principale di Cloud Shell.

Da Cloud Shell

cd ..

7. Esporre Hello World Cloud Run tramite un bilanciatore del carico delle applicazioni interno

Prenota un indirizzo IP interno statico per la regola di forwarding del bilanciatore del carico.

In Cloud Shell

gcloud compute addresses create cloudrun-ip \
 --region=$region \
 --subnet=producer-subnet

gcloud compute addresses describe cloudrun-ip --region=$region

Esempio di output

address: 10.0.1.31
addressType: INTERNAL
creationTimestamp: '2025-03-17T09:04:06.620-07:00'
description: ''
id: 'xxxx'
kind: compute#address
labelFingerprint: xxxx
name: cloudrun-ip
networkTier: PREMIUM
purpose: GCE_ENDPOINT
region: https://www.googleapis.com/compute/v1/projects/$projectid/regions/$region
selfLink: https://www.googleapis.com/compute/v1/projects/$projectid/regions/$region/addresses/cloudrun-ip
status: RESERVED
subnetwork: https://www.googleapis.com/compute/v1/projects/$projectid/regions/$region/subnetworks/producer-subnet

Prendi nota dell'indirizzo IP appena creato.

Crea il bilanciatore del carico delle applicazioni interno regionale

In Cloud Shell

gcloud compute network-endpoint-groups create cloudrun-producer-neg \
    --region=$region \
    --network-endpoint-type=serverless \
    --cloud-run-service=helloworld

gcloud compute backend-services create cloudrun-producer-bes \
    --load-balancing-scheme=INTERNAL_MANAGED \
    --protocol=HTTP \
    --region=$region

gcloud compute backend-services add-backend cloudrun-producer-bes \
        --region=$region \
        --network-endpoint-group=cloudrun-producer-neg \
        --network-endpoint-group-region=$region

gcloud compute url-maps create producer-urlmap \
        --default-service=cloudrun-producer-bes \
        --region=$region

gcloud compute target-http-proxies create producer-http-proxy \
        --url-map=producer-urlmap \
        --region=$region

In Cloud Shell

gcloud compute forwarding-rules create cloudrun-fr \
        --load-balancing-scheme=INTERNAL_MANAGED \
        --network=producer-vpc \
        --subnet=producer-subnet \
        --address=cloudrun-ip \
        --target-http-proxy=producer-http-proxy \
        --target-http-proxy-region=$region \
        --region=$region \
        --ports=80 \
        --allow-global-access

8. Testare il servizio Cloud Run Hello World esposto tramite il bilanciatore del carico

Crea VM di test

Da Cloud Shell

gcloud compute instances create producer-client \
    --zone=$zone \
    --subnet=producer-subnet \
    --no-address \
    --scopes=cloud-platform

In Cloud Shell

gcloud compute ssh \
    --zone "$zone" "producer-client" \
    --tunnel-through-iap \
    --project $projectid

Sostituisci <loadbalancer-ip> con l'indirizzo IP che hai creato in precedenza (ad esempio 10.0.0.2).

Testa Hello World

In producer-vm

curl <loadbalancer-ip>

Risultato previsto

Hello World!

Esci dalla VM.

In producer-vm

exit

9. Crea collegamento al servizio

Da Cloud Shell

gcloud compute service-attachments create cloudrun-attachment \
    --region=$region \
    --producer-forwarding-rule=cloudrun-fr \
    --connection-preference=ACCEPT_MANUAL \
    --consumer-accept-list=$projectid=5 \
    --nat-subnets=psc-nat-subnet

Successivamente, recupera e annota l'URI del collegamento al servizio per configurare l'endpoint PSC nell'ambiente consumer.

In Cloud Shell

gcloud compute service-attachments describe cloudrun-attachment --region=$region

Output previsto di esempio

connectionPreference: ACCEPT_MANUAL
consumerAcceptLists:
- connectionLimit: 5
  projectIdOrNum: $projectid
creationTimestamp: '2025-03-10T08:49:08.134-07:00'
description: ''
enableProxyProtocol: false
fingerprint: -F0Kpe3Fi8o=
id: '2679595584727463707'
kind: compute#serviceAttachment
name: cloudrun-attachment
natSubnets:
- https://www.googleapis.com/compute/v1/projects/$projectid/regions/$region/subnetworks/psc-nat-subnet
pscServiceAttachmentId:
  high: 'xxxxx'
  low: 'xxxx'
reconcileConnections: false
region: https://www.googleapis.com/compute/v1/projects/$projectid/regions/$region
selfLink: https://www.googleapis.com/compute/v1/projects/$projectid/regions/$region/serviceAttachments/cloudrun-attachment
targetService: https://www.googleapis.com/compute/v1/projects/$projectid/regions/$projectid/forwardingRules/cloudrun-fr

10. Crea rete VPC consumer

Rete VPC

Da Cloud Shell

gcloud compute networks create consumer-vpc --subnet-mode custom

Crea subnet

Da Cloud Shell

gcloud compute networks subnets create consumer-subnet \
    --network=consumer-vpc \
    --range=10.0.0.0/24 \
    --region=$region \
    --enable-private-ip-google-access

gcloud compute networks subnets create cloudrun-egress \
    --network=consumer-vpc \
    --range=10.0.1.0/24 \
    --region=$region \
    --enable-private-ip-google-access

Crea Cloud NAT

Da Cloud Shell

gcloud compute routers create central-cr \
    --network=consumer-vpc \
    --region=$region

gcloud compute routers nats create central-nat \
    --router=central-cr \
    --region=$region \
    --nat-all-subnet-ip-ranges \
    --auto-allocate-nat-external-ips

Crea criteri firewall di rete consumer e regole firewall

Creeremo un'altra policy firewall di rete per consumer-vpc.

Da Cloud Shell

gcloud compute network-firewall-policies create consumer-vpc-policy --global

gcloud compute network-firewall-policies associations create --firewall-policy consumer-vpc-policy --network consumer-vpc --name network-consumer-vpc --global-firewall-policy

gcloud compute network-firewall-policies rules create 1000 --action ALLOW --firewall-policy consumer-vpc-policy --description "SSH with IAP" --direction INGRESS --src-ip-ranges 35.235.240.0/20 --layer4-configs tcp:22  --global-firewall-policy

11. Crea l'endpoint PSC per il servizio Hello World Cloud Run

A questo punto, creeremo un endpoint PSC e lo collegheremo al servizio Cloud Run che hai esposto tramite il collegamento del servizio. Utilizzerai l'URI del collegamento di servizio che hai annotato in precedenza in questa sezione. Assicurati che il formato dell'URI nel comando gcloud corrisponda al tuo URI.

Crea endpoint PSC

Da Cloud Shell

gcloud compute addresses create cloudrun-service-ip --region=$region --subnet=consumer-subnet --ip-version=IPV4


gcloud compute forwarding-rules create cloudrun-ep --region=$region --network=consumer-vpc --address=cloudrun-service-ip --target-service-attachment=projects/$projectid/regions/$region/serviceAttachments/cloudrun-attachment

Ottieni l'indirizzo IP dell'endpoint PSC che hai appena creato. Utilizzerai l'indirizzo IP nel passaggio successivo per testare l'endpoint.

Da Cloud Shell

gcloud compute addresses list --filter="name=cloudrun-service-ip"

Output previsto di esempio

NAME: cloudrun-service-ip
ADDRESS/RANGE: 10.0.0.2
TYPE: INTERNAL
PURPOSE: GCE_ENDPOINT
NETWORK: 
REGION: us-central1
SUBNET: consumer-subnet
STATUS: IN_USE

12. Crea la VM consumer-client e testa la connettività all'endpoint

Crea una VM consumer-client

Da Cloud Shell

gcloud compute instances create consumer-client \
    --zone=$zone \
    --subnet=consumer-subnet \
    --no-address \
    --metadata startup-script='#! /bin/bash
    sudo apt-get update
    sudo apt-get install dnsutils -y'

Test di connettività

Da Cloud Shell

gcloud compute ssh \
    --zone "$zone" "consumer-client" \
    --tunnel-through-iap \
    --project $projectid

Sostituisci <cloudrun-service-ip> con l'indirizzo IP effettivo.

Dalla VM client consumer

curl <cloudrun-service-ip>

Risultato previsto

Hello World!

Dalla VM client consumer

exit

13. Crea il servizio Cloud Run Loop

Successivamente, creeremo un servizio Cloud Run che effettuerà un richiamo privato nel consumer-vpc per chiamare il servizio Cloud Run HelloWorld precedente che abbiamo esposto tramite PSC.

Segui le istruzioni riportate nella sezione "Scrivi l'applicazione di esempio" qui per scrivere un'applicazione di loop in PHP. Invece di helloworld-php, assegna alla directory il nome cloudrun-loop. Esegui questi comandi in Cloud Shell. Nel passaggio 2, utilizza il codice PHP riportato di seguito nel file index.php. Torna al codelab quando è tutto pronto per il deployment in Cloud Run. Non seguire le istruzioni riportate nella documentazione per questo passaggio.

Utilizza questo codice per il file index.php. Sostituisci <cloudrun-service-ip> con l'indirizzo IP dell'endpoint PSC che hai testato nel passaggio precedente.

Da Cloud Shell

<?php 

if(!function_exists('curl_init')) {
    die('cURL not available!');
}

$curl = curl_init();
curl_setopt($curl, CURLOPT_URL, 'http://<cloudrun-service-ip>/');
curl_setopt($curl, CURLOPT_FAILONERROR, true);
curl_setopt($curl, CURLOPT_FOLLOWLOCATION, true);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);

$output = curl_exec($curl);
if ($output === FALSE) {
    echo 'An error has occurred: ' . curl_error($curl) . PHP_EOL;
}
else {
    echo $output;
}
?>

Specifichiamo una rete e una subnet in questo deployment Cloud Run perché il traffico Cloud Run deve uscire di nuovo nella VPC per accedere all'endpoint PSC. Stiamo indirizzando Cloud Run a utilizzare la subnet cloudrun-egress per l'uscita VPC diretto. Stiamo indirizzando tutto il traffico in uscita tramite la subnet di uscita VPC diretto di nuovo nel VPC.

Da Cloud Shell

gcloud run deploy cloudrun-loop \
    --source . \
    --platform=managed \
    --ingress=internal \
    --allow-unauthenticated  \
    --vpc-egress=all-traffic \
    --network=consumer-vpc \
    --subnet=cloudrun-egress \
    --region=$region

Al termine del deployment, il servizio Cloud Run fornirà un URL del servizio nel formato https://cloudrun-loop-<projectnum>.<region>.run.app. Prendi nota anche di questo URL, che testerai nel passaggio successivo.

14. Testa la connettività a Cloud Run - Ciclo nell'URL di Cloud Run

Da Cloud Shell

gcloud compute ssh \
    --zone "$zone" "consumer-client" \
    --tunnel-through-iap \
    --project $projectid

Sostituisci <Cloud-Run-ServiceURL> con l'URL del servizio annotato nel passaggio precedente.

Dalla VM client consumer

curl <Cloud-Run-ServiceURL>

Risultato previsto

Hello World!

Questo risultato mostra che il nostro servizio CloudRun-Loop richiama correttamente consumer-vpc per chiamare il nostro endpoint PSC connesso al nostro servizio Cloud Run Hello World. Tuttavia, a questo punto, la nostra VM client consumer esce su internet tramite Cloud NAT per effettuare una chiamata al nostro URL Cloud Run pubblico. Possiamo eseguire un dig sull'URL per dimostrare che verrà risolto in un indirizzo IP pubblico.

Dalla VM client consumer

dig <Cloud-Run-ServiceURL>

Esempio di output

; <<>> DiG 9.18.33-1~deb12u2-Debian <<>> https://cloudrun-loop-<projectnum>.<region>.run.app
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 1938
;; flags: qr rd ra; QUERY: 1, ANSWER: 4, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 65494
;; QUESTION SECTION:
;https://cloudrun-loop-<projectnum>.<region>.run.app.        IN A

;; ANSWER SECTION:
https://cloudrun-loop-<projectnum>.<region>.run.app. 300 IN A 216.239.38.53
https://cloudrun-loop-<projectnum>.<region>.run.app. 300 IN A 216.239.36.53
https://cloudrun-loop-<projectnum>.<region>.run.app. 300 IN A 216.239.32.53
https://cloudrun-loop-<projectnum>.<region>.run.app. 300 IN A 216.239.34.53

;; Query time: 4 msec
;; SERVER: 127.0.0.53#53(127.0.0.53) (UDP)
;; WHEN: Tue Mar 11 19:05:36 UTC 2025
;; MSG SIZE  rcvd: 147

Possiamo creare un endpoint PSC per le API di Google per modificare questa risoluzione in privata e mantenere il traffico lontano da internet pubblico.

Dalla VM client consumer

exit

15. Crea PSC per l'endpoint delle API di Google

Questo endpoint PSC è diverso da quello creato in precedenza. PSC per le API di Google punta a un bundle di API di Google (tutte le API o le API compatibili con VPC-SC). L'indirizzo IP non proviene da una subnet regionale, ma viene creato come singolo indirizzo IP /32 globale che non può sovrapporsi a subnet VPC, subnet VPC con peering o route ibride esistenti.

Da Cloud Shell

export pscgoogip=100.100.100.100

echo $pscgoogip

gcloud compute addresses create psc-goog-ep-ip \
    --global \
    --purpose=PRIVATE_SERVICE_CONNECT \
    --addresses=$pscgoogip \
    --network=consumer-vpc

Da Cloud Shell

gcloud compute forwarding-rules create psc4googapi \
    --global \
    --network=consumer-vpc \
    --address=psc-goog-ep-ip \
    --target-google-apis-bundle=all-apis

16. Crea una zona privata di Cloud DNS per run.app

Quando viene creato un endpoint PSC per le API di Google, viene creata una zona DNS privata Cloud Run per tutte le API che rientrano nel dominio googleapis.com. Poiché Cloud Run utilizza run.app, dobbiamo creare un'altra zona privata per mappare run.app al nostro PSC per l'endpoint delle API di Google.

Da Cloud Shell

gcloud dns managed-zones create "cloudrun" \
    --dns-name=run.app \
    --description="run.app psc resolution" \
    --visibility=private \
    --networks=consumer-vpc

gcloud dns record-sets transaction start \
   --zone="cloudrun"

gcloud dns record-sets transaction add $pscgoogip \
   --name=*.run.app \
   --ttl=300 \
   --type=A \
   --zone="cloudrun"

gcloud dns record-sets transaction execute \
   --zone="cloudrun"

17. Testare la risoluzione DNS privato

Accediamo di nuovo alla VM client consumer ed eseguiamo di nuovo dig. Ora dovremmo vedere che il nostro URL Cloud Run verrà risolto nel nostro endpoint PSC per le API di Google.

Da Cloud Shell

gcloud compute ssh \
    --zone "$zone" "consumer-client" \
    --tunnel-through-iap \
    --project $projectid

Per prima cosa, svuoteremo la cache DNS. Sostituisci <Cloud-Run-ServiceURL> con l'URL del servizio annotato in precedenza.

Dalla VM client consumer

sudo resolvectl flush-caches

curl <CloudRun-Loop-ServiceURL>

Il ricciolo dovrebbe funzionare come in precedenza.

Dalla VM client consumer

curl <CloudRun-Loop-ServiceURL>

Risultato previsto

Hello World!

Dalla VM client consumer

dig <CloudRun-Loop-ServiceURL>

Il comando dig dovrebbe mostrare che il nostro servizio Cloud Run Loop ora viene risolto nel nostro endpoint PSC per le API di Google.

Esempio di output

; <<>> DiG 9.18.33-1~deb12u2-Debian <<>> https://cloudrun-loop-<projectnum>.<region>.run.app
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 30179
;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 65494
;; QUESTION SECTION:
;https://cloudrun-loop-<projectnum>.<region>.run.app.        IN A

;; ANSWER SECTION:
https://cloudrun-loop-<projectnum>.<region>.run.app. 300 IN A 100.100.100.100

;; Query time: 8 msec
;; SERVER: 127.0.0.53#53(127.0.0.53) (UDP)
;; WHEN: Tue Mar 11 20:04:05 UTC 2025
;; MSG SIZE  rcvd: 99

OPERAZIONE RIUSCITA.

18. Procedura di pulizia

Esci dall'istanza VM

exit

Da Cloud Shell

gcloud dns record-sets delete *.run.app --zone="cloudrun" --type=A -q

gcloud dns managed-zones delete "cloudrun" -q

gcloud compute instances delete consumer-client --zone=$zone --project=$projectid -q

gcloud compute forwarding-rules delete psc4googapi --global -q

gcloud compute addresses delete psc-goog-ep-ip --global -q

gcloud run services delete cloudrun-loop --region=$region -q 

gcloud artifacts docker images delete $region-docker.pkg.dev/$projectid/cloud-run-source-deploy/cloudrun-loop -q

gcloud compute forwarding-rules delete cloudrun-ep --region=$region -q

gcloud compute addresses delete cloudrun-service-ip --region=$region -q

gcloud compute network-firewall-policies rules delete 1000 --firewall-policy consumer-vpc-policy --global-firewall-policy -q

gcloud compute network-firewall-policies associations delete --firewall-policy=consumer-vpc-policy  --name=network-consumer-vpc --global-firewall-policy -q

gcloud compute network-firewall-policies delete consumer-vpc-policy --global -q

gcloud compute routers nats delete central-nat --router=central-cr --region=$region -q

gcloud compute routers delete central-cr --region=$region -q

gcloud compute networks subnets delete consumer-subnet --region $region -q

È possibile che l'esecuzione dei due comandi successivi non vada a buon fine e vengano visualizzati errori di tipo "risorsa in uso". La documentazione di Cloud Run indica che a volte Cloud Run impiega da 1 a 2 ore per rilasciare le risorse di subnet dopo l'eliminazione del servizio Cloud Run. Se l'eliminazione non va a buon fine, salta questi due comandi e continua con la sezione successiva, poi torna a questa sezione per eliminare dopo un po' di tempo.

Da Cloud Shell

gcloud compute networks subnets delete cloudrun-egress --region $region -q

gcloud compute networks delete consumer-vpc -q

Da Cloud Shell

gcloud compute service-attachments delete cloudrun-attachment --region=$region -q

gcloud compute instances delete producer-client --zone=$zone --project=$projectid -q

gcloud compute forwarding-rules delete cloudrun-fr --region=$region -q

gcloud compute target-http-proxies delete producer-http-proxy --region=$region -q

gcloud compute url-maps delete producer-urlmap --region=$region -q

gcloud compute backend-services delete cloudrun-producer-bes --region=$region -q

gcloud compute network-endpoint-groups delete cloudrun-producer-neg --region=$region -q

gcloud compute addresses delete cloudrun-ip --region=$region -q

gcloud run services delete helloworld --region=$region -q 

gcloud artifacts docker images delete $region-docker.pkg.dev/$projectid/cloud-run-source-deploy/helloworld -q

gcloud artifacts repositories delete cloud-run-source-deploy --location=$region -q

gcloud compute network-firewall-policies rules delete 1000 --firewall-policy producer-vpc-policy --global-firewall-policy -q

gcloud compute network-firewall-policies associations delete --firewall-policy=producer-vpc-policy  --name=network-producer-vpc --global-firewall-policy -q

gcloud compute network-firewall-policies delete producer-vpc-policy --global -q

gcloud compute networks subnets delete lb-proxy-subnet --region $region -q

gcloud compute networks subnets delete psc-nat-subnet --region $region -q

gcloud compute networks subnets delete producer-subnet --region $region -q

gcloud compute networks delete producer-vpc -q

19. Complimenti!

Congratulazioni per aver completato il codelab.

Argomenti trattati

• Deployment di app di base su Cloud Run
• Controlli in entrata e in uscita di Cloud Run
• Deployment di Cloud Run tramite un bilanciatore del carico delle applicazioni interno con un NEG serverless
• Configurazione di un servizio producer PSC tramite un collegamento di servizio
• Deployment degli endpoint PSC