Private Service Connect: como usar o Private Service Connect para publicar e consumir serviços com o Cloud Run

1. Introdução

O Private Service Connect (PSC) é um recurso da rede do Google Cloud que permite que os consumidores acessem serviços gerenciados de maneira particular na rede VPC deles. Da mesma forma, ele permite que produtores de serviços gerenciados hospedem esses serviços em redes VPC separadas e ofereçam uma conexão particular aos consumidores.

O Cloud Run é uma plataforma de computação gerenciada para rodar contêineres diretamente na infraestrutura escalonável do Google.

O Cloud Run pode ser consumido como um serviço do PSC de duas maneiras diferentes.

1. Usando o PSC para APIs do Google ao chamar o Cloud Run pelo URL run.app fornecido pelo Cloud Run
2. Por um serviço de produtor do PSC personalizado em que o Cloud Run é exposto por um anexo de serviço via um balanceador de carga de aplicativo interno com um NEG sem servidor.

Neste codelab, vamos mostrar como configurar o Cloud Run com PSC para esses dois cenários.

O que você vai aprender

• Como implantar apps básicos no Cloud Run
• Controles de entrada e saída do Cloud Run
• Como implantar o Cloud Run usando um balanceador de carga de aplicativo interno com um NEG sem servidor
• Configurar um serviço de produtor do PSC usando um anexo de serviço
• Como implantar endpoints do PSC

O que é necessário

• Projeto do Google Cloud com permissões de proprietário

2. Topologia do codelab

Neste codelab, você vai implantar dois serviços do Cloud Run que poderão ser acessados via PSC. Primeiro, como um serviço publicado personalizado com PSC e, segundo, como PSC para APIs do Google. Você vai criar duas VPCs, uma consumer-vpc e uma producer-vpc. Primeiro, você vai implantar o serviço Hello World do Cloud Run e torná-lo acessível por um balanceador de carga de aplicativo interno regional e um NEG sem servidor na VPC do produtor. Você vai verificar se o serviço está funcionando pelo balanceador de carga via produtor-cliente antes de configurar o serviço do Cloud Run para ser acessível como um serviço produtor do PSC por um anexo de serviço.

Passando para a consumer-vpc, você vai implantar um endpoint do PSC apontando para o anexo de serviço do Cloud Run que configuramos na producer-vpc. Em seguida, você vai verificar se o serviço está acessível via PSC de um cliente consumidor na VPC do consumidor. Em seguida, você vai criar outro serviço do Cloud Run que chama seu endpoint do PSC. Por fim, você vai implantar um endpoint do PSC para APIs do Google. No consumer-client, você vai acessar o Cloud Run usando o URL fornecido pelo Cloud Run, que vai usar o endpoint do PSC para APIs do Google.

3. Configuração e requisitos

Configuração de ambiente autoguiada

1. Faça login no Console do Google Cloud e crie um novo projeto ou reutilize um existente. Crie uma conta do Gmail ou do Google Workspace, se ainda não tiver uma.

• O Nome do projeto é o nome de exibição para os participantes do projeto. É uma string de caracteres não usada pelas APIs do Google e pode ser atualizada quando você quiser.
• O ID do projeto precisa ser exclusivo em todos os projetos do Google Cloud e não pode ser mudado após a definição. O console do Cloud gera automaticamente uma string exclusiva. Em geral, não importa o que seja. Na maioria dos codelabs, é necessário fazer referência ao ID do projeto, normalmente identificado como PROJECT_ID. Se você não gostar do ID gerado, crie outro aleatório. Se preferir, teste o seu e confira se ele está disponível. Ele não pode ser mudado após essa etapa e permanece durante o projeto.
• Para sua informação, há um terceiro valor, um Número do projeto, que algumas APIs usam. Saiba mais sobre esses três valores na documentação.

Atenção: o ID do projeto é globalmente exclusivo e não pode ser usado por outras pessoas após a seleção. Você é o único usuário com esse ID. Mesmo que um projeto seja excluído, o ID não poderá ser usado novamente.

Observação: se você usa uma conta do Gmail, defina o local padrão como Sem organização. Se você usa uma conta do Google Workspace, escolha um local adequado para a organização.

2. Em seguida, ative o faturamento no console do Cloud para usar os recursos/APIs do Cloud. A execução deste codelab não vai ser muito cara, se tiver algum custo. Para encerrar os recursos e evitar cobranças além deste tutorial, exclua os recursos criados ou exclua o projeto. Novos usuários do Google Cloud estão qualificados para o programa de US$ 300 de avaliação sem custos.

Inicie o Cloud Shell

Embora o Google Cloud e o Spanner possam ser operados remotamente do seu laptop, neste codelab usaremos o Google Cloud Shell, um ambiente de linha de comando executado no Cloud.

No Console do Google Cloud, clique no ícone do Cloud Shell na barra de ferramentas superior à direita:

O provisionamento e a conexão com o ambiente levarão apenas alguns instantes para serem concluídos: Quando o processamento for concluído, você verá algo como:

Essa máquina virtual contém todas as ferramentas de desenvolvimento necessárias. Ela oferece um diretório principal persistente de 5 GB, além de ser executada no Google Cloud. Isso aprimora o desempenho e a autenticação da rede. Neste codelab, todo o trabalho pode ser feito com um navegador. Você não precisa instalar nada.

4. Antes de começar

Ativar APIs

No Cloud Shell, verifique se o projeto está configurado e configure as variáveis.

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

Ative todos os serviços necessários

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. Criar rede VPC do produtor

Rede VPC

No Cloud Shell

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

Criar sub-redes

No 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

A sub-rede do PSC será associada ao anexo de serviço do PSC para fins de conversão de endereços de rede. Para casos de uso de produção, essa sub-rede precisa ter o tamanho adequado para oferecer suporte ao número de endpoints conectados. Consulte a documentação sobre dimensionamento de sub-rede NAT do PSC para mais informações.

Criar política de firewall de rede e regras de firewall do produtor

No 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 o IAP se conecte às suas instâncias de VM, crie uma regra de firewall que:

• Aplica-se a todas as instâncias de VM que você quer acessar usando o IAP.
• Permite o tráfego de entrada do intervalo de IP 35.235.240.0/20. Esse intervalo contém todos os endereços IP que o IAP usa para o encaminhamento de TCP.

No 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. Criar Hello World do Cloud Run

Siga as instruções aqui para escrever um aplicativo de exemplo em Python. Execute estes comandos no Cloud Shell. Depois de concluir a etapa 3 em "Escrever o aplicativo de amostra", volte a este codelab e siga as instruções abaixo para implantar no Cloud Run a partir da origem.

Antes de implantar o serviço do Cloud Run, execute o comando a seguir para garantir que a conta de serviço de computação padrão tenha as permissões adequadas.

No Cloud Shell

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

OBSERVAÇÃO:este codelab pressupõe que sua organização não tem a política de organização de compartilhamento restrito de domínio ativada. Se essa política estiver ativada, você precisará realizar etapas extras para implantar o Cloud Run com autenticação, configurar uma tela de permissão OAuth e configurar o IAP para o back-end do balanceador de carga. Recomendamos que todas essas etapas de configuração sejam seguidas em um ambiente de produção.

No Cloud Shell

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

Usar a flag --no-default-url vai implantar o serviço do Cloud Run sem o URL run.app fornecido. Não vamos usar o URL para esse serviço. No momento da publicação deste codelab, esse recurso ainda está em pré-lançamento.

Antes de continuar, volte para o diretório principal do Cloud Shell.

No Cloud Shell

cd ..

7. Expor o Hello World do Cloud Run usando um balanceador de carga de aplicativo interno

Reserve um endereço IP interno estático para a regra de encaminhamento do balanceador de carga.

No Cloud Shell, faça o seguinte:

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

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

Exemplo de saída

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

Anote o endereço IP que você acabou de criar.

Criar o balanceador de carga de aplicativo interno regional

No Cloud Shell, faça o seguinte:

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

No Cloud Shell, faça o seguinte:

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. Testar o Hello World do Cloud Run exposto pelo balanceador de carga

Criar VM de teste

No Cloud Shell

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

No Cloud Shell, faça o seguinte:

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

Substitua <loadbalancer-ip> pelo endereço IP que você criou antes (por exemplo, 10.0.0.2).

Testar o Hello World

Em producer-vm

curl <loadbalancer-ip>

Resposta esperada

Hello World!

Saia da VM.

Em producer-vm

exit

9. Criar anexo de serviço

No 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

Em seguida, recupere e anote o URI do anexo de serviço para configurar o endpoint do PSC no ambiente do consumidor.

No Cloud Shell, faça o seguinte:

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

Exemplo de resposta esperada

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. Criar rede VPC do consumidor

Rede VPC

No Cloud Shell

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

Criar sub-rede

No 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

Criar o Cloud NAT

No 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

Criar uma política de firewall de rede do consumidor e regras de firewall

Vamos criar outra política de firewall de rede para a VPC do consumidor.

No 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. Criar um endpoint do PSC para o serviço Hello World do Cloud Run

Neste ponto, vamos criar um endpoint do PSC e conectá-lo ao serviço do Cloud Run exposto pelo anexo de serviço. Você vai usar o URI do anexo de serviço que anotou anteriormente nesta seção. Verifique se o formato do URI no comando gcloud corresponde ao seu URI.

Criar endpoint do PSC

No 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

Consiga o endereço IP do endpoint do PSC que você acabou de criar. Você vai usar o endereço IP na próxima etapa para testar o endpoint.

No Cloud Shell

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

Exemplo de resposta esperada

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. Criar uma VM cliente do consumidor e testar a conectividade com o endpoint

Criar VM de cliente consumidor

No 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'

Testar a conectividade

No Cloud Shell

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

Substitua <cloudrun-service-ip> pelo endereço IP real.

Da VM cliente do consumidor

curl <cloudrun-service-ip>

Resposta esperada

Hello World!

Da VM cliente do consumidor

exit

13. Criar serviço de loop do Cloud Run

Em seguida, vamos criar um serviço do Cloud Run que fará uma chamada particular de volta para a VPC do consumidor para chamar o serviço anterior do Cloud Run HelloWorld que expusemos pelo PSC.

Siga as instruções em "Escrever o aplicativo de exemplo" aqui para escrever um aplicativo de loop em PHP. Em vez de helloworld-php, nomeie o diretório como cloudrun-loop. Execute estes comandos no Cloud Shell. Na etapa dois, use o código PHP abaixo no arquivo index.php. Volte ao codelab quando estiver pronto para implantar no Cloud Run. Não siga as instruções na documentação para esta etapa.

Use este código para o arquivo index.php. Substitua <cloudrun-service-ip> pelo endereço IP do endpoint do PSC que você testou na etapa anterior.

No 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;
}
?>

Estamos especificando uma rede e uma sub-rede nesta implantação do Cloud Run porque o tráfego do Cloud Run precisa sair de volta para a VPC para acessar o endpoint do PSC. Estamos direcionando o Cloud Run para usar a sub-rede cloudrun-egress para a saída direta da VPC. Estamos direcionando todo o tráfego para sair pela sub-rede de saída direta da VPC e voltar para a VPC.

No 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

Quando o serviço do Cloud Run terminar a implantação, ele vai fornecer um URL de serviço no formato https://cloudrun-loop-<projectnum>.<region>.run.app. Anote esse URL, porque ele será testado na próxima etapa.

14. Testar a conectividade com o Cloud Run: loop pelo URL do Cloud Run

No Cloud Shell

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

Substitua <Cloud-Run-ServiceURL> pelo URL do serviço que você anotou na etapa anterior.

Da VM cliente do consumidor

curl <Cloud-Run-ServiceURL>

Resposta esperada

Hello World!

Esse resultado mostra que nosso serviço CloudRun-Loop está chamando de volta a VPC do consumidor para chamar nosso endpoint do PSC conectado ao serviço Hello World do Cloud Run. No entanto, neste ponto, nossa VM cliente-consumidor está saindo para a Internet pelo Cloud NAT para fazer uma chamada para nosso URL público do Cloud Run. Podemos executar um dig no URL para mostrar que ele será resolvido em um endereço IP público.

Da VM cliente do consumidor

dig <Cloud-Run-ServiceURL>

Exemplo de saída

; <<>> 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 criar um endpoint do PSC para APIs do Google e mudar essa resolução para particular, mantendo o tráfego fora da Internet pública.

Da VM cliente do consumidor

exit

15. Criar um PSC para o endpoint das APIs do Google

Esse endpoint do PSC é diferente do que criamos anteriormente. O PSC para APIs do Google aponta para um pacote de APIs do Google (todas as APIs ou APIs compatíveis com o VPC-SC). O endereço IP não é originado de uma sub-rede regional, mas é criado como um único endereço IP /32 global que não pode se sobrepor a nenhuma sub-rede VPC, sub-rede VPC com peering ou rota híbrida.

No 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

No Cloud Shell

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

16. Criar uma zona particular do Cloud DNS para run.app

Quando um endpoint do PSC para APIs do Google é criado, uma zona de DNS particular do Cloud Run é criada para todas as APIs que se enquadram no domínio googleapis.com. Como o Cloud Run usa run.app, precisamos criar outra zona particular para mapear run.app para nosso endpoint do PSC para APIs do Google.

No 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. Testar a resolução de DNS particular

Vamos fazer login novamente na VM do cliente consumidor e executar o dig novamente. Agora, o URL do Cloud Run será resolvido para o endpoint do PSC para APIs do Google.

No Cloud Shell

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

Primeiro, vamos limpar o cache de DNS. Substitua <Cloud-Run-ServiceURL> pelo URL do serviço que você anotou anteriormente.

Da VM cliente do consumidor

sudo resolvectl flush-caches

curl <CloudRun-Loop-ServiceURL>

O curl ainda vai funcionar como antes.

Da VM cliente do consumidor

curl <CloudRun-Loop-ServiceURL>

Resposta esperada

Hello World!

Da VM cliente do consumidor

dig <CloudRun-Loop-ServiceURL>

O dig vai mostrar que nosso serviço de loop do Cloud Run agora está resolvendo para nosso endpoint do PSC para APIs do Google.

Exemplo de saída

; <<>> 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

SUCCESS!

18. Etapas de limpeza

Sair da instância de VM

exit

No 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

É possível que a execução dos dois comandos a seguir falhe com erros de "recurso em uso". A documentação do Cloud Run informa que, às vezes, o Cloud Run leva de uma a duas horas para liberar os recursos da sub-rede depois que o serviço do Cloud Run é excluído. Se a exclusão falhar, pule esses dois comandos e continue para a próxima seção. Depois, volte para esta seção e exclua os dados.

No Cloud Shell

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

gcloud compute networks delete consumer-vpc -q

No 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. Parabéns!

Parabéns por concluir o codelab.

O que vimos

• Como implantar apps básicos no Cloud Run
• Controles de entrada e saída do Cloud Run
• Como implantar o Cloud Run usando um balanceador de carga de aplicativo interno com um NEG sem servidor
• Configurar um serviço de produtor do PSC usando um anexo de serviço
• Como implantar endpoints do PSC