1. Introducción
Private Service Connect (PSC) es una función de las herramientas de redes de Google Cloud que permite a los consumidores acceder a los servicios administrados de forma privada desde su red de VPC. Del mismo modo, permite a los productores de servicios administrados alojar estos servicios en sus propias redes de VPC independientes y ofrecer una conexión privada a sus consumidores.
Cloud Run es una plataforma de procesamiento administrada que te permite ejecutar contenedores directamente sobre la infraestructura escalable de Google.
Cloud Run se puede consumir como un servicio de PSC de dos maneras diferentes.
- A través de PSC para las APIs de Google, llamando a Cloud Run a través de la URL de run.app que proporciona Cloud Run
- A través de un servicio de productor de PSC personalizado en el que Cloud Run se expone a través de un archivo adjunto de servicio mediante un balanceador de cargas de aplicaciones interno con un NEG sin servidores.
En este codelab, exploraremos cómo configurar Cloud Run con PSC para ambas situaciones.
Qué aprenderás
- Implementa apps básicas en Cloud Run
- Controles de entrada y salida de Cloud Run
- Implementa Cloud Run a través de un balanceador de cargas de aplicaciones interno con un NEG sin servidores
- Cómo configurar un servicio de productor de PSC a través de un adjunto de servicio
- Implementa extremos de PSC
Requisitos
- Proyecto de Google Cloud con permisos de propietario
2. Topología del codelab
En este codelab, implementarás dos servicios de Cloud Run a los que se podrá acceder a través de PSC: primero, como un servicio publicado personalizado con PSC y, segundo, como PSC para las APIs de Google. Crearás dos VPC, una VPC de consumidor y una VPC de productor. Primero, implementarás el servicio de Cloud Run de Hello World y le permitirás el acceso a través de un balanceador de cargas de aplicaciones interno regional y un NEG sin servidores en producer-vpc. Verificarás que el servicio funcione a través del balanceador de cargas mediante el cliente productor antes de configurar el servicio de Cloud Run para que se pueda acceder a él como servicio de productor de PSC a través de un archivo adjunto de servicio.
En la VPC de consumidor, implementarás un extremo de PSC que apunte al adjunto de servicio de Cloud Run que configuramos en la VPC de productor. Luego, verificarás que se pueda acceder al servicio a través de PSC desde un cliente consumidor en el VPC de consumidor. A continuación, crearás otro servicio de Cloud Run que llame a tu extremo de PSC. Por último, implementarás un extremo de PSC para las APIs de Google. Desde el cliente consumidor, accederás a Cloud Run a través de la URL proporcionada por Cloud Run, que usará el PSC para el extremo de las APIs de Google.
3. Configuración y requisitos
Configuración del entorno de autoaprendizaje
- Accede a Google Cloud Console y crea un proyecto nuevo o reutiliza uno existente. Si aún no tienes una cuenta de Gmail o de Google Workspace, debes crear una.
- El Nombre del proyecto es el nombre visible de los participantes de este proyecto. Es una cadena de caracteres que no se utiliza en las APIs de Google. Puedes actualizarla cuando quieras.
- El ID del proyecto es único en todos los proyectos de Google Cloud y es inmutable (no se puede cambiar después de configurarlo). La consola de Cloud genera automáticamente una cadena única. Por lo general, no importa cuál sea. En la mayoría de los codelabs, deberás hacer referencia al ID de tu proyecto (suele identificarse como
PROJECT_ID). Si no te gusta el ID que se generó, podrías generar otro aleatorio. También puedes probar uno propio y ver si está disponible. No se puede cambiar después de este paso y se usa el mismo durante todo el proyecto. - Recuerda que hay un tercer valor, un número de proyecto, que usan algunas APIs. Obtén más información sobre estos tres valores en la documentación.
- A continuación, deberás habilitar la facturación en la consola de Cloud para usar las APIs o los recursos de Cloud. Ejecutar este codelab no costará mucho, tal vez nada. Para cerrar recursos y evitar que se generen cobros más allá de este instructivo, puedes borrar los recursos que creaste o borrar el proyecto. Los usuarios nuevos de Google Cloud son aptos para participar en el programa Prueba gratuita de $300.
Inicia Cloud Shell
Si bien Google Cloud y Spanner se pueden operar de manera remota desde tu laptop, en este codelab usarás Google Cloud Shell, un entorno de línea de comandos que se ejecuta en la nube.
En Google Cloud Console, haz clic en el ícono de Cloud Shell en la barra de herramientas en la parte superior derecha:
El aprovisionamiento y la conexión al entorno deberían tomar solo unos minutos. Cuando termine el proceso, debería ver algo como lo siguiente:
Esta máquina virtual está cargada con todas las herramientas de desarrollo que necesitarás. Ofrece un directorio principal persistente de 5 GB y se ejecuta en Google Cloud, lo que permite mejorar considerablemente el rendimiento de la red y la autenticación. Todo tu trabajo en este codelab se puede hacer en un navegador. No es necesario que instales nada.
4. Antes de comenzar
Habilita las APIs
En Cloud Shell, asegúrate de que tu proyecto esté configurado y configura las variables.
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
Habilita todos los servicios necesarios
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 una red de VPC del productor
Red de VPC
Desde Cloud Shell
gcloud compute networks create producer-vpc --subnet-mode custom
Crea subredes
Desde 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 subred de PSC se asociará con el adjunto de servicio de PSC para la traducción de direcciones de red. En el caso de los casos de uso de producción, el tamaño de esta subred debe ser adecuado para admitir la cantidad de extremos conectados. Consulta la documentación sobre el tamaño de subred de NAT de PSC para obtener más información.
Crea una política de firewall de red y reglas de firewall del productor
Desde 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
Para permitir que IAP se conecte a tus instancias de VM, crea una regla de firewall que cumpla con lo siguiente:
- Se aplica a todas las instancias de VM a las que deseas acceder mediante IAP.
- Permite el tráfico de entrada desde el rango de IP 35.235.240.0/20. Este rango contiene todas las direcciones IP que IAP usa para el reenvío de TCP.
Desde 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 de Cloud Run
Sigue las instrucciones que se indican aquí para escribir una aplicación de ejemplo en Python. Ejecuta estos comandos en Cloud Shell. Después de completar el paso 3 de "Escribe la aplicación de ejemplo", vuelve a este codelab y sigue las instrucciones que se indican a continuación para implementar en Cloud Run desde la fuente.
Antes de implementar tu servicio de Cloud Run, ejecuta el siguiente comando para asegurarte de que tu cuenta de servicio de Compute predeterminada tenga los permisos adecuados.
Desde Cloud Shell
gcloud projects add-iam-policy-binding $projectid --member=serviceAccount:$projectnum-compute@developer.gserviceaccount.com --role=roles/run.builder
NOTA: En este codelab, se supone que tu organización no tiene habilitada la política de la organización de uso compartido de dominio restringido. Si tienes habilitada esta política, deberás realizar pasos adicionales para implementar Cloud Run con autenticación, configurar una pantalla de consentimiento de OAuth y configurar IAP para el backend de tu balanceador de cargas. Se recomienda que se sigan todos estos pasos de configuración en un entorno de producción.
Desde Cloud Shell
gcloud beta run deploy helloworld \
--source . \
--platform=managed \
--ingress=internal \
--allow-unauthenticated \
--no-default-url \
--region=$region
Si usas la marca --no-default-url, se implementará tu servicio de Cloud Run sin la URL run.app proporcionada. No usaremos la URL para este servicio. En el momento de la publicación de este codelab, esta función aún se encuentra en versión preliminar.
Antes de continuar, vuelve al directorio principal de Cloud Shell.
Desde Cloud Shell
cd ..
7. Expone Hello World Cloud Run a través de un balanceador de cargas de aplicaciones interno
Reserva una dirección IP interna estática para la regla de reenvío del balanceador de cargas.
En Cloud Shell, haga lo siguiente:
gcloud compute addresses create cloudrun-ip \ --region=$region \ --subnet=producer-subnet gcloud compute addresses describe cloudrun-ip --region=$region
Resultado de muestra
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
Anota la dirección IP que acabas de crear.
Crea el balanceador de cargas de aplicaciones interno regional
En Cloud Shell, haga lo siguiente:
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
En Cloud Shell, haga lo siguiente:
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. Prueba Hello World de Cloud Run expuesto a través de un balanceador de cargas
Crea una VM de prueba
Desde Cloud Shell
gcloud compute instances create producer-client \
--zone=$zone \
--subnet=producer-subnet \
--no-address \
--scopes=cloud-platform
En Cloud Shell, haga lo siguiente:
gcloud compute ssh \
--zone "$zone" "producer-client" \
--tunnel-through-iap \
--project $projectid
Reemplaza <loadbalancer-ip> por la dirección IP que creaste antes (por ejemplo, 10.0.0.2).
Prueba Hello World
En producer-vm
curl <loadbalancer-ip>
Resultado esperado
Hello World!
Sal de la VM.
En producer-vm
exit
9. Crea un archivo adjunto de servicio
Desde 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
A continuación, recupera y toma nota del URI del adjunto de servicio para configurar el extremo de PSC en el entorno del consumidor.
En Cloud Shell, haga lo siguiente:
gcloud compute service-attachments describe cloudrun-attachment --region=$region
Ejemplo de resultado esperado
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 una red de VPC de consumidor
Red de VPC
Desde Cloud Shell
gcloud compute networks create consumer-vpc --subnet-mode custom
Crear subred
Desde 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
Cómo crear Cloud NAT
Desde 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
Cómo crear una política de firewall y reglas de firewall de red para consumidores
Crearemos otra política de firewall de red para consumer-vpc.
Desde 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 un extremo de PSC para el servicio de Cloud Run de Hello World
En este punto, crearemos un extremo de PSC y lo conectaremos al servicio de Cloud Run que expusiste a través del adjunto de servicio. Usarás el URI del archivo adjunto de servicio que anotaste antes en esta sección. Asegúrate de que el formato del URI en el comando gcloud coincida con el tuyo.
Crea un extremo de PSC
Desde 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
Obtén la dirección IP del extremo de PSC que acabas de crear. Usarás la dirección IP en el siguiente paso para probar el extremo.
Desde Cloud Shell
gcloud compute addresses list --filter="name=cloudrun-service-ip"
Ejemplo de resultado esperado
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 una VM de cliente consumidor y prueba la conectividad con el extremo
Cómo crear una VM de cliente consumidor
Desde 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'
Cómo probar la conectividad
Desde Cloud Shell
gcloud compute ssh \
--zone "$zone" "consumer-client" \
--tunnel-through-iap \
--project $projectid
Reemplaza <cloudrun-service-ip> por la dirección IP real.
Desde la VM cliente de consumidor
curl <cloudrun-service-ip>
Resultado esperado
Hello World!
Desde la VM cliente de consumidor
exit
13. Crea un servicio de Cloud Run Loop
A continuación, crearemos un servicio de Cloud Run que realizará una devolución de llamada privada a consumer-vpc para llamar al servicio HelloWorld de Cloud Run anterior que expusimos a través de PSC.
Sigue las instrucciones para "escribir la aplicación de ejemplo" aquí para escribir una aplicación de bucle en PHP. En lugar de helloworld-php, asigna el nombre cloudrun-loop a tu directorio. Ejecuta estos comandos en Cloud Shell. En el paso dos, usa el siguiente código PHP en tu archivo index.php. Vuelve al codelab cuando esté todo listo para la implementación en Cloud Run. No sigas las instrucciones de la documentación para este paso.
Usa este código para tu archivo index.php. Reemplaza <cloudrun-service-ip> por la dirección IP de tu extremo de PSC que probaste en el paso anterior.
Desde 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;
}
?>
Especificamos una red y una subred en esta implementación de Cloud Run porque el tráfico de Cloud Run debe salir nuevamente a la VPC para acceder al extremo de PSC. Le indicamos a Cloud Run que use la subred cloudrun-egress para la salida de VPC directa. Dirigimos todo el tráfico a salir a través de la subred de salida directa de VPC y volver a la VPC.
Desde 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
Cuando el servicio de Cloud Run termine de implementarse, proporcionará una URL del servicio en el formato https://cloudrun-loop-<projectnum>.<region>.run.app. Anota esta URL, ya que la probarás en el siguiente paso.
14. Prueba la conectividad a CloudRun-Loop a través de la URL de Cloud Run
Desde Cloud Shell
gcloud compute ssh \
--zone "$zone" "consumer-client" \
--tunnel-through-iap \
--project $projectid
Reemplaza <Cloud-Run-ServiceURL> por la URL del servicio que anotaste en el paso anterior.
Desde la VM cliente de consumidor
curl <Cloud-Run-ServiceURL>
Resultado esperado
Hello World!
Este resultado muestra que nuestro servicio de CloudRun-Loop vuelve a llamar correctamente a consumer-vpc para llamar a nuestro extremo de PSC conectado a nuestro servicio de Cloud Run de Hello World. Sin embargo, en este punto, nuestra VM de cliente consumidor sale a Internet a través de nuestra Cloud NAT para realizar una llamada a nuestra URL pública de Cloud Run. Podemos ejecutar un comando dig en la URL para mostrar que se resolverá en una dirección IP pública.
Desde la VM cliente de consumidor
dig <Cloud-Run-ServiceURL>
Resultado de muestra
; <<>> 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
Podemos crear un PSC para el extremo de las APIs de Google para cambiar esta resolución a privada y mantener el tráfico fuera de la Internet pública.
Desde la VM cliente de consumidor
exit
15. Crea un PSC para el extremo de las APIs de Google
Este extremo de PSC es diferente del que creamos anteriormente. PSC para las APIs de Google apunta a un paquete de APIs de Google (todas las APIs o las APIs compatibles con VPC-SC). La dirección IP no proviene de una subred regional, sino que se crea como una sola dirección IP /32 que es global y que no puede superponerse con ninguna subred de VPC existente, subred de VPC con intercambio de tráfico ni ruta híbrida.
Desde 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
Desde 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 privada de Cloud DNS para run.app
Cuando se crea un extremo de PSC para las APIs de Google, se crea una zona DNS privada de Cloud Run para todas las APIs que se encuentran en el dominio googleapis.com. Dado que Cloud Run usa run.app, tendremos que crear otra zona privada para asignar run.app a nuestro extremo de PSC para las APIs de Google.
Desde 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. Prueba la resolución de DNS privado
Volveremos a acceder a nuestra VM de cliente consumidor y volveremos a ejecutar dig. Ahora, deberíamos ver que nuestra URL de Cloud Run se resolverá en nuestro PSC para el extremo de las APIs de Google.
Desde Cloud Shell
gcloud compute ssh \
--zone "$zone" "consumer-client" \
--tunnel-through-iap \
--project $projectid
Primero, borraremos la caché de DNS. Reemplaza <Cloud-Run-ServiceURL> por la URL de servicio que anotaste antes.
Desde la VM cliente de consumidor
sudo resolvectl flush-caches curl <CloudRun-Loop-ServiceURL>
El curl debería seguir funcionando como se vio anteriormente.
Desde la VM cliente de consumidor
curl <CloudRun-Loop-ServiceURL>
Resultado esperado
Hello World!
Desde la VM cliente de consumidor
dig <CloudRun-Loop-ServiceURL>
El comando dig debería mostrar que nuestro servicio de Cloud Run Loop ahora se resuelve en nuestro extremo de PSC para las APIs de Google.
Resultado de muestra
; <<>> 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
Operación exitosa
18. Pasos de limpieza
Sal de la instancia de VM
exit
Desde 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
Es posible que ejecutar los siguientes dos comandos falle con errores de "recurso en uso". En los documentos de Cloud Run, se indica que, a veces, Cloud Run tarda entre 1 y 2 horas en liberar los recursos de subred después de que se borra el servicio de Cloud Run. Si la eliminación falla, omite estos dos comandos y continúa con la siguiente sección. Luego, vuelve a esta sección para borrarla después de un tiempo.
Desde Cloud Shell
gcloud compute networks subnets delete cloudrun-egress --region $region -q gcloud compute networks delete consumer-vpc -q
Desde 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. ¡Felicitaciones!
Felicitaciones por completar el codelab.
Temas abordados
- Implementa apps básicas en Cloud Run
- Controles de entrada y salida de Cloud Run
- Implementa Cloud Run a través de un balanceador de cargas de aplicaciones interno con un NEG sin servidores
- Cómo configurar un servicio de productor de PSC a través de un adjunto de servicio
- Implementa extremos de PSC