1. Introduzione
Private Service Connect (PSC) è una funzionalità della rete Google Cloud che consente ai consumer di accedere privatamente ai servizi gestiti dall'interno della loro rete VPC. Analogamente, 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 calcolo 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.
- Tramite PSC per le API Google chiamando Cloud Run tramite l'URL run.app fornito da Cloud Run
- Tramite un servizio di produzione PSC personalizzato in cui Cloud Run è esposto tramite un collegamento di servizio tramite un bilanciatore del carico delle applicazioni interno con un NEG serverless.
Questo codelab illustra come configurare Cloud Run con PSC per entrambi gli scenari
Cosa imparerai a fare
- Deployment di app di base su Cloud Run
- Controlli di rete in entrata e in uscita di Cloud Run
- Eseguire il 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
- Eseguire il 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 che saranno accessibili tramite PSC: il primo come servizio pubblicato personalizzato con PSC e il secondo come PSC per le API Google. Dovrai creare due VPC, consumer-vpc e producer-vpc. Per prima cosa, 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 nel VPC del produttore. Prima di configurare il servizio Cloud Run in modo che sia accessibile come servizio di produzione PSC tramite un allegato del servizio, dovrai verificare che il servizio funzioni tramite il bilanciatore del carico tramite il client di produzione.
Passando a consumer-vpc, esegui il deployment di un endpoint PSC che rimandi al collegamento del servizio Cloud Run che abbiamo configurato in producer-vpc. Poi verificherai che il servizio sia accessibile tramite PSC da un client consumer nella 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 Google.
3. Configurazione e requisiti
Configurazione dell'ambiente a tuo ritmo
- 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 al progetto. Si tratta di una stringa di caratteri non utilizzata dalle API di Google. Puoi sempre aggiornarlo.
- L'ID progetto è univoco per tutti i progetti Google Cloud ed è immutabile (non può essere modificato dopo essere stato impostato). La console Cloud genera automaticamente una stringa univoca; di solito non ti interessa quale sia. Nella maggior parte dei codelab, dovrai fare riferimento al tuo ID progetto (in genere identificato come
PROJECT_ID). Se l'ID generato non ti piace, puoi generarne un altro casuale. In alternativa, puoi provare il tuo e vedere se è disponibile. Non può essere modificato dopo questo passaggio e rimane invariato per tutta la durata del progetto. - Per tua informazione, esiste un terzo valore, un Numero progetto, utilizzato da alcune API. Scopri di più su tutti e tre questi valori nella documentazione.
- Successivamente, dovrai abilitare la fatturazione nella console Cloud per utilizzare le API/risorse Cloud. La partecipazione a questo codelab non ha costi, o quasi. Per arrestare le risorse ed evitare di incorrere in fatturazione al termine di questo tutorial, puoi eliminare le risorse che hai creato o il progetto. I nuovi utenti di Google Cloud sono idonei al programma Prova senza costi di 300$.
Avvia Cloud Shell
Sebbene Google Cloud possa essere utilizzato 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:
Dovrebbe richiedere solo pochi istanti per eseguire il provisioning e connettersi all'ambiente. Al termine, dovresti vedere qualcosa di simile a questo:
Questa macchina virtuale contiene tutti gli strumenti di sviluppo 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 di rete. Tutto il lavoro in questo codelab può essere svolto in 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
Attivare 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 la rete VPC del producer
Rete VPC
Da Cloud Shell
gcloud compute networks create producer-vpc --subnet-mode custom
Creare 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 del 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 ulteriori informazioni, consulta la documentazione relativa al dimensionamento delle sottoreti NAT PSC.
Creare la policy firewall di rete e le regole firewall del produttore
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 applica 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. Creare Hello World Cloud Run
Segui le istruzioni riportate qui per scrivere un'applicazione di esempio in Python. Esegui questi comandi in Cloud Shell. Dopo aver completato il passaggio 3 della sezione "Scrivere 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 l'account di servizio Compute predefinito disponga delle autorizzazioni appropriate eseguendo il seguente comando.
Da Cloud Shell
gcloud projects add-iam-policy-binding $projectid --member=serviceAccount:$projectnum-compute@developer.gserviceaccount.com --role=roles/run.builder
NOTA:questo codelab presuppone che nella tua organizzazione non sia attivato il criterio dell'organizzazione per la condivisione con restrizioni al dominio. Se hai attivato questo criterio, dovrai eseguire ulteriori passaggi per eseguire il deployment di Cloud Run con autenticazione, configurare una schermata di consenso OAuth e configurare l'IAP per il backend del bilanciatore del carico. È consigliabile 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. Esponi Cloud Run Hello World tramite un bilanciatore del carico delle applicazioni interno
Prenota un indirizzo IP interno statico per la regola di inoltro 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. Testa Hello World Cloud Run esposto tramite 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).
Eseguire il test di 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 prendi nota dell'URI del collegamento a un servizio per configurare l'endpoint PSC nell'ambiente consumer.
In Cloud Shell
gcloud compute service-attachments describe cloudrun-attachment --region=$region
Esempio di output previsto
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 la 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
Creare 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
Creare criteri e regole firewall per la rete di consumatori
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. Creare un endpoint PSC per il servizio Cloud Run Hello World
A questo punto, creeremo un endpoint PSC e lo collegheremo al servizio Cloud Run che hai esposto tramite il collegamento del servizio. Dovrai utilizzare 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.
Creare un 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 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"
Esempio di output previsto
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 client per i consumatori e testa la connettività all'endpoint
Crea la VM client per i consumatori
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'
Testa la 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. Creare un servizio Cloud Run Loop
Successivamente, creeremo un servizio Cloud Run che effettuerà una chiamata privata in consumer-vpc per chiamare il precedente servizio HelloWorld di Cloud Run che abbiamo esposto tramite PSC.
Segui le istruzioni "Scrivere l'applicazione di esempio" qui per scrivere un'applicazione con un ciclo in PHP. Invece di helloworld-php, assegna alla directory il nome cloudrun-loop. Esegui questi comandi in Cloud Shell. Nel secondo passaggio, 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;
}
?>
Stiamo specificando una rete e una subnet in questo deployment di Cloud Run perché il traffico di Cloud Run deve tornare nel VPC per accedere all'endpoint PSC. Stiamo indicando a Cloud Run di utilizzare la sottorete cloudrun-egress per il traffico in uscita VPC diretto. Stiamo indirizzando tutto il traffico in uscita tramite la subnet VPC diretto per il traffico in uscita 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 del servizio Cloud Run, verrà fornito un URL del servizio nel formato https://cloudrun-loop-<projectnum>.<region>.run.app. Tieni presente che verrà testato anche questo URL nel passaggio successivo.
14. Testa la connettività a CloudRun-Loop tramite l'URL 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 la VPC del consumatore per chiamare il nostro endpoint PSC collegato al nostro servizio Cloud Run Hello World. Tuttavia, a questo punto, la VM client consumer esce su internet tramite Cloud NAT per effettuare una chiamata al nostro URL pubblico di Cloud Run. Possiamo eseguire una ricerca sull'URL per dimostrare che risolverà 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 PSC per l'endpoint delle API di Google per impostare questa risoluzione su privata in modo da impedire il traffico sulla rete internet pubblica.
Dalla VM client consumer
exit
15. Creare un endpoint PSC per le API di Google
Questo endpoint PSC è diverso da quello che abbiamo creato in precedenza. PSC per le API di Google punta a un bundle di API di Google (tutte le API o API compatibili con VPC-SC). L'indirizzo IP non proviene da una subnet regionale, ma viene creato come un singolo indirizzo IP /32 globale che non può sovrapporsi a subnet VPC esistenti, subnet VPC con peering o route ibride.
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 Cloud DNS per run.app
Quando viene creato un endpoint PSC per le API di Google, viene creata una zona DNS privata di 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 endpoint PSC per le API 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
Accedi di nuovo alla VM client consumer ed esegui di nuovo il comando dig. Ora dovresti vedere che l'URL di Cloud Run risolverà nell'endpoint PSC per le API 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 comando curl dovrebbe funzionare come visto 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 risolve il nostro endpoint PSC per le API 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
Uscire 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 con errori di tipo "risorsa in uso". Le documentazioni di Cloud Run indicano che a volte Cloud Run impiega 1-2 ore per rilasciare le risorse della sottorete dopo l'eliminazione del servizio Cloud Run. Se l'eliminazione non va a buon fine, salta questi due comandi e vai alla sezione successiva, quindi torna a questa sezione per eseguire l'eliminazione 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!
Complimenti per aver completato il codelab.
Argomenti trattati
- Deployment di app di base su Cloud Run
- Controlli di rete in entrata e in uscita di Cloud Run
- Eseguire il 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
- Eseguire il deployment degli endpoint PSC