1. Introduzione
Private Service Connect è una funzionalità di networking di Google Cloud che consente ai consumer di accedere ai servizi del producer. Ciò include la possibilità di connettersi alle API di Google tramite un endpoint privato ospitato all'interno del VPC dell'utente(in genere consumer).
Inoltre, i backend PSC possono essere utilizzati insieme ai bilanciatori del carico proxy di Google Cloud per indirizzare le API di Google specifiche per regione. L'utilizzo dei backend PSC offre controlli più granulari lato consumer, ad esempio:
- Scegliere quali servizi API di Google sono disponibili utilizzando una mappa URL
- Maggiore osservabilità
- Integrazione di Cloud Armor
- URL personalizzati
- Gestione avanzata del traffico
L'elenco dei servizi disponibili e delle relative API regionali è disponibile qui.
In questo codelab, creerai un backend PSC che punta all'API Cloud KMS regionale e testerai la connettività a questa API.
Obiettivi didattici
- Crea un keyring e una chiave Cloud Key Management Service (KMS).
- Crea un bilanciatore del carico delle applicazioni interno con un backend PSC che punta a un'API regionale Cloud KMS
- Creazione di una zona privata gestita Cloud DNS e di un record A.
- Accedi a Cloud KMS regionale
Che cosa ti serve
- Un progetto Google Cloud con autorizzazioni "Proprietario" o "Editor" complete.
2. Topologia del codelab
Verrà creato un VPC consumer con una subnet nella regione europe-west9 per ospitare una VM, la regola di forwarding del bilanciatore del carico delle applicazioni regionale interno e il backend PSC e una subnet solo proxy da utilizzare con il bilanciatore del carico. Creeremo un keyring e una chiave in Cloud Key Management System (KMS) nella regione europe-west. Quindi creeremo il bilanciatore del carico e il backend PSC per risolvere l'API KMS regionale in europe-west9.
3. Configurazione e requisiti
Configurazione dell'ambiente autonomo
- Accedi alla console Google Cloud e crea un nuovo progetto o riutilizzane uno esistente. Se non hai ancora un account Gmail o Google Workspace, devi crearne uno.
- Il nome del progetto è il nome visualizzato per i partecipanti a questo progetto. È una stringa di caratteri non utilizzata dalle API di Google. Puoi sempre aggiornarlo.
- L'ID progetto è univoco in tutti i progetti Google Cloud ed è immutabile (non può essere modificato dopo l'impostazione). La console Cloud genera automaticamente una stringa univoca, di solito non ti interessa di cosa si tratta. Nella maggior parte dei codelab, dovrai fare riferimento all'ID progetto (in genere identificato come
PROJECT_ID). Se l'ID generato non ti piace, puoi generarne un altro casuale. In alternativa, puoi provare a crearne uno e vedere se è disponibile. Non può essere modificato dopo questo passaggio e rimane per tutta la durata del progetto. - Per tua informazione, esiste un terzo valore, un numero di progetto, utilizzato da alcune API. Scopri di più su tutti e tre questi valori nella documentazione.
- Successivamente, devi abilitare la fatturazione in Cloud Console per utilizzare le risorse/API Cloud. Completare questo codelab non costa molto, se non nulla. Per arrestare le risorse ed evitare addebiti oltre a quelli previsti in questo tutorial, puoi eliminare le risorse che hai creato o il progetto. I nuovi utenti di Google Cloud possono beneficiare del programma prova senza costi di 300$.
Avvia Cloud Shell
Sebbene Google Cloud possa essere gestito da remoto dal tuo laptop, in questo codelab utilizzerai Google Cloud Shell, un ambiente a riga di comando in esecuzione nel cloud.
Nella console Google Cloud, fai clic sull'icona di Cloud Shell nella barra degli strumenti in alto a destra:
Bastano pochi istanti per eseguire il provisioning e connettersi all'ambiente. Al termine, dovresti vedere un risultato simile a questo:
Questa macchina virtuale è caricata con tutti gli strumenti per sviluppatori di cui avrai bisogno. Offre una home directory permanente da 5 GB e viene eseguita su Google Cloud, migliorando notevolmente le prestazioni e l'autenticazione della rete. Tutto il lavoro in questo codelab può essere svolto all'interno di un browser. Non devi installare nulla.
4. Prima di iniziare
Abilita API
In Cloud Shell, assicurati che l'ID progetto sia configurato.
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
Attiva tutti i servizi necessari
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 rete VPC, subnet e regole firewall
Crea rete VPC
Da 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 subnet
Da 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
In questo lab creerai un bilanciatore del carico regionale interno di livello 7 che punta ai backend API regionali. Questo bilanciatore del carico è un bilanciatore del carico proxy, pertanto devi creare una "subnet proxy" dedicata al bilanciatore del carico per eseguire il proxy. Per saperne di più sulla subnet solo proxy, fai clic qui.
Da 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 regole firewall
Per questo lab, utilizzerai IAP per connetterti alle istanze che crei. Se preferisci non utilizzare IAP, puoi saltare questo passaggio e aggiungere invece indirizzi IP pubblici all'istanza e creare una regola firewall che consenta l'ingresso sulla porta TCP 22 da 0.0.0.0/0.
Per consentire a IAP di connettersi alle tue istanze VM, crea una regola firewall che:
- Si applichi a tutte le istanze VM a cui vuoi accedere tramite IAP.
- Consente il traffico in entrata dall'intervallo IP 35.235.240.0/20. Questo intervallo contiene tutti gli indirizzi IP che utilizzati da IAP per l'inoltro TCP.
Da Cloud Shell
gcloud compute firewall-rules create allow-ssh-iap \
--network=${VPC_NAME} \
--allow tcp:22 \
--source-ranges=35.235.240.0/20
6. Crea Cloud NAT
Per scaricare le distribuzioni dei pacchetti Linux, è necessario creare un Cloud NAT.
Crea router Cloud
Da Cloud Shell
gcloud compute routers create crnat \
--network=${VPC_NAME} \
--region=${REGION}
Crea Cloud NAT
Da 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 la chiave automatizzata e la chiave Key Management
Da Cloud Shell
gcloud kms keyrings create europe-kr \
--location ${REGION}
Da Cloud Shell
gcloud kms keys create europe-key \
--location ${REGION} \
--keyring europe-kr \
--purpose encryption
Da Cloud Shell, verifica che il keyring e la chiave siano stati creati correttamente nella regione europe-west.
gcloud kms keys list \
--location ${REGION} \
--keyring europe-kr
RISULTATO PREVISTO
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
Prendi nota del nome del percorso completo assegnato alle chiavi, in quanto lo utilizzerai per connetterti in un secondo momento.
8. Crea la VM client e connettiti all'API KMS
Successivamente, creerai una VM client, ti connetterai alla VM tramite SSH e testerai la risoluzione dell'API KMS globale. Questo test rappresenta l'opzione predefinita per la risoluzione delle API globali di Google.
Da 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"
Successivamente, dovrai aggiornare il service account Compute predefinito per ottenere l'accesso alla chiave KMS che hai creato. Il service account di computing predefinito sarà nel formato <Project_Number> -compute@developer.gserviceaccount.com. Per ottenere il numero di progetto, esegui il seguente comando da Cloud Shell e copia il numero nell'ultima riga dei risultati restituiti.
gcloud projects describe $PROJECT_ID
Aggiorna il service account Compute predefinito per ottenere l'accesso alla chiave KMS che hai creato.
Da 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
Crea un altro terminale Cloud Shell facendo clic su + (screenshot di seguito)
Nella scheda 2, esegui il tunnel tramite IAP per accedere a client-vm tramite SSH. Tieni presente che le variabili di ambiente non verranno trasferite e dovrai aggiungere l'ID progetto al comando riportato di seguito.
Da 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
Connettiti all'API KMS globale utilizzando il nome della chiave KMS annotato in precedenza.
Dalla scheda 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'
RISULTATO PREVISTO
* 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
Controlla dove DNS risolve l'endpoint KMS.
Dalla scheda 2, client-vm
dig cloudkms.googleapis.com
RISULTATO PREVISTO
<<>> 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
Dalla scheda 2, client-vm
dig cloudkms.europe-west9.rep.googleapis.com
RISULTATO PREVISTO
<<>> 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
Il comportamento predefinito per le API di Google è l'utilizzo dell'endpoint del servizio API globale. Questo endpoint verrà risolto in un elenco di IP pubblici. La ricerca di cloudkms.googleapis.com lo mostra. Nota: l'indirizzo IP visualizzato potrebbe essere un indirizzo IP esterno diverso. Si tratta di un comportamento normale delle API di Google.)
Utilizzando gli endpoint API di Google regionali con PSC, puoi soddisfare i requisiti regionali per il traffico API e modificare la risoluzione da pubblica a privata. Il comando dig per cloudkms.europe-west9.rep.googleapis.com mostra che a questo punto la risoluzione dell'endpoint API KSM regionale è ancora pubblica.
Nelle sezioni seguenti eseguiremo la migrazione dall'utilizzo dell'endpoint API KMS globale all'endpoint regionale e modificheremo la risoluzione in privata utilizzando i backend PSC.
9. Crea il NEG PSC e il bilanciatore del carico
Per la sezione successiva, torna alla prima scheda di Cloud Shell.
Creerai un bilanciatore del carico HTTP(S) interno con un gruppo di endpoint di rete(NEG) che punta all'endpoint KMS regionale di europe come servizio di backend. La regola di forwarding del bilanciatore del carico funge da endpoint Private Service Connect(PSC).
Crea il gruppo di endpoint di rete (NEG) di tipo Private Service Connect e il servizio di destinazione europe-west9-cloudkms.example.com
Da 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 il servizio di backend per il bilanciatore del carico.
Da 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 \
Aggiungi il NEG al servizio di backend.
Da Cloud Shell
gcloud compute backend-services add-backend $BACKEND_SERVICE_NAME \
--network-endpoint-group=${NEG_NAME} \
--region=$REGION
Crea la mappa URL per il bilanciatore del carico.
Da Cloud Shell
gcloud compute url-maps create l7-psc-url-map \ --default-service=l7-psc-kms \ --region=$REGION
Crea il matcher di percorso per l'URL personalizzato che verrà utilizzato dall'endpoint.
Da 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 regola host per l'URL personalizzato europe-west9-cloudkms.example.com.
Da 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 il proxy HTTPS di destinazione per il bilanciatore del carico. Per farlo, devi creare una risorsa del certificato SSL a livello di regione. Consulta i passaggi per creare un certificato autofirmato qui. Creeremo un certificato autofirmato utilizzando openssl e lo utilizzeremo per creare una risorsa di certificato regionale su GCP. Il proxy HTTPS di destinazione utilizzerà questo certificato.
Da 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 regola di forwarding per il bilanciatore del carico che fungerà da endpoint Private Service Connect. L'indirizzo IP per la regola di forwarding deve appartenere a una subnet regionale nel VPC che si trova nella stessa regione dell'endpoint API a cui stai accedendo.
Da 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. Configurazione DNS
In questa sezione creerai una zona DNS privata per example.com e un record A che punta alla regola di forwarding creata nell'ultimo passaggio.
Crea una zona privata DNS gestita.
Da 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 record A per europe-west9-cloudkms.example.com.
Da 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. Connettiti all'API KMS regionale tramite PSC
Torna a client-vm nella scheda 2 per eseguire tcpdump per visualizzare tutti i dettagli della connessione e testare le connessioni all'endpoint KMS regionale tramite il backend PSC.
sudo tcpdump -i any net 10.0.0.100 or port 53 -n
Apri una terza scheda in Cloud Shell e connettiti tramite SSH 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)"
RISULTATO ATTESO per il 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
Torna alla finestra della scheda 2 e controlla le informazioni di tcpdump. Vedrai che sei riuscito ad accedere all'endpoint regionale Cloud KMS tramite l'endpoint PSC che hai creato e che l'endpoint regionale europe-west9 viene risolto privatamente nella zona Managed Cloud DNS che hai creato. Le righe pertinenti nell'output di tcpdump sono evidenziate sopra e riportate di seguito:
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) (Il server dei metadati GCP risponde con il record A: 10.0.0.100, l'IP del bilanciatore del carico. La risoluzione DNS funziona correttamente. europe-west9-cloudkms.example.com si risolve in 10.0.0.100, che è l'IP del bilanciatore del carico)
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 (mostra l'handshake TCP per la connessione HTTPS all'IP del bilanciatore del carico)
Nella scheda 3, client-vm
dig europe-west9-cloudkms.example.com
RISULTATO PREVISTO
; <<>> 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
L'output del comando dig mostra che l'URL personalizzato che abbiamo creato per europe-west9-cloudkms.example.com viene risolto correttamente in 10.0.0.100, ovvero l'IP del bilanciamento del carico interno. Le richieste a europe-west9-cloudkms.example.com verranno indirizzate al bilanciatore del carico interno, che le inoltrerà all'endpoint regionale KMS tramite Private Service Connect.
Ora puoi chiudere entrambe le schede SSH per client-vm.
12. Procedura di pulizia
Elimina i componenti del lab da un singolo terminale 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. Complimenti!
Congratulazioni per aver completato il codelab.