Private Service Connect: utilizzo di domini personalizzati per accedere alle API di Google globali con i backend PSC

1. Introduzione

Private Service Connect (PSC) è una funzionalità di networking di Google Cloud che consente ai consumer di accedere ai servizi gestiti privatamente dall'interno della propria rete VPC. I backend PSC sono un sottoinsieme di funzionalità PSC che consentono a un bilanciatore del carico di trovarsi davanti a servizi gestiti da Google globali come Google Cloud Storage, consentendo l'applicazione di altre integrazioni di bilanciamento del carico, ad esempio un FQDN diverso. Al momento della pubblicazione di questo codelab, è disponibile solo un sottoinsieme di servizi Google che possono essere utilizzati con i backend PSC globali. Puoi trovare l'elenco qui.

Questo codelab esplorerà come configurare i backend PSC per accedere a Google Cloud Storage con un FQDN interno.

Cosa imparerai a fare

• Deployment dell'infrastruttura di rete VPC di base
• Deployment di bucket di base in Google Cloud Storage
• Deployment di un bilanciatore del carico delle applicazioni interno tra regioni con un backend PSC in Google Cloud Storage

Che cosa ti serve

• Progetto Google Cloud con autorizzazioni di proprietario
• I seguenti criteri dell'organizzazione non vengono applicati nel progetto Google Cloud: VM schermate

2. Topologia del codelab

In questo Codelab, eseguirai il deployment di una rete VPC, subnet, zona DNS privata, regole firewall, bucket Google Cloud Storage, un file di esempio e una VM di test. Dopodiché, eseguirai il deployment di un bilanciatore del carico delle applicazioni multiregionale con un backend PSC per Google Cloud Storage. Infine, testerai la connettività al file nel bucket Google Cloud Storage.

3. Configurazione e requisiti

Configurazione dell'ambiente autonomo

1. 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.

Attenzione:un ID progetto è univoco a livello globale e non può essere utilizzato da altri dopo che lo hai selezionato. Sei l'unico utente di questo ID. Anche se un progetto viene eliminato, l'ID non può essere riutilizzato

Nota:se utilizzi un account Gmail, puoi lasciare la posizione predefinita impostata su Nessuna organizzazione. Se utilizzi un account Google Workspace, scegli una posizione adatta alla tua organizzazione.

2. 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 il progetto sia configurato e configura le variabili.

gcloud auth login
gcloud config list project
gcloud config set project [YOUR-PROJECT-ID]
export projectid=[YOUR-PROJECT-ID]
export region1=us-central1
export zone1=us-central1-a
export region2=us-south1
echo $projectid
echo $region1
echo $zone1
echo $region2

Attiva tutti i servizi necessari

gcloud services enable compute.googleapis.com 
gcloud services enable networkmanagement.googleapis.com 
gcloud services enable storage.googleapis.com 
gcloud services enable dns.googleapis.com

5. Crea la rete VPC

Crea la rete VPC in cui verranno ospitati il client VM e i componenti di bilanciamento del carico.

Rete VPC

Da Cloud Shell

gcloud compute networks create myvpc \
    --subnet-mode=custom \
    --bgp-routing-mode=global 

Crea le subnet nel VPC. La prima subnet ospiterà il bilanciatore del carico. La seconda subnet è la subnet solo proxy per il bilanciatore del carico, mentre la terza è quella in cui verrà ospitato il client VM.

Crea subnet

Da Cloud Shell

gcloud compute networks subnets create $region2-subnet \
    --network=myvpc \
    --range=10.100.0.0/24 \
    --region=$region2

gcloud compute networks subnets create $region2-proxy-subnet \
    --network=myvpc \
    --range=10.100.100.0/24 \
    --region=$region2 \
    --purpose=GLOBAL_MANAGED_PROXY \
    --role=ACTIVE

gcloud compute networks subnets create $region1-subnet \
    --network=myvpc \
    --region=$region1 \
    --range=10.200.0.0/24 

Crea policy firewall di rete e regole firewall

Da Cloud Shell

gcloud compute network-firewall-policies create my-vpc-policy --global

gcloud compute network-firewall-policies associations create \
    --firewall-policy my-vpc-policy \
    --network myvpc \
    --name network-myvpc \
    --global-firewall-policy

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 network-firewall-policies rules create 1000 \
    --action ALLOW \
    --firewall-policy my-vpc-policy \
    --description "SSH with IAP" \
    --direction INGRESS \
    --src-ip-ranges 35.235.240.0/20 \
    --layer4-configs tcp:22  \
    --global-firewall-policy

6. Crea un bucket Google Cloud Storage, un file di esempio e concedi le autorizzazioni

Da Cloud Shell

gcloud storage buckets create gs://$projectid-pscbackend --location=us

echo "Here is my bucket file contents" > my-bucket-contents.txt 

gcloud storage cp my-bucket-contents.txt gs://$projectid-pscbackend/my-bucket-contents.txt

computesa=$(gcloud iam service-accounts list \
    --filter='displayName:Compute Engine default service account' \
    --format='value(email)')

echo $computesa


gcloud storage buckets add-iam-policy-binding gs://$projectid-pscbackend \
    --member="serviceAccount:$computesa" \
    --role="roles/storage.objectViewer"

Esempio di output

Creating gs://xxxxxxxxxxx-pscbackend/...
Copying file://my-bucket-contents.txt to gs://xxxxxxxxxxx-pscbackend/my-bucket-contents.txt
  Completed files 1/1 | 32.0B/32.0B                                                                                                                                                                  
[e-mail]
bindings:
- members:
  - projectEditor:xxxxxxxxxxx
  - projectOwner:xxxxxxxxxxx
  role: roles/storage.legacyBucketOwner
- members:
  - projectViewer:xxxxxxxxxxx
  role: roles/storage.legacyBucketReader
- members:
  - projectEditor:xxxxxxxxxxx
  - projectOwner:xxxxxxxxxxx
  role: roles/storage.legacyObjectOwner
- members:
  - projectViewer:xxxxxxxxxxx
  role: roles/storage.legacyObjectReader
- members:
  - serviceAccount:[e-mail]
  role: roles/storage.objectViewer
etag: CAI=
kind: storage#policy
resourceId: projects/_/buckets/xxxxxxxxxxx-pscbackend
version: 1

NOTA:questo codelab presuppone che il nome del bucket GCS sia disponibile a livello globale. Se il nome del bucket è già in uso, devi modificarlo sostituendo "$projectid-pscbackend" nel codice elencato sopra.

NOTA:se la tua organizzazione non consente l'utilizzo del service account predefinito, dovrai crearne uno tuo.

7. Esporre Google Cloud Storage tramite un bilanciatore del carico delle applicazioni interno tra regioni

Crea il bilanciatore del carico delle applicazioni interno tra regioni

Inizia creando i componenti del bilanciatore del carico. Creerai un NEG PSC, un servizio di backend, una mappa URL e proxy HTTP di destinazione.

In Cloud Shell

gcloud compute network-endpoint-groups create gcs-$region2-neg \
    --region=$region2 \
    --network-endpoint-type=private-service-connect \
    --psc-target-service=storage.googleapis.com

gcloud compute backend-services create gcs-bes \
    --load-balancing-scheme=INTERNAL_MANAGED \
    --protocol=HTTP \
    --global

gcloud compute backend-services add-backend gcs-bes \
    --global \
    --network-endpoint-group=gcs-$region2-neg \
    --network-endpoint-group-region=$region2

gcloud compute url-maps create gcsilb \
    --default-service=gcs-bes \
    --global

gcloud compute target-http-proxies create gcs-http-proxy \
    --url-map=gcsilb \
    --global

Crea la regola di forwarding del bilanciatore del carico.

In Cloud Shell

gcloud compute forwarding-rules create gcs-ilb-fr \
    --load-balancing-scheme=INTERNAL_MANAGED \
    --network=myvpc \
    --subnet=$region2-subnet \
    --target-http-proxy=gcs-http-proxy \
    --ports=80 \
    --subnet-region=$region2 \
    --global

NOTA:per una progettazione pronta per la produzione, ti consigliamo di utilizzare i proxy HTTPS di destinazione, la porta 443 e un certificato sul bilanciatore del carico.

8. Crea una zona privata di Cloud DNS per company.com

Innanzitutto, determiniamo l'indirizzo IP del bilanciatore del carico per il record A ed esportiamolo come variabile.

In Cloud Shell

gcloud compute forwarding-rules describe gcs-ilb-fr \
    --global

export lbip=$(gcloud compute forwarding-rules describe gcs-ilb-fr \
    --global \
    --format='value(IPAddress)')

echo $lbip

Esempio di output

IPAddress: 10.100.0.4
IPProtocol: TCP
creationTimestamp: 'xxxxxxxxxxxxxxx'
description: ''
fingerprint: xxxxxxxxxx
id: 'xxxxxxxxxxxxxx'
kind: compute#forwardingRule
labelFingerprint: xxxxxxxxxx
loadBalancingScheme: INTERNAL_MANAGED
name: gcs-ilb-fr
network: https://www.googleapis.com/compute/v1/projects/[projectID]/global/networks/myvpc
networkTier: PREMIUM
portRange: 80-80
selfLink: https://www.googleapis.com/compute/v1/projects/[projectID]/global/forwardingRules/gcs-ilb-fr
selfLinkWithId: https://www.googleapis.com/compute/v1/projects/[projectID]/global/forwardingRules/xxxxxxxxxxxxxx
subnetwork: https://www.googleapis.com/compute/v1/projects/[projectID]/regions/us-south1/subnetworks/us-south1-subnet
target: https://www.googleapis.com/compute/v1/projects/[projectID]/global/targetHttpProxies/gcs-http-proxy
10.100.0.4

Successivamente, crea la zona DNS privata e il record A per il bilanciatore del carico interno che hai appena creato.

Da Cloud Shell

gcloud dns managed-zones create "company-com" \
    --dns-name=company.com. \
    --description="company.com private dns zone" \
    --visibility=private \
    --networks=myvpc

gcloud dns record-sets create "storage.company.com" \
    --zone="company-com" \
    --type="A" \
    --ttl="300" \
    --rrdatas="$lbip"

9. Crea la VM di test

Crea una VM consumer-client

Da Cloud Shell

gcloud compute instances create testvm \
    --zone="$zone1" \
    --subnet="$region1-subnet" \
    --no-address \
    --metadata "startup-script=#! /bin/bash
cat <<EOF > /etc/profile.d/gcp-startup-vars.sh
export MYBUCKET=\"$projectid-pscbackend\"
export computesa=\"$computesa\"
EOF
chmod +x /etc/profile.d/gcp-startup-vars.sh"

10. Test della connessione a Google Cloud Storage tramite il bilanciatore del carico

Connettiti alla VM di test

In Cloud Shell

gcloud compute ssh "testvm"\
    --zone "$zone1"\
    --tunnel-through-iap \
    --project $projectid

Test di connettività

Nella VM di test

TOKEN=$(curl -s -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/$computesa/token" | jq -r .access_token)

curl -H "Authorization: Bearer $TOKEN" "http://storage.company.com/$MYBUCKET/my-bucket-contents.txt"

NOTA: [projectid-pscbackend] deve essere sostituito con il nome del bucket utilizzato durante la configurazione del bucket Google Cloud Storage, se è stato utilizzato un nome diverso.

Risultato previsto

Here is my bucket file contents

Esci dalla VM.

In TestVM

exit

OPERAZIONE RIUSCITA.

11. Procedura di pulizia

Da Cloud Shell

gcloud dns record-sets delete "storage.company.com" \
    --zone="company-com" \
    --type="A"

gcloud dns managed-zones delete "company-com"

gcloud compute forwarding-rules delete gcs-ilb-fr \
    --global \
    --quiet

gcloud compute target-http-proxies delete gcs-http-proxy \
    --global \
    --quiet

gcloud compute url-maps delete gcsilb \
    --global \
    --quiet

gcloud compute backend-services delete gcs-bes \
    --global \
    --quiet

gcloud compute network-endpoint-groups delete gcs-$region2-neg \
    --region=$region2 \
    --quiet

gcloud storage rm -r gs://$projectid-pscbackend \
    --quiet

gcloud compute instances delete testvm \
    --zone=$zone1 \
    --quiet

gcloud compute network-firewall-policies rules delete 1000 \
    --firewall-policy my-vpc-policy \
    --global-firewall-policy \
    --quiet

gcloud compute network-firewall-policies associations delete \
    --firewall-policy my-vpc-policy \
    --name=network-myvpc \
    --global-firewall-policy \
    --quiet

gcloud compute network-firewall-policies delete my-vpc-policy \
    --global \
    --quiet

gcloud compute networks subnets delete $region1-subnet \
    --region=$region1 \
    --quiet

gcloud compute networks subnets delete $region2-proxy-subnet \
    --region=$region2 \
    --quiet

gcloud compute networks subnets delete $region2-subnet \
    --region=$region2 \
    --quiet

gcloud compute networks delete myvpc \
    --quiet

12. Complimenti!

Congratulazioni per aver completato il codelab.

Argomenti trattati

• Deployment di file di base in Google Cloud Storage
• Deployment di un backend PSC per Google Cloud Storage
• Deployment di un bilanciatore del carico delle applicazioni interno tra regioni