1. Introducción
Private Service Connect es una función de las herramientas de redes de Google Cloud que permite a los consumidores acceder a los servicios de los productores. Esto incluye la capacidad de conectarse a las APIs de Google a través de un extremo privado alojado en la VPC del usuario(por lo general, de consumidor).
Además, los backends de PSC se pueden usar junto con los balanceadores de cargas de proxy de Google Cloud para apuntar a APIs de Google específicas de la región. El uso de backend de PSC proporciona controles más detallados para el consumidor, como los siguientes:
- Cómo elegir qué servicios de la API de Google están disponibles con un mapa de URL
- Observabilidad más profunda
- Integración de Cloud Armor
- URL personalizadas
- Administración avanzada del tráfico
Puedes encontrar la lista de servicios disponibles y sus APIs regionales aquí.
En este codelab, crearás un backend de PSC que apunte a la API regional de Cloud KMS y probarás la conectividad a esa API.
Qué aprenderás
- Crea un llavero de claves y una clave de Cloud Key Management Service (KMS).
- Crea un balanceador de cargas de aplicaciones interno con un backend de PSC que apunte a una API regional de Cloud KMS
- Crea una zona privada administrada y un registro A de Cloud DNS.
- Accede a Cloud KMS regional
Requisitos
- Un proyecto de Google Cloud con permisos de “Propietario” o “Editor” completos
2. Topología del codelab
Se creará una VPC para consumidores con una subred en la región europe-west9 para alojar una VM, la regla de reenvío del balanceador de cargas de aplicaciones interno regional y el backend de PSC, y una subred de solo proxy para usar con el balanceador de cargas. Crearemos un llavero de claves y una clave en el sistema de administración de claves (KMS) de Cloud en la región Europa occidental. Luego, crearemos el balanceador de cargas y el backend de PSC para resolver la API de KMS regional en europe-west9.
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 ID del proyecto 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
Habilita todos los servicios necesarios
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. Crea redes de VPC, subredes y reglas de firewall
Crear red de VPC
Desde 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
Crea subredes
Desde 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
En este lab, crearás un balanceador de cargas regional interno de L7 para dirigir a los backends de API regionales. Este balanceador de cargas es un balanceador de cargas de proxy, por lo que debes crear una "subred de proxy" dedicada al balanceador de cargas para que realice el proxy. Obtén más información sobre la subred de solo proxy aquí.
Desde 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
Crea reglas de firewall
En este lab, usarás IAP para conectarte a las instancias que crees. Si prefieres no usar IAP, puedes omitir este paso y, en su lugar, agregar direcciones IP públicas en la instancia y crear una regla de firewall que permita la entrada en el puerto TCP 22 desde 0.0.0.0/0.
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 firewall-rules create allow-ssh-iap \
--network=${VPC_NAME} \
--allow tcp:22 \
--source-ranges=35.235.240.0/20
6. Crea Cloud NAT
Se debe crear una Cloud NAT para descargar distribuciones de paquetes de Linux.
Crea un Cloud Router
Desde Cloud Shell
gcloud compute routers create crnat \
--network=${VPC_NAME} \
--region=${REGION}
Cómo crear Cloud NAT
Desde 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. Crea un llavero de claves y una clave de administración de claves
Desde Cloud Shell
gcloud kms keyrings create europe-kr \
--location ${REGION}
Desde Cloud Shell
gcloud kms keys create europe-key \
--location ${REGION} \
--keyring europe-kr \
--purpose encryption
En Cloud Shell, confirma que el llavero y la clave se hayan creado correctamente en la región 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
Anota el nombre de la ruta de acceso completa que se proporcionó para las claves, ya que la usarás para conectarte más adelante.
8. Crea una VM de cliente y conéctate a la API de KMS
A continuación, crearás una VM cliente, te conectarás a ella mediante SSH y probarás la resolución de la API global de KMS. Esta prueba representa la opción predeterminada para la resolución de las APIs de Google globales.
Desde 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"
A continuación, deberás actualizar la cuenta de servicio predeterminada de Compute para obtener acceso a la clave de KMS que creaste. La cuenta de servicio predeterminada de Compute tendrá el formato <Project_Number> -compute@developer.gserviceaccount.com. Para obtener el número de proyecto, ejecuta el siguiente comando desde Cloud Shell y copia el número de la última línea de los resultados que se muestran.
gcloud projects describe $PROJECT_ID
Actualiza la cuenta de servicio de Compute predeterminada para obtener acceso a la clave de KMS que creaste.
Desde 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
Para crear una terminal de Cloud Shell adicional, haz clic en + (captura de pantalla a continuación).
En la pestaña 2, crea un túnel a través de IAP para establecer una conexión SSH a client-vm. Ten en cuenta que las variables de entorno no se transferirán y deberás agregar el ID de tu proyecto al siguiente comando.
Desde 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
Conéctate a la API de KMS global con el nombre de clave de KMS que anotaste antes.
En la pestaña 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
Verifica dónde resuelve el DNS el extremo de KMS.
En la pestaña 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
En la pestaña 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
El comportamiento predeterminado de las APIs de Google es usar el extremo del servicio de API global. Este extremo se resolverá en una lista de IPs públicas. El comando dig para cloudkms.googleapis.com muestra esto. (Nota: La dirección IP que veas puede ser una dirección IP externa diferente. Este es el comportamiento normal de las APIs de Google).
Cuando usas extremos regionales de la API de Google con PSC, puedes cumplir con los requisitos regionales para el tráfico de la API y cambiar la resolución de pública a privada. El comando dig a cloudkms.europe-west9.rep.googleapis.com muestra que, en este momento, la resolución del extremo de la API de KSM regional sigue siendo pública.
En las siguientes secciones, migraremos del uso del extremo de la API de KMS global al extremo regional y cambiaremos la resolución a privada con los backend de PSC.
9. Crea el NEG y el balanceador de cargas de PSC
Para la siguiente sección, vuelve a la primera pestaña de Cloud Shell.
Crearás un balanceador de cargas HTTP(S) interno con un grupo de extremos de red(NEG) que apunte al extremo regional de KMS de Europa como servicio de backend. La regla de reenvío del balanceador de cargas actúa como el extremo de Private Service Connect(PSC).
Crea el grupo de extremos de red (NEG) con el tipo Private Service Connect y el servicio de destino europe-west9-cloudkms.example.com.
Desde 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}
Crea el servicio de backend para el balanceador de cargas.
Desde 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 \
Agrega el NEG al servicio de backend.
Desde Cloud Shell
gcloud compute backend-services add-backend $BACKEND_SERVICE_NAME \
--network-endpoint-group=${NEG_NAME} \
--region=$REGION
Crea el mapa de URL para el balanceador de cargas.
Desde Cloud Shell
gcloud compute url-maps create l7-psc-url-map \ --default-service=l7-psc-kms \ --region=$REGION
Crea el comparador de rutas para la URL personalizada que usará el extremo.
Desde Cloud Shell
gcloud compute url-maps add-path-matcher l7-psc-url-map \ --path-matcher-name=example \ --default-service=l7-psc-kms \ --region=$REGION
Crea la regla de host para la URL personalizada europe-west9-cloudkms.example.com.
Desde 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
Crea el proxy HTTPS de destino para el balanceador de cargas. Para ello, debes crear un recurso de certificado SSL regional. Consulta los pasos para crear un certificado autofirmado aquí. Crearemos un certificado autofirmado con openssl y lo usaremos para crear un recurso de certificado regional en GCP. El proxy HTTPS de destino usará este certificado.
Desde 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}
Crea la regla de reenvío para el balanceador de cargas que actuará como el extremo de Private Service Connect. La dirección IP de la regla de reenvío debe pertenecer a una subred regional de la VPC que esté en la misma región del extremo de la API al que accedes.
Desde 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. Configuración de DNS
En esta sección, crearás una zona de DNS privada para example.com y un registro A que apunte a la regla de reenvío que creamos en el último paso.
Crea una zona privada de DNS administrada.
Desde 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}
Crea un registro A para europe-west9-cloudkms.example.com.
Desde 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. Cómo conectarse a la API de KMS regional a través de PSC
Vuelve a la VM de cliente en la pestaña 2 para ejecutar tcpdump y ver todos los detalles de la conexión y probar las conexiones al extremo regional de KMS a través del backend de PSC.
sudo tcpdump -i any net 10.0.0.100 or port 53 -n
Abre una 3ª pestaña en Cloud Shell y usa SSH para conectarte a client-vm.
# 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 del 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
Vuelve a la ventana de la pestaña 2 y revisa la información de tcpdump. Verás que pudiste acceder al extremo regional de Cloud KMS a través del extremo de PSC que creaste y que el extremo regional de europe-west9 se resuelve de forma privada en la zona administrada de Cloud DNS que creaste. Las líneas relevantes del resultado de tcpdump se destacan arriba y se mencionan a continuación:
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) (El servidor de metadatos de GCP responde con el registro A: 10.0.0.100, la IP del balanceador de cargas. La resolución de DNS funciona correctamente. europe-west9-cloudkms.example.com se resuelve en 10.0.0.100, que es la IP de tu balanceador de cargas).
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 (Se muestra el protocolo de enlace TCP para la conexión HTTPS a la IP del balanceador de cargas)
En la pestaña 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
El resultado del comando dig muestra que la URL personalizada que creamos para europe-west9-cloudkms.example.com se resuelve correctamente en 10.0.0.100, que es la IP de tu balanceador de cargas interno. Las solicitudes a europe-west9-cloudkms.example.com se dirigirán a tu balanceador de cargas interno, que luego las reenviará al extremo regional de KMS a través de Private Service Connect.
Ahora puedes cerrar ambas pestañas de SSH a client-vm.
12. Pasos de limpieza
Borra componentes del lab desde una sola terminal de 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. ¡Felicitaciones!
Felicitaciones por completar el codelab.