1. Introdução
O Private Service Connect é um recurso da rede do Google Cloud que permite que consumidores acessem serviços de produtores. Isso inclui a capacidade de se conectar às APIs do Google por um endpoint particular hospedado na VPC do usuário(normalmente consumidor).
Além disso, os back-ends do PSC podem ser usados com balanceadores de carga de proxy do Google Cloud para apontar para APIs específicas da região. O uso de back-ends do PSC oferece controles mais granulares do lado do consumidor, como:
- Como escolher quais serviços da API Google estão disponíveis usando um mapa de URL
- Observabilidade mais detalhada
- Integração do Cloud Armor
- URLs personalizados
- Gerenciamento de tráfego avançado
A lista de serviços disponíveis e as APIs regionais podem ser encontradas aqui.
Neste codelab, você vai criar um back-end de PSC que aponta para a API regional do Cloud KMS e testar a conectividade com essa API.
O que você vai aprender
- Crie um keyring e uma chave do Cloud Key Management Service (KMS).
- Criar um balanceador de carga de aplicativo interno com um back-end PSC que aponta para uma API regional do Cloud KMS
- Criação de uma zona particular gerenciada do Cloud DNS e um registro A.
- Acessar o Cloud KMS regional
O que é necessário
- Um projeto do Google Cloud com permissões de "Proprietário" ou "Editor".
2. Topologia do codelab
Uma VPC de consumidor será criada com uma sub-rede na região europe-west9 para hospedar uma VM, a regra de encaminhamento do balanceador de carga de aplicativo regional interno, o back-end do PSC e uma sub-rede somente proxy para uso com o balanceador de carga. Vamos criar um keyring e uma chave no sistema de gerenciamento de chaves (KMS, na sigla em inglês) do Cloud na região europe-west. Em seguida, vamos criar o balanceador de carga e o back-end do PSC para resolver a API KMS regional em europe-west9.
3. Configuração e requisitos
Configuração de ambiente autoguiada
- 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.
- 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 ID do projeto está configurado:
gcloud config list project gcloud config set project <project-id> export PROJECT_ID=$(gcloud config get-value project) export REGION=europe-west9 export ZONE=europe-west9-a echo $PROJECT_ID echo $REGION echo $ZONE
Ativar todos os serviços necessários
gcloud services enable compute.googleapis.com gcloud services enable servicedirectory.googleapis.com gcloud services enable dns.googleapis.com gcloud services enable cloudkms.googleapis.com
5. Criar rede VPC, sub-redes e regras de firewall
Criar rede VPC
No Cloud Shell
# Set environment variables
export VPC_NAME="consumer-vpc"
export SUBNET_NAME="consumer-subnet-1"
# Create VPC network
gcloud compute networks create ${VPC_NAME} \
--subnet-mode=custom \
--bgp-routing-mode=regional
Criar sub-redes
No Cloud Shell
gcloud compute networks subnets create ${SUBNET_NAME} \
--network=${VPC_NAME} \
--region=${REGION} \
--range=10.0.0.0/24 \
--enable-private-ip-google-access
Neste laboratório, você vai criar um balanceador de carga regional L7 interno para apontar para back-ends de API regionais. Esse balanceador de carga é um balanceador de proxy, portanto, você precisa criar uma "sub-rede de proxy" dedicada ao balanceador de carga para executar o proxy. Confira mais informações sobre a sub-rede somente proxy neste link.
No Cloud Shell
gcloud compute networks subnets create eu-west9-proxy-subnet \
--network=${VPC_NAME} \
--region=${REGION} \
--range=10.100.100.0/24 \
--purpose=REGIONAL_MANAGED_PROXY \
--role=ACTIVE
Criar regras de firewall
Neste laboratório, você vai usar o IAP para se conectar às instâncias que criar. Se você preferir não usar o IAP, pule esta etapa e adicione endereços IP públicos à instância e crie uma regra de firewall que permita a entrada na porta TCP 22 de 0.0.0.0/0.
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 da VM que você quer que sejam acessíveis 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 firewall-rules create allow-ssh-iap \
--network=${VPC_NAME} \
--allow tcp:22 \
--source-ranges=35.235.240.0/20
6. Criar Cloud NAT
É necessário criar um Cloud NAT para fazer o download de distribuições de pacotes do Linux.
Criar Cloud Router
No Cloud Shell
gcloud compute routers create crnat \
--network=${VPC_NAME} \
--region=${REGION}
Criar o Cloud NAT
No Cloud Shell
gcloud compute routers nats create europe-nat \
--router=crnat \
--auto-allocate-nat-external-ips \
--nat-all-subnet-ip-ranges \
--enable-logging \
--region=${REGION}
7. Criar um keyring e uma chave de gerenciamento de chaves
No Cloud Shell
gcloud kms keyrings create europe-kr \
--location ${REGION}
No Cloud Shell
gcloud kms keys create europe-key \
--location ${REGION} \
--keyring europe-kr \
--purpose encryption
No Cloud Shell, confirme se o keyring e a chave foram criados na região europe-west.
gcloud kms keys list \
--location ${REGION} \
--keyring europe-kr
RESULTADO ESPERADO
NAME: projects/<project-id>/locations/europe-west9/keyRings/europe-kr/cryptoKeys/europe-key PURPOSE: ENCRYPT_DECRYPT ALGORITHM: GOOGLE_SYMMETRIC_ENCRYPTION PROTECTION_LEVEL: SOFTWARE LABELS: PRIMARY_ID: 1 PRIMARY_STATE: ENABLED
Anote o nome do caminho completo fornecido para as chaves, porque você vai usá-lo para se conectar mais tarde.
8. Criar uma VM cliente e se conectar à API KMS
Em seguida, você vai criar uma VM cliente, fazer SSH na VM e testar a resolução da API KMS global. Esse teste representa a opção padrão para APIs globais de resolução do Google.
No Cloud Shell
#Create the startup script
touch startup.sh
#Open the startup.sh file using a text editor of your choice (e.g., nano, vim, gedit, etc.)
nano startup.sh
#Paste the following script content into the startup.sh file
#! /bin/bash
sudo apt-get update
sudo apt-get install dnsutils -y
sudo apt-get install tcpdump -y
#Save the changes you made to the startup.sh file
#Use the chmod command to make the script executable
chmod +x startup.sh
#Create the VM instance
gcloud compute instances create client-vm \
--network="${VPC_NAME}" \
--subnet="${SUBNET_NAME}" \
--zone="europe-west9-a" \
--machine-type="e2-medium" \
--no-address \
--scopes="https://www.googleapis.com/auth/cloud-platform" \
--image-family="debian-12" \
--image-project="debian-cloud" \
--metadata-from-file="startup-script=./startup.sh"
Em seguida, atualize a conta de serviço padrão do Compute para ter acesso à chave do KMS que você criou. A conta de serviço padrão do Compute vai estar no formato <Project_Number> -compute@developer.gserviceaccount.com. Para conferir o número do projeto, execute o comando a seguir no Cloud Shell e copie o número na última linha dos resultados retornados.
gcloud projects describe $PROJECT_ID
Atualize a conta de serviço padrão do Compute para ter acesso à chave do KMS criada.
No Cloud Shell
gcloud kms keys add-iam-policy-binding europe-key \
--location $REGION \
--keyring europe-kr \
--member serviceAccount:<project_number>-compute@developer.gserviceaccount.com \
--role roles/cloudkms.admin
Crie outro terminal do Cloud Shell clicando em + (captura de tela abaixo)
Na guia 2, crie um túnel pelo IAP para SSH na VM do cliente. As variáveis de ambiente não serão transferidas, e você precisará adicionar o ID do projeto ao comando abaixo.
No Cloud Shell
# Set the environment variable export PROJECT_ID=$(gcloud config get-value project) # ssh into the client-vm gcloud beta compute ssh --zone europe-west9-a "client-vm" \ --tunnel-through-iap \ --project $PROJECT_ID
Conecte-se à API KMS global usando o nome da chave KMS que você anotou anteriormente.
Na guia 2, "client-vm"
# Store the access token in a variable TOKEN=$(gcloud auth print-access-token) # Run the full command with maximum verbosity curl -v \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ 'https://cloudkms.googleapis.com/v1/projects/<project-id>/locations/europe-west9/keyRings/europe-kr/cryptoKeys/europe-key'
RESULTADO ESPERADO
* Trying 216.58.214.74:443...
* Connected to cloudkms.googleapis.com (216.58.214.74) port 443 (#0)
* ALPN: offers h2,http/1.1
* TLSv1.3 (OUT), TLS handshake, Client hello (1):
* CAfile: /etc/ssl/certs/ca-certificates.crt
* CApath: /etc/ssl/certs
* TLSv1.3 (IN), TLS handshake, Server hello (2):
* TLSv1.3 (IN), TLS handshake, Encrypted Extensions (8):
* TLSv1.3 (IN), TLS handshake, Certificate (11):
* TLSv1.3 (IN), TLS handshake, CERT verify (15):
* TLSv1.3 (IN), TLS handshake, Finished (20):
* TLSv1.3 (OUT), TLS change cipher, Change cipher spec (1):
* TLSv1.3 (OUT), TLS handshake, Finished (20):
* SSL connection using TLSv1.3 / TLS_AES_256_GCM_SHA384
* ALPN: server accepted h2
* Server certificate:
* subject: CN=upload.video.google.com
* start date: Aug 26 07:12:45 2024 GMT
* expire date: Nov 18 07:12:44 2024 GMT
* subjectAltName: host "cloudkms.googleapis.com" matched cert's "*.googleapis.com"
* issuer: C=US; O=Google Trust Services; CN=WR2
* SSL certificate verify ok.
* using HTTP/2
* h2h3 [:method: GET]
* h2h3 [:path: /v1/projects/<project-id>/locations/europe-west9/keyRings/europe-kr/cryptoKeys/europe-key]
* h2h3 [:scheme: https]
* h2h3 [:authority: cloudkms.googleapis.com]
* h2h3 [user-agent: curl/7.88.1]
* h2h3 [accept: */*]
* h2h3 [authorization: Bearer dsnkjfdnvjfd
* h2h3 [content-type: application/json]
* Using Stream ID: 1 (easy handle 0x55ed8bb7ece0)
> GET /v1/projects/<project-id>/locations/europe-west9/keyRings/europe-kr/cryptoKeys/europe-key HTTP/2
> Host: cloudkms.googleapis.com
> user-agent: curl/7.88.1
> accept: */*
> authorization: Bearer dsnkjfdnvjfd
> content-type: application/json
>
< HTTP/2 200
< content-type: application/json; charset=UTF-8
< vary: X-Origin
< vary: Referer
< vary: Origin,Accept-Encoding
< date: Tue, 24 Sep 2024 18:25:42 GMT
< server: ESF
< cache-control: private
< x-xss-protection: 0
< x-frame-options: SAMEORIGIN
< x-content-type-options: nosniff
< accept-ranges: none
<
{
"name": "projects/<project-id>/locations/europe-west9/keyRings/europe-kr/cryptoKeys/europe-key",
"primary": {
"name": "projects/<project-id>/locations/europe-west9/keyRings/europe-kr/cryptoKeys/europe-key/cryptoKeyVersions/1",
"state": "ENABLED",
"createTime": "2024-09-24T17:56:01.905156045Z",
"protectionLevel": "SOFTWARE",
"algorithm": "GOOGLE_SYMMETRIC_ENCRYPTION",
"generateTime": "2024-09-24T17:56:01.905156045Z"
},
"purpose": "ENCRYPT_DECRYPT",
"createTime": "2024-09-24T17:56:01.905156045Z",
"versionTemplate": {
"protectionLevel": "SOFTWARE",
"algorithm": "GOOGLE_SYMMETRIC_ENCRYPTION"
},
"destroyScheduledDuration": "2592000s"
}
* Connection #0 to host cloudkms.googleapis.com left intact
Verifique onde o DNS resolve o endpoint do KMS.
Na guia 2, "client-vm"
dig cloudkms.googleapis.com
RESULTADO ESPERADO
<<>> DiG 9.18.28-1~deb12u2-Debian <<>> cloudkms.googleapis.com ;; global options: +cmd ;; Got answer: ;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 62617 ;; flags: qr rd ra; QUERY: 1, ANSWER: 13, AUTHORITY: 0, ADDITIONAL: 1 ;; OPT PSEUDOSECTION: ; EDNS: version: 0, flags:; udp: 65494 ;; QUESTION SECTION: ;cloudkms.googleapis.com. IN A ;; ANSWER SECTION: cloudkms.googleapis.com. 300 IN A 142.250.74.234 cloudkms.googleapis.com. 300 IN A 142.250.75.234 cloudkms.googleapis.com. 300 IN A 216.58.214.170 cloudkms.googleapis.com. 300 IN A 172.217.20.170 cloudkms.googleapis.com. 300 IN A 172.217.20.202 cloudkms.googleapis.com. 300 IN A 216.58.215.42 cloudkms.googleapis.com. 300 IN A 216.58.213.74 cloudkms.googleapis.com. 300 IN A 142.250.179.74 cloudkms.googleapis.com. 300 IN A 142.250.179.106 cloudkms.googleapis.com. 300 IN A 142.250.178.138 cloudkms.googleapis.com. 300 IN A 142.250.201.170 cloudkms.googleapis.com. 300 IN A 172.217.18.202 cloudkms.googleapis.com. 300 IN A 216.58.214.74 ;; Query time: 4 msec ;; SERVER: 127.0.0.53#53(127.0.0.53) (UDP) ;; WHEN: Wed Oct 23 19:58:58 UTC 2024 ;; MSG SIZE rcvd: 260
Na guia 2, "client-vm"
dig cloudkms.europe-west9.rep.googleapis.com
RESULTADO ESPERADO
<<>> DiG 9.18.28-1~deb12u2-Debian <<>> cloudkms.europe-west9.rep.googleapis.com ;; global options: +cmd ;; Got answer: ;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 2736 ;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1 ;; OPT PSEUDOSECTION: ; EDNS: version: 0, flags:; udp: 65494 ;; QUESTION SECTION: ;cloudkms.europe-west9.rep.googleapis.com. IN A ;; ANSWER SECTION: cloudkms.europe-west9.rep.googleapis.com. 3043 IN A 34.1.65.232 ;; Query time: 0 msec ;; SERVER: 127.0.0.53#53(127.0.0.53) (UDP) ;; WHEN: Wed Oct 23 20:00:04 UTC 2024 ;; MSG SIZE rcvd: 85
O comportamento padrão das APIs do Google é usar o endpoint do serviço da API Global. Esse endpoint será resolvido para uma lista de IPs públicos. O comando dig para cloudkms.googleapis.com mostra isso. Observação: o endereço IP mostrado pode ser um endereço IP externo diferente. Esse é o comportamento normal das APIs do Google.
Ao usar endpoints regionais das APIs do Google com o PSC, você atende aos requisitos regionais de tráfego de API e muda a resolução de público para privado. A pesquisa em cloudkms.europe-west9.rep.googleapis.com mostra que, neste ponto, a resolução para o endpoint regional da API KSM ainda é pública.
Nas próximas seções, vamos migrar do uso do endpoint da API KMS global para o endpoint regional e mudar a resolução para privado usando back-ends do PSC.
9. Criar o PSC NEG e o balanceador de carga
Para a próxima seção, volte para a primeira guia no Cloud Shell.
Você vai criar um balanceador de carga HTTP(S) interno com um grupo de endpoints de rede(NEG) que aponte para o endpoint regional do KMS na Europa como um serviço de back-end. A regra de encaminhamento do balanceador de carga funciona como o endpoint do Private Service Connect(PSC).
Crie o grupo de endpoints de rede (NEG) com o tipo Private Service Connect e o serviço de destino europe-west9-cloudkms.example.com.
No Cloud Shell
#Set the necessary variables
NEG_NAME="l7psc-kms-neg"
PSC_TARGET="cloudkms.europe-west9.rep.googleapis.com"
#Create the Private Service Connect NEG
gcloud compute network-endpoint-groups create ${NEG_NAME} \
--project=${PROJECT_ID} \
--region=${REGION} \
--network-endpoint-type=PRIVATE_SERVICE_CONNECT \
--psc-target-service=${PSC_TARGET}
# Verify the NEG creation
gcloud compute network-endpoint-groups describe ${NEG_NAME} \
--project=${PROJECT_ID} \
--region=${REGION}
Crie o serviço de back-end para o balanceador de carga.
No Cloud Shell
# 1. Set the necessary variables BACKEND_SERVICE_NAME="l7-psc-kms" # 2. Create the backend service gcloud compute backend-services create $BACKEND_SERVICE_NAME \ --load-balancing-scheme=INTERNAL_MANAGED \ --protocol=HTTPS \ --region=$REGION \
Adicione o NEG ao serviço de back-end.
No Cloud Shell
gcloud compute backend-services add-backend $BACKEND_SERVICE_NAME \
--network-endpoint-group=${NEG_NAME} \
--region=$REGION
Crie o mapa de URL para o balanceador de carga.
No Cloud Shell
gcloud compute url-maps create l7-psc-url-map \ --default-service=l7-psc-kms \ --region=$REGION
Crie o Path Matcher para o URL personalizado que o endpoint vai usar.
No Cloud Shell
gcloud compute url-maps add-path-matcher l7-psc-url-map \ --path-matcher-name=example \ --default-service=l7-psc-kms \ --region=$REGION
Crie a regra de host para o URL personalizado europe-west9-cloudkms.example.com.
No Cloud Shell
gcloud compute url-maps add-host-rule l7-psc-url-map \ --hosts=europe-west9-cloudkms.example.com \ --path-matcher-name=example \ --region=$REGION
Crie o proxy HTTPS de destino para o balanceador de carga. Para isso, é necessário criar um recurso de certificado SSL regional. Confira as etapas para criar um certificado autoassinado aqui. Vamos criar um certificado autoassinado usando o openssl e usá-lo para criar um recurso de certificado regional no GCP. O proxy HTTPS de destino vai usar esse certificado.
No Cloud Shell
# Set environment variables
export CERT_NAME="my-ssl-cert"
# Generate a private key
openssl genrsa -out private.key 2048
# Create a configuration file for the CSR
cat > csr_config.cnf << EOF
[req]
default_bits = 2048
prompt = no
default_md = sha256
req_extensions = req_ext
distinguished_name = dn
[dn]
CN = example.com
O = My Organization
C = US
[req_ext]
subjectAltName = @alt_names
[alt_names]
DNS.1 = example.com
DNS.2 = *.example.com
EOF
# Create a CSR using the configuration
openssl req -new -key private.key -out server.csr -config csr_config.cnf
# Create a self-signed certificate using the CSR
openssl x509 -req -days 365 -in server.csr -signkey private.key -out server.crt \
-extfile csr_config.cnf -extensions req_ext
# Verify the certificate
openssl x509 -in server.crt -text -noout
#Create a regional SSL certificate resource
gcloud compute ssl-certificates create ${CERT_NAME} \
--region=${REGION} \
--certificate=server.crt \
--private-key=private.key
#Create the target HTTPS proxy for the load balancer
gcloud compute target-https-proxies create psc-http-proxy \
--region=${REGION} \
--url-map=l7-psc-url-map \
--ssl-certificates=${CERT_NAME}
Crie a regra de encaminhamento para o balanceador de carga, que vai atuar como o endpoint do Private Service Connect. O endereço IP da regra de encaminhamento precisa pertencer a uma sub-rede regional na VPC que esteja na mesma região do endpoint da API que você está acessando.
No Cloud Shell
# Set environment variables
export PROXY_NAME="psc-http-proxy"
# Create the forwarding rule
gcloud compute forwarding-rules create kms-lb-rule \
--project=${PROJECT_ID} \
--region=${REGION} \
--load-balancing-scheme=INTERNAL_MANAGED \
--network=${VPC_NAME} \
--subnet=${SUBNET_NAME} \
--target-https-proxy=${PROXY_NAME} \
--target-https-proxy-region=${REGION} \
--address=10.0.0.100 \
--ports=443
10. Configuração do DNS
Nesta seção, você vai criar uma zona de DNS particular para example.com e um registro A que aponte para a regra de encaminhamento criada na última etapa.
Crie uma zona particular do DNS gerenciado.
No Cloud Shell
# Set environment variables
export LB_RULE_NAME="kms-lb-rule"
export DNS_ZONE_NAME="example-com-private-zone"
# Create the private DNS zone
gcloud dns managed-zones create ${DNS_ZONE_NAME} \
--dns-name="example.com." \
--description="Private DNS zone for example.com" \
--visibility=private \
--networks=${VPC_NAME}
Crie um registro A para europe-west9-cloudkms.example.com.
No Cloud Shell
gcloud dns record-sets transaction start \
--zone=${DNS_ZONE_NAME}
gcloud dns record-sets transaction add 10.0.0.100 \
--name=europe-west9-cloudkms.example.com \
--ttl=300 \
--type=A \
--zone=${DNS_ZONE_NAME}
gcloud dns record-sets transaction execute \
--zone=${DNS_ZONE_NAME}
11. Conectar-se à API Regional do KMS pelo PSC
Volte para a VM cliente na guia 2 para executar o tcpdump e conferir todos os detalhes da conexão e testar as conexões com o endpoint regional do KMS pelo back-end do PSC.
sudo tcpdump -i any net 10.0.0.100 or port 53 -n
Abra uma terceira guia no Cloud Shell e faça SSH na VM do cliente.
# Set environment variables
export PROJECT_ID=$(gcloud config get-value project)
export KMS_HOSTNAME="europe-west9-cloudkms.example.com"
export KEY_RING="europe-kr"
export KEY_NAME="europe-key"
export REGION="europe-west9"
# Command to access the specific key
curl -k "https://${KMS_HOSTNAME}/v1/projects/${PROJECT_ID}/locations/${REGION}/keyRings/${KEY_RING}/cryptoKeys/${KEY_NAME}" \
-H "Authorization: Bearer $(gcloud auth print-access-token)"
RESULTADO ESPERADO para o comando curl + TCPDUMP
{
"name": "projects/<project-id>/locations/europe-west9/keyRings/europe-kr/cryptoKeys/europe-key",
"primary": {
"name": "projects/<project-id>/locations/europe-west9/keyRings/europe-kr/cryptoKeys/europe-key/cryptoKeyVersions/1",
"state": "ENABLED",
"createTime": "2024-10-10T18:50:24.357027036Z",
"protectionLevel": "SOFTWARE",
"algorithm": "GOOGLE_SYMMETRIC_ENCRYPTION",
"generateTime": "2024-10-10T18:50:24.357027036Z"
},
"purpose": "ENCRYPT_DECRYPT",
"createTime": "2024-10-10T18:50:24.357027036Z",
"versionTemplate": {
"protectionLevel": "SOFTWARE",
"algorithm": "GOOGLE_SYMMETRIC_ENCRYPTION"
},
"destroyScheduledDuration": "2592000s"
}
Tcpdump output
listening on any, link-type LINUX_SLL2 (Linux cooked v2), snapshot length 262144 bytes
18:13:51.220209 lo In IP 127.0.0.1.48873 > 127.0.0.53.53: 2086+ [1au] A? europe-west9-cloudkms.example.com. (62)
18:13:51.220230 lo In IP 127.0.0.1.48873 > 127.0.0.53.53: 24619+ [1au] AAAA? europe-west9-cloudkms.example.com. (62)
18:13:51.220669 ens4 Out IP 10.0.0.2.52121 > 169.254.169.254.53: 8885+ [1au] A? europe-west9-cloudkms.example.com. (62)
18:13:51.220784 ens4 Out IP 10.0.0.2.53041 > 169.254.169.254.53: 57748+ [1au] AAAA? europe-west9-cloudkms.example.com. (62)
18:13:51.229638 ens4 In IP 169.254.169.254.53 > 10.0.0.2.52121: 8885 1/0/1 A 10.0.0.100 (78)
18:13:51.229945 lo In IP 127.0.0.53.53 > 127.0.0.1.48873: 2086 1/0/1 A 10.0.0.100 (78)
18:13:51.230068 ens4 In IP 169.254.169.254.53 > 10.0.0.2.53041: 57748 0/1/1 (155)
18:13:51.230203 lo In IP 127.0.0.53.53 > 127.0.0.1.48873: 24619 0/1/1 (155)
18:13:51.230390 ens4 Out IP 10.0.0.2.59474 > 10.0.0.100.443: Flags [S], seq 1606150798, win 65320, options [mss 1420,sackOK,TS val 4135800856 ecr 0,nop,wscale 7], length 0
18:13:51.232565 ens4 In IP 10.0.0.100.443 > 10.0.0.2.59474: Flags [S.], seq 1041507402, ack 1606150799, win 65535, options [mss 1420,sackOK,TS val 2276748382 ecr 4135800856,nop,wscale 8], length 0
18:13:51.232583 ens4 Out IP 10.0.0.2.59474 > 10.0.0.100.443: Flags [.], ack 1, win 511, options [nop,nop,TS val 4135800859 ecr 2276748382], length 0
18:13:51.235494 ens4 Out IP 10.0.0.2.59474 > 10.0.0.100.443: Flags [P.], seq 1:518, ack 1, win 511, options [nop,nop,TS val 4135800862 ecr 2276748382], length 517
18:13:51.236571 ens4 In IP 10.0.0.100.443 > 10.0.0.2.59474: Flags [.], ack 518, win 267, options [nop,nop,TS val 2276748387 ecr 4135800862], length 0
18:13:51.239119 ens4 In IP 10.0.0.100.443 > 10.0.0.2.59474: Flags [P.], seq 1:1356, ack 518, win 267, options [nop,nop,TS val 2276748389 ecr 4135800862], length 1355
18:13:51.239140 ens4 Out IP 10.0.0.2.59474 > 10.0.0.100.443: Flags [.], ack 1356, win 501, options [nop,nop,TS val 4135800865 ecr 2276748389], length 0
18:13:51.240978 ens4 Out IP 10.0.0.2.59474 > 10.0.0.100.443: Flags [P.], seq 518:598, ack 1356, win 501, options [nop,nop,TS val 4135800867 ecr 2276748389], length 80
18:13:51.241266 ens4 Out IP 10.0.0.2.59474 > 10.0.0.100.443: Flags [P.], seq 598:684, ack 1356, win 501, options [nop,nop,TS val 4135800867 ecr 2276748389], length 86
18:13:51.241366 ens4 Out IP 10.0.0.2.59474 > 10.0.0.100.443: Flags [P.], seq 684:1646, ack 1356, win 501, options [nop,nop,TS val 4135800867 ecr 2276748389], length 962
18:13:51.242370 ens4 In IP 10.0.0.100.443 > 10.0.0.2.59474: Flags [.], ack 684, win 267, options [nop,nop,TS val 2276748392 ecr 4135800867], length 0
18:13:51.242619 ens4 In IP 10.0.0.100.443 > 10.0.0.2.59474: Flags [P.], seq 1356:1433, ack 1646, win 278, options [nop,nop,TS val 2276748393 ecr 4135800867], length 77
18:13:51.242730 ens4 Out IP 10.0.0.2.59474 > 10.0.0.100.443: Flags [P.], seq 1646:1677, ack 1433, win 501, options [nop,nop,TS val 4135800869 ecr 2276748393], length 31
18:13:51.248724 ens4 In IP 10.0.0.100.443 > 10.0.0.2.59474: Flags [.], ack 1677, win 278, options [nop,nop,TS val 2276748399 ecr 4135800869], length 0
18:13:51.296676 ens4 In IP 10.0.0.100.443 > 10.0.0.2.59474: Flags [P.], seq 1433:2357, ack 1677, win 278, options [nop,nop,TS val 2276748447 ecr 4135800869], length 924
18:13:51.297223 ens4 Out IP 10.0.0.2.59474 > 10.0.0.100.443: Flags [F.], seq 1677, ack 2357, win 501, options [nop,nop,TS val 4135800923 ecr 2276748447], length 0
18:13:51.298304 ens4 In IP 10.0.0.100.443 > 10.0.0.2.59474: Flags [P.], seq 2357:2381, ack 1678, win 278, options [nop,nop,TS val 2276748448 ecr 4135800923], length 24
18:13:51.298305 ens4 In IP 10.0.0.100.443 > 10.0.0.2.59474: Flags [F.], seq 2381, ack 1678, win 278, options [nop,nop,TS val 2276748448 ecr 4135800923], length 0
18:13:51.298336 ens4 Out IP 10.0.0.2.59474 > 10.0.0.100.443: Flags [R], seq 1606152476, win 0, length 0
18:13:51.298343 ens4 Out IP 10.0.0.2.59474 > 10.0.0.100.443: Flags [R], seq 1606152476, win 0, length 0
Verifique novamente a janela da guia 2 e inspecione as informações do tcpdump. Você vai notar que conseguiu acessar o endpoint regional do Cloud KMS pelo endpoint PSC que criou e que o endpoint regional europe-west9 é resolvido de forma particular para a zona do Cloud DNS gerenciado que você criou. As linhas relevantes na saída do tcpdump estão destacadas acima e referenciadas abaixo:
18:13:51.229638 ens4 In IP 169.254.169.254.53 > 10.0.0.2.52121: 8885 1/0/1 A 10.0.0.100 (78) (O servidor de metadados do GCP responde com o registro A: 10.0.0.100, o IP do balanceador de carga. A resolução de DNS está funcionando corretamente. europe-west9-cloudkms.example.com é resolvido para 10.0.0.100, que é o IP do balanceador de carga.
18:13:51.230390 ens4 Out IP 10.0.0.2.59474 > 10.0.0.100.443: Flags [S], seq 1606150798, win 65320, options [mss 1420,sackOK,TS val 4135800856 ecr 0,nop,wscale 7], length 0 (Isso mostra o handshake TCP para a conexão HTTPS com o IP do balanceador de carga)
Na guia 3, client-vm
dig europe-west9-cloudkms.example.com
RESULTADO ESPERADO
; <<>> DiG 9.18.28-1~deb12u2-Debian <<>> europe-west9-cloudkms.example.com ;; global options: +cmd ;; Got answer: ;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 7008 ;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1 ;; OPT PSEUDOSECTION: ; EDNS: version: 0, flags:; udp: 65494 ;; QUESTION SECTION: ;europe-west9-cloudkms.example.com. IN A ;; ANSWER SECTION: europe-west9-cloudkms.example.com. 300 IN A 10.0.0.100 ;; Query time: 12 msec ;; SERVER: 127.0.0.53#53(127.0.0.53) (UDP) ;; WHEN: Fri Oct 11 20:03:00 UTC 2024 ;; MSG SIZE rcvd: 78
A saída do comando "dig" mostra que o URL personalizado que criamos para europe-west9-cloudkms.example.com é resolvido corretamente para 10.0.0.100, que é o IP do balanceador de carga interno. As solicitações para europe-west9-cloudkms.example.com serão direcionadas ao balanceador de carga interno, que as encaminha para o endpoint regional do KMS pelo Private Service Connect.
Agora você pode fechar as duas guias SSH para a VM do cliente.
12. Etapas de limpeza
Excluir componentes do laboratório em um único terminal do Cloud Shell
# Set environment variables
export PROJECT_ID=$(gcloud config get-value project)
export PROJECT_NUMBER=$(gcloud projects describe ${PROJECT_ID} --format="value(projectNumber)")
export REGION=europe-west9
export ZONE=europe-west9-a
export VPC_NAME="consumer-vpc"
export SUBNET_NAME="consumer-subnet-1"
export NEG_NAME="l7psc-kms-neg"
export BACKEND_SERVICE_NAME="l7-psc-kms"
export CERT_NAME="my-ssl-cert"
export PROXY_NAME="psc-http-proxy"
export LB_RULE_NAME="kms-lb-rule"
export DNS_ZONE_NAME="example-com-private-zone"
# Delete DNS records and zone
gcloud dns record-sets delete europe-west9-cloudkms.example.com. \
--zone=${DNS_ZONE_NAME} --type=A --quiet
gcloud dns managed-zones delete ${DNS_ZONE_NAME} --quiet
# Delete Load Balancer components
gcloud compute forwarding-rules delete ${LB_RULE_NAME} --region=${REGION} --quiet
gcloud compute target-https-proxies delete ${PROXY_NAME} --region=${REGION} --quiet
gcloud compute url-maps delete l7-psc-url-map --region=${REGION} --quiet
gcloud compute backend-services delete ${BACKEND_SERVICE_NAME} --region=${REGION} --quiet
gcloud compute network-endpoint-groups delete ${NEG_NAME} --region=${REGION} --quiet
# Delete SSL certificate
gcloud compute ssl-certificates delete ${CERT_NAME} --region=${REGION} --quiet
# Delete VM instance
gcloud compute instances delete client-vm --zone=${ZONE} --quiet
# Delete firewall rules
gcloud compute firewall-rules delete allow-ssh-iap --quiet
# Delete Cloud NAT and router
gcloud compute routers nats delete europe-nat --router=crnat --region=${REGION} --quiet
gcloud compute routers delete crnat --region=${REGION} --quiet
# Delete subnets and VPC
gcloud compute networks subnets delete ${SUBNET_NAME} --region=${REGION} --quiet
gcloud compute networks subnets delete eu-west9-proxy-subnet --region=${REGION} --quiet
gcloud compute networks delete ${VPC_NAME} --quiet
# Schedule KMS key for deletion and provide instructions for keyring deletion
gcloud kms keys remove-iam-policy-binding europe-key \
--location ${REGION} \
--keyring europe-kr \
--member serviceAccount:${PROJECT_NUMBER}-compute@developer.gserviceaccount.com \
--role roles/cloudkms.admin
gcloud kms keys versions destroy 1 --location=${REGION} --keyring=europe-kr --key=europe-key
# Disable services (optional, only if you want to completely disable these APIs)
gcloud services disable compute.googleapis.com --force
gcloud services disable servicedirectory.googleapis.com --force
gcloud services disable dns.googleapis.com --force
gcloud services disable cloudkms.googleapis.com --force
# Clean up local files
rm -f private.key server.csr server.crt csr_config.cnf startup.sh
13. Parabéns!
Parabéns por concluir o codelab.