Utilizza Private Service Connect per accedere alle previsioni batch di Vertex AI on-premise

Le previsioni batch sono richieste asincrone che richiedono direttamente le previsioni dalla risorsa del modello senza dover eseguire il deployment del modello in un endpoint.

In questo tutorial utilizzi la VPN ad alta disponibilità (HA VPN) per inviare richieste di previsione collettiva a un modello addestrato in privato tra due reti Virtual Private Cloud che possono servire da base per la connettività privata multi-cloud e on-premise.

Questo tutorial è rivolto agli amministratori di rete aziendali, scienziati e ricercatori che hanno familiarità con Vertex AI, Virtual Private Cloud (VPC), la console Google Cloud Cloud Shell. La conoscenza di Vertex AI Workbench è utile, ma non obbligatoria.

Diagramma di architettura che mostra l'utilizzo di Private Service Connect per accedere alle previsioni collettive.

Obiettivi

  • Crea due reti Virtual Private Cloud (VPC), come mostrato nel diagramma precedente:
    • Uno (vertex-networking-vpc) è per accedere alle API di Google per le predizioni in batch.
    • L'altra (onprem-vpc) rappresenta una rete on-premise.
  • Esegui il deployment di gateway VPN ad alta disponibilità, tunnel VPN Cloud e router Cloud per connettere vertex-networking-vpc e onprem-vpc.
  • Crea un modello di previsione batch Vertex AI e caricalo in un bucket Cloud Storage.
  • Crea un endpoint Private Service Connect (PSC) per l'inoltro richieste private all'API REST di previsione batch di Vertex AI.
  • Configura la modalità di annuncio personalizzato del router Cloud in vertex-networking-vpc per annunciare le route per l'endpoint Private Service Connect a onprem-vpc.
  • Crea un'istanza VM di Compute Engine in onprem-vpc da rappresentare un'applicazione client (on-prem-client) che invia dati le richieste di previsione privatamente tramite VPN ad alta disponibilità.

Costi

In questo documento utilizzi i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi basata sull'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud potrebbero essere idonei per una prova gratuita.

Una volta completate le attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la pagina Pulizia.

Prima di iniziare

  1. In the Google Cloud console, go to the project selector page.

    Go to project selector

  2. Select or create a Google Cloud project.

  3. Make sure that billing is enabled for your Google Cloud project.

  4. Apri Cloud Shell per eseguire i comandi elencati in questo tutorial. Cloud Shell è un ambiente shell interattivo per Google Cloud che ti consente di gestire progetti e risorse nel browser web.
  5. In Cloud Shell, imposta il progetto corrente sul tuo ID progetto Google Cloud e memorizza lo stesso ID progetto nella variabile shell projectid: 
      projectid="PROJECT_ID"
  gcloud config set project ${projectid}
     Sostituisci PROJECT_ID con l'ID del tuo progetto. Se necessario, puoi trovare l'ID progetto nella console Google Cloud. Per ulteriori informazioni, consulta Trovare l'ID progetto.
  6. Se non sei il proprietario del progetto, chiedi al proprietario di concederti l'autorizzazione Amministratore IAM progetto (roles/resourcemanager.projectIamAdmin) ruolo. Devi avere questo ruolo per concedere i ruoli IAM nella prossima passaggio.

  7. Grant roles to your user account. Run the following command once for each of the following IAM roles: roles/compute.instanceAdmin.v1, roles/compute.networkAdmin, roles/compute.securityAdmin, roles/dns.admin, roles/iap.tunnelResourceAccessor, roles/notebooks.admin, roles/iam.serviceAccountAdmin, roles/iam.serviceAccountUser, roles/servicedirectory.editor, roles/serviceusage.serviceUsageAdmin, roles/storage.admin, roles/aiplatform.admin, roles/aiplatform.user, roles/resourcemanager.projectIamAdmin 

    gcloud projects add-iam-policy-binding PROJECT_ID --member="USER_IDENTIFIER" --role=ROLE
    • Replace PROJECT_ID with your project ID.

    • Replace USER_IDENTIFIER with the identifier for your user account. For example, user:myemail@example.com.

    • Replace ROLE with each individual role.

  8. Enable the DNS, Artifact Registry, IAM, Compute Engine, Notebooks, and Vertex AI APIs: 

    gcloud services enable dns.googleapis.com artifactregistry.googleapis.com iam.googleapis.com compute.googleapis.com notebooks.googleapis.com aiplatform.googleapis.com

Crea le reti VPC

In questa sezione, creerai due reti VPC: una per accedere le API di Google per la previsione batch e l'altra per simulare un modello in ogni rete. In ognuno dei due VPC devi creare un router Cloud e un gateway Cloud NAT. Un gateway Cloud NAT fornisce la connettività in uscita per Compute Engine di macchine virtuali (VM) senza indirizzi IP esterni.

  1. Crea la rete VPC vertex-networking-vpc:

    gcloud compute networks create vertex-networking-vpc \
  --subnet-mode custom

  2. Nella rete vertex-networking-vpc, crea una subnet denominata workbench-subnet, con un intervallo IPv4 principale di 10.0.1.0/28:

    gcloud compute networks subnets create workbench-subnet \
  --range=10.0.1.0/28 \
  --network=vertex-networking-vpc \
  --region=us-central1 \
  --enable-private-ip-google-access

  3. Crea la rete VPC per simulare la rete on-premise (onprem-vpc):

    gcloud compute networks create onprem-vpc \
  --subnet-mode custom

  4. Nella rete onprem-vpc, crea una subnet denominata onprem-vpc-subnet1 con un intervallo IPv4 principale di 172.16.10.0/29:

    gcloud compute networks subnets create onprem-vpc-subnet1 \
  --network onprem-vpc \
  --range 172.16.10.0/29 \
  --region us-central1

Verificare che le reti VPC siano configurate correttamente

  1. Nella console Google Cloud, vai alla scheda Reti nel progetto corrente nella pagina Reti VPC.

    Vai a Reti VPC

  2. Nell'elenco delle reti VPC, verifica che i due reti sono state create: vertex-networking-vpc e onprem-vpc.

  3. Fai clic sulla scheda Subnet nel progetto attuale.

  4. Nell'elenco delle subnet VPC, verifica che le subnet workbench-subnet e onprem-vpc-subnet1 siano state create.

Configura la connettività ibrida

In questa sezione crei due gateway VPN ad alta disponibilità connessi tra loro. Uno risiede nella vertex-networking-vpc rete VPC. L'altro risiede onprem-vpc rete VPC. Ogni gateway contiene un un router Cloud e una coppia di tunnel VPN.

Crea i gateway VPN ad alta disponibilità

  1. In Cloud Shell, crea il gateway VPN ad alta disponibilità vertex-networking-vpc rete VPC:

    gcloud compute vpn-gateways create vertex-networking-vpn-gw1 \
   --network vertex-networking-vpc \
   --region us-central1

  2. Crea il gateway VPN ad alta disponibilità per onprem-vpc Rete VPC:

    gcloud compute vpn-gateways create onprem-vpn-gw1 \
   --network onprem-vpc \
   --region us-central1

  3. Nella console Google Cloud, vai alla scheda Gateway Cloud VPN nella Pagina VPN.

    Vai a VPN

  4. Verifica che i due (vertex-networking-vpn-gw1 e onprem-vpn-gw1) sono stati e che ogni gateway abbia due indirizzi IP di interfaccia.

crea router Cloud e gateway Cloud NAT

In ciascuna delle due reti VPC, crei due Router Cloud: uno generale e uno a livello di regione. In ogni regione router Cloud, devi creare un gateway Cloud NAT. I gateway Cloud NAT forniscono connettività in uscita per le istanze della macchina virtuale (VM) Compute Engine che non dispongono di indirizzi IP esterni.

  1. In Cloud Shell, crea un router Cloud per vertex-networking-vpc rete VPC:

    gcloud compute routers create vertex-networking-vpc-router1 \
   --region us-central1\
   --network vertex-networking-vpc \
   --asn 65001

  2. Crea un router Cloud per la rete VPC onprem-vpc:

    gcloud compute routers create onprem-vpc-router1 \
   --region us-central1\
   --network onprem-vpc\
   --asn 65002

  3. Crea un router Cloud regionale per la rete VPCvertex-networking-vpc:

    gcloud compute routers create cloud-router-us-central1-vertex-nat \
  --network vertex-networking-vpc \
  --region us-central1

  4. Configura un gateway Cloud NAT sul router Cloud regionale:

    gcloud compute routers nats create cloud-nat-us-central1 \
  --router=cloud-router-us-central1-vertex-nat \
  --auto-allocate-nat-external-ips \
  --nat-all-subnet-ip-ranges \
  --region us-central1

  5. Crea un router Cloud a livello di regione per il VPC onprem-vpc rete:

    gcloud compute routers create cloud-router-us-central1-onprem-nat \
  --network onprem-vpc \
  --region us-central1

  6. Configura un gateway Cloud NAT sul router Cloud a livello di regione:

    gcloud compute routers nats create cloud-nat-us-central1-on-prem \
  --router=cloud-router-us-central1-onprem-nat \
  --auto-allocate-nat-external-ips \
  --nat-all-subnet-ip-ranges \
  --region us-central1

  7. Nella console Google Cloud, vai alla pagina Router Cloud.

    Vai a Router Cloud

  8. Nell'elenco Cloud Routers (Router cloud), verifica che siano stati creati i seguenti router:

    • cloud-router-us-central1-onprem-nat
    • cloud-router-us-central1-vertex-nat
    • onprem-vpc-router1
    • vertex-networking-vpc-router1

    Potresti dover aggiornare la scheda del browser della console Google Cloud per vedere la nuova e i relativi valori.

  9. Nell'elenco Router Cloud, fai clic su cloud-router-us-central1-vertex-nat.

  10. Nella pagina Dettagli router, verifica che cloud-nat-us-central1 Il gateway Cloud NAT è stato creato.

  11. Fai clic sulla freccia indietro per torna alla pagina Router Cloud.

  12. Nell'elenco dei router, fai clic su cloud-router-us-central1-onprem-nat.

  13. Nella pagina Dettagli router, verifica che cloud-nat-us-central1-on-prem Il gateway Cloud NAT è stato creato.

Crea tunnel VPN

  1. In Cloud Shell, nella rete vertex-networking-vpc, crea un tunnel VPN denominato vertex-networking-vpc-tunnel0:

    gcloud compute vpn-tunnels create vertex-networking-vpc-tunnel0 \
  --peer-gcp-gateway onprem-vpn-gw1 \
  --region us-central1 \
  --ike-version 2 \
  --shared-secret [ZzTLxKL8fmRykwNDfCvEFIjmlYLhMucH] \
  --router vertex-networking-vpc-router1 \
  --vpn-gateway vertex-networking-vpn-gw1 \
  --interface 0

  2. Nella rete vertex-networking-vpc, crea un tunnel VPN denominato vertex-networking-vpc-tunnel1:

    gcloud compute vpn-tunnels create vertex-networking-vpc-tunnel1 \
  --peer-gcp-gateway onprem-vpn-gw1 \
  --region us-central1 \
  --ike-version 2 \
  --shared-secret [bcyPaboPl8fSkXRmvONGJzWTrc6tRqY5] \
  --router vertex-networking-vpc-router1 \
  --vpn-gateway vertex-networking-vpn-gw1 \
  --interface 1

  3. Nella rete onprem-vpc, crea un tunnel VPN chiamato onprem-vpc-tunnel0:

    gcloud compute vpn-tunnels create onprem-vpc-tunnel0 \
  --peer-gcp-gateway vertex-networking-vpn-gw1 \
  --region us-central1\
  --ike-version 2 \
  --shared-secret [ZzTLxKL8fmRykwNDfCvEFIjmlYLhMucH] \
  --router onprem-vpc-router1 \
  --vpn-gateway onprem-vpn-gw1 \
  --interface 0

  4. Nella rete onprem-vpc, crea un tunnel VPN chiamato onprem-vpc-tunnel1:

    gcloud compute vpn-tunnels create onprem-vpc-tunnel1 \
  --peer-gcp-gateway vertex-networking-vpn-gw1 \
  --region us-central1\
  --ike-version 2 \
  --shared-secret [bcyPaboPl8fSkXRmvONGJzWTrc6tRqY5] \
  --router onprem-vpc-router1 \
  --vpn-gateway onprem-vpn-gw1 \
  --interface 1

  5. Nella console Google Cloud, vai alla pagina VPN.

    Vai alla VPN

  6. Nell'elenco dei tunnel VPN, verifica che i quattro tunnel VPN siano stati è stato creato.

Definizione di sessioni BGP

Il router Cloud utilizza il protocollo BGP (Border Gateway Protocol) per scambiare le route tra sulla tua rete VPC (in questo caso, vertex-networking-vpc) e la rete on-premise (rappresentata da onprem-vpc). Sul router Cloud, devi configurare un'interfaccia e un peer BGP per il tuo router on-premise. L'abbinamento dell'interfaccia e della configurazione peer BGP crea una sessione BGP. In questa sezione creerai due sessioni BGP per vertex-networking-vpc e due per onprem-vpc.

Dopo aver configurato le interfacce e i peer BGP tra i router, questi inizieranno automaticamente a scambiarsi le route.

Stabilisci sessioni BGP per vertex-networking-vpc

  1. In Cloud Shell, nella rete vertex-networking-vpc, crea un'interfaccia BGP per vertex-networking-vpc-tunnel0:

    gcloud compute routers add-interface vertex-networking-vpc-router1 \
  --interface-name if-tunnel0-to-onprem \
  --ip-address 169.254.0.1 \
  --mask-length 30 \
  --vpn-tunnel vertex-networking-vpc-tunnel0 \
  --region us-central1

  2. Nella rete vertex-networking-vpc, crea un peer BGP per bgp-onprem-tunnel0:

    gcloud compute routers add-bgp-peer vertex-networking-vpc-router1 \
  --peer-name bgp-onprem-tunnel0 \
  --interface if-tunnel0-to-onprem \
  --peer-ip-address 169.254.0.2 \
  --peer-asn 65002 \
  --region us-central1

  3. Nella rete vertex-networking-vpc, crea un'interfaccia BGP per vertex-networking-vpc-tunnel1:

    gcloud compute routers add-interface vertex-networking-vpc-router1 \
  --interface-name if-tunnel1-to-onprem \
  --ip-address 169.254.1.1 \
  --mask-length 30 \
  --vpn-tunnel vertex-networking-vpc-tunnel1 \
  --region us-central1

  4. Nella rete vertex-networking-vpc, crea un peer BGP per bgp-onprem-tunnel1:

    gcloud compute routers add-bgp-peer vertex-networking-vpc-router1 \
  --peer-name bgp-onprem-tunnel1 \
  --interface if-tunnel1-to-onprem \
  --peer-ip-address 169.254.1.2 \
  --peer-asn 65002 \
  --region us-central1

Stabilisci sessioni BGP per onprem-vpc

  1. Nella rete onprem-vpc, crea un'interfaccia BGP per onprem-vpc-tunnel0:

    gcloud compute routers add-interface onprem-vpc-router1 \
  --interface-name if-tunnel0-to-vertex-networking-vpc \
  --ip-address 169.254.0.2 \
  --mask-length 30 \
  --vpn-tunnel onprem-vpc-tunnel0 \
  --region us-central1

  2. Nella rete onprem-vpc, crea un peer BGP per bgp-vertex-networking-vpc-tunnel0:

    gcloud compute routers add-bgp-peer onprem-vpc-router1 \
  --peer-name bgp-vertex-networking-vpc-tunnel0 \
  --interface if-tunnel0-to-vertex-networking-vpc \
  --peer-ip-address 169.254.0.1 \
  --peer-asn 65001 \
  --region us-central1

  3. Nella rete onprem-vpc, crea un'interfaccia BGP per onprem-vpc-tunnel1:

    gcloud compute routers add-interface   onprem-vpc-router1  \
  --interface-name if-tunnel1-to-vertex-networking-vpc \
  --ip-address 169.254.1.2 \
  --mask-length 30 \
  --vpn-tunnel onprem-vpc-tunnel1 \
  --region us-central1

  4. Nella rete onprem-vpc, crea un peer BGP per bgp-vertex-networking-vpc-tunnel1:

    gcloud compute routers add-bgp-peer onprem-vpc-router1 \
  --peer-name bgp-vertex-networking-vpc-tunnel1 \
  --interface if-tunnel1-to-vertex-networking-vpc \
  --peer-ip-address 169.254.1.1 \
  --peer-asn 65001 \
  --region us-central1

Convalida la creazione della sessione BGP

  1. Nella console Google Cloud, vai alla pagina VPN.

    Vai alla VPN

  2. Nell'elenco dei tunnel VPN, verifica che il valore nel campo La colonna Stato sessione BGP per ciascuno dei tunnel è stata modificata da Configura la sessione BGP su BGP stabilito. Potresti dover aggiornare la scheda del browser della console Google Cloud per visualizzare i nuovi valori.

Convalida vertex-networking-vpc route apprese

  1. Nella console Google Cloud, vai alla pagina Reti VPC.

    Vai a Reti VPC

  2. Nell'elenco delle reti VPC, fai clic su vertex-networking-vpc.

  3. Fai clic sulla scheda Percorsi.

  4. Seleziona us-central1 (Iowa) nell'elenco Regione e fai clic su Visualizza.

  5. Nella colonna Intervallo IP di destinazione, verifica che l'intervallo IP della subnet onprem-vpc-subnet1 (172.16.10.0/29) venga visualizzato due volte.

Convalida onprem-vpc route apprese

  1. Fai clic sulla Freccia indietro per tornare alla pagina Reti VPC.

  2. Nell'elenco delle reti VPC, fai clic su onprem-vpc.

  3. Fai clic sulla scheda Route.

  4. Seleziona us-central1 (Iowa) nell'elenco Regione e fai clic su Visualizza.

  5. Nella colonna Intervallo IP di destinazione, verifica che l'intervallo IP della subnet workbench-subnet (10.0.1.0/28) venga visualizzato due volte.

Crea l'endpoint consumer di Private Service Connect

  1. In Cloud Shell, prenota un indirizzo IP endpoint consumer che per accedere alle API di Google:

    gcloud compute addresses create psc-googleapi-ip \
  --global \
  --purpose=PRIVATE_SERVICE_CONNECT \
  --addresses=192.168.0.1 \
  --network=vertex-networking-vpc

  2. Crea una regola di inoltro per collegare l'endpoint alle API e ai servizi Google.

    gcloud compute forwarding-rules create pscvertex \
 --global \
 --network=vertex-networking-vpc\
 --address=psc-googleapi-ip \
 --target-google-apis-bundle=all-apis

Crea route annunciate personalizzate per vertex-networking-vpc

In questa sezione, configuri la modalità di annuncio personalizzato del router Cloud su Annunci range IP personalizzati per vertex-networking-vpc-router1 (il router Cloud per vertex-networking-vpc) in modo che annunci l'indirizzo IP dell'endpoint PSC alla rete onprem-vpc.

  1. Nella console Google Cloud, vai alla pagina Router Cloud.

    Vai a Router Cloud

  2. Nell'elenco Router Cloud, fai clic su vertex-networking-vpc-router1.

  3. Nella pagina Dettagli del router, fai clic su Modifica.

  4. Nella sezione Route annunciate, seleziona Route per Crea route personalizzate.

  5. Seleziona la casella di controllo Pubblicizza tutte le subnet visibili al router Cloud per continuare a pubblicizzare le subnet disponibili per il router Cloud. L'attivazione di questa opzione simula il comportamento del router Cloud in modalità di annuncio predefinita.

  6. Fai clic su Aggiungi un percorso personalizzato.

  7. In Origine, seleziona Intervallo IP personalizzato.

  8. In Intervallo di indirizzi IP, inserisci il seguente indirizzo IP:

    192.168.0.1

  9. In Descrizione, inserisci il seguente testo:

    Custom route to advertise Private Service Connect endpoint IP address

  10. Fai clic su Fine e poi su Salva.

Verifica che onprem-vpc abbia appreso le route annunciate

  1. Nella console Google Cloud, vai alla pagina Route.

    Vai a Route

  2. Nella scheda Route operative, procedi nel seguente modo:

    1. In corrispondenza di Rete, scegli onprem-vpc.
    2. In corrispondenza di Regione, scegli us-central1 (Iowa).
    3. Fai clic su Visualizza.

    4. Nell'elenco delle route, verifica che siano presenti voci i cui nomi iniziano con onprem-vpc-router1-bgp-vertex-networking-vpc-tunnel0 e onprem-vpc-router1-bgp-vfertex-networking-vpc-tunnel1 ed entrambi il cui intervallo IP di destinazione è 192.168.0.1.

      Se queste voci non vengono visualizzate immediatamente, attendi qualche minuto. e poi aggiorna la scheda del browser della console Google Cloud.

Creare una VM in onprem-vpc che utilizza un account di servizio gestito dall'utente

In questa sezione creerai un'istanza VM che simula un client on-premise un'applicazione che invia richieste di previsione batch. Dopo Compute Engine e IAM best practice, questa VM utilizza un account di servizio gestito dall'utente anziché l'Compute Engine account di servizio predefinito.

Crea un account di servizio gestito dall'utente

  1. In Cloud Shell, esegui i seguenti comandi, sostituendo PROJECT_ID con l'ID progetto:

    projectid=PROJECT_ID
gcloud config set project ${projectid}

  2. Crea un account di servizio denominato onprem-user-managed-sa:

    gcloud iam service-accounts create onprem-user-managed-sa \
  --display-name="onprem-user-managed-sa-onprem-client"

  3. Assegna il parametro Utente Vertex AI (roles/aiplatform.user) di servizio all'account di servizio:

    gcloud projects add-iam-policy-binding $projectid \
  --member="serviceAccount:onprem-user-managed-sa@$projectid.iam.gserviceaccount.com" \
  --role="roles/aiplatform.user"

  4. Assegna il ruolo Visualizzatore oggetti Storage (storage.objectViewer) all'account di servizio:

    gcloud projects add-iam-policy-binding $projectid \
  --member="serviceAccount:onprem-user-managed-sa@$projectid.iam.gserviceaccount.com" \
  --role="roles/storage.objectViewer"

Crea l'istanza VM on-prem-client

L'istanza VM che crei non ha un indirizzo IP esterno e non consentono l'accesso diretto su internet. Per abilitare le funzionalità amministrative alla VM, si utilizza l'inoltro TCP di Identity-Aware Proxy (IAP).

  1. In Cloud Shell, crea l'istanza VM on-prem-client:

    gcloud compute instances create on-prem-client \
  --zone=us-central1-a \
  --image-family=debian-11 \
  --image-project=debian-cloud \
  --subnet=onprem-vpc-subnet1 \
  --scopes=https://www.googleapis.com/auth/cloud-platform \
  --no-address \
  --shielded-secure-boot \
  --service-account=onprem-user-managed-sa@$projectid.iam.gserviceaccount.com \
  --metadata startup-script="#! /bin/bash
    sudo apt-get update
    sudo apt-get install tcpdump dnsutils -y"

  2. Crea una regola firewall per consentire a IAP di connettersi alla tua VM istanza:

    gcloud compute firewall-rules create ssh-iap-on-prem-vpc \
  --network onprem-vpc \
  --allow tcp:22 \
  --source-ranges=35.235.240.0/20

Convalida l'accesso pubblico all'API Vertex AI

In questa sezione, utilizzerai l'utilità dig per eseguire una ricerca DNS dal on-prem-client di un'istanza VM all'API Vertex AI (us-central1-aiplatform.googleapis.com). L'output dig mostra che l'accesso predefinito utilizza solo VIP pubblici per accedere all'API Vertex AI.

Nella sezione successiva configurerai l'accesso privato a Vertex AI tramite Google Cloud CLI o tramite l'API Compute Engine.

  1. In Cloud Shell, accedi all'istanza VM on-prem-client utilizzando IAP:

    gcloud compute ssh on-prem-client \
  --zone=us-central1-a \
  --tunnel-through-iap

  2. Nell'istanza VM on-prem-client, esegui il comando dig:

    dig us-central1-aiplatform.googleapis.com

    Dovresti vedere un output dig simile al seguente, dove gli indirizzi IP nella sezione della risposta sono indirizzi IP pubblici:

    ; <<>> DiG 9.16.44-Debian <<>> us-central1.aiplatfom.googleapis.com
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 42506
;; flags: qr rd ra; QUERY: 1, ANSWER: 16, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 512
;; QUESTION SECTION:
;us-central1.aiplatfom.googleapis.com. IN A

;; ANSWER SECTION:
us-central1.aiplatfom.googleapis.com. 300 IN A  173.194.192.95
us-central1.aiplatfom.googleapis.com. 300 IN A  142.250.152.95
us-central1.aiplatfom.googleapis.com. 300 IN A  172.217.219.95
us-central1.aiplatfom.googleapis.com. 300 IN A  209.85.146.95
us-central1.aiplatfom.googleapis.com. 300 IN A  209.85.147.95
us-central1.aiplatfom.googleapis.com. 300 IN A  142.250.125.95
us-central1.aiplatfom.googleapis.com. 300 IN A  142.250.136.95
us-central1.aiplatfom.googleapis.com. 300 IN A  142.250.148.95
us-central1.aiplatfom.googleapis.com. 300 IN A  209.85.200.95
us-central1.aiplatfom.googleapis.com. 300 IN A  209.85.234.95
us-central1.aiplatfom.googleapis.com. 300 IN A  142.251.171.95
us-central1.aiplatfom.googleapis.com. 300 IN A  108.177.112.95
us-central1.aiplatfom.googleapis.com. 300 IN A  142.250.128.95
us-central1.aiplatfom.googleapis.com. 300 IN A  142.251.6.95
us-central1.aiplatfom.googleapis.com. 300 IN A  172.217.212.95
us-central1.aiplatfom.googleapis.com. 300 IN A  74.125.124.95

;; Query time: 8 msec
;; SERVER: 169.254.169.254#53(169.254.169.254)
;; WHEN: Wed Sep 27 04:10:16 UTC 2023
;; MSG SIZE  rcvd: 321

Configura e convalida l'accesso privato all'API Vertex AI

In questa sezione configurerai l'accesso privato all'API Vertex AI in modo che che quando invii richieste di previsione batch, queste vengano reindirizzate al tuo dell'endpoint PSC. L'endpoint PSC, a sua volta, inoltra queste richieste private all'API REST di previsione in batch di Vertex AI.

Aggiorna il file /etc/hosts in modo che punti all'endpoint PSC

In questo passaggio, aggiungi una riga al file /etc/hosts che indirizzi le richieste inviate all'endpoint del servizio pubblico (us-central1-aiplatform.googleapis.com) all'endpoint PSC (192.168.0.1).

  1. Nell'istanza VM on-prem-client, utilizza un editor di testo come vim o nano per aprire il file /etc/hosts:

    sudo vim /etc/hosts

  2. Aggiungi la seguente riga al file:

    192.168.0.1 us-central1-aiplatform.googleapis.com

    Questa riga assegna l'indirizzo IP dell'endpoint PSC (192.168.0.1) al nome di dominio completo per l'API Google Vertex AI (us-central1-aiplatform.googleapis.com).

    Il file modificato dovrebbe avere il seguente aspetto:

    127.0.0.1       localhost
::1             localhost ip6-localhost ip6-loopback
ff02::1         ip6-allnodes
ff02::2         ip6-allrouters

192.168.0.1 us-central1-aiplatform.googleapis.com  # Added by you
172.16.10.6 on-prem-client.us-central1-a.c.vertex-genai-400103.internal on-prem-client  # Added by Google
169.254.169.254 metadata.google.internal  # Added by Google

  3. Salva il file come segue:

    • Se utilizzi vim, premi il tasto Esc e poi digita :wq per salvare il file ed uscire.
    • Se utilizzi nano, digita Control+O e premi Enter per salvare il file, quindi digita Control+X per uscire.

  4. Esegui il ping dell'endpoint Vertex AI come segue:

    ping us-central1-aiplatform.googleapis.com

    Il comando ping dovrebbe restituire il seguente output. 192.168.0.1 è l'indirizzo IP dell'endpoint PSC:

    PING us-central1-aiplatform.googleapis.com (192.168.0.1) 56(84) bytes of data.

  5. Digita Control+C per uscire da ping.

  6. Digita exit per uscire dall'istanza VM on-prem-client.

Crea un account di servizio gestito dall'utente per Vertex AI Workbench in vertex-networking-vpc

In questa sezione, per controllare l'accesso all'istanza Vertex AI Workbench, crei un account di servizio gestito dall'utente e poi assegni i ruoli IAM all'account di servizio. Quando crei l'istanza, specifica l'account di servizio.

  1. In Cloud Shell, esegui questo comando sostituendo PROJECT_ID con il tuo ID progetto:

    projectid=PROJECT_ID
gcloud config set project ${projectid}

  2. Crea un account di servizio denominato workbench-sa:

    gcloud iam service-accounts create workbench-sa \
  --display-name="workbench-sa"

  3. Assegna il ruolo IAM Utente Vertex AI (roles/aiplatform.user) all'account di servizio:

    gcloud projects add-iam-policy-binding $projectid \
  --member="serviceAccount:workbench-sa@$projectid.iam.gserviceaccount.com" \
  --role="roles/aiplatform.user"

  4. Assegna il parametro Utente BigQuery (roles/bigquery.user) ruolo IAM all'account di servizio:

    gcloud projects add-iam-policy-binding $projectid \
  --member="serviceAccount:workbench-sa@$projectid.iam.gserviceaccount.com" \
  --role="roles/bigquery.user"

  5. Assegna il ruolo IAM Amministratore archiviazione (roles/storage.admin) all'account di servizio:

    gcloud projects add-iam-policy-binding $projectid \
  --member="serviceAccount:workbench-sa@$projectid.iam.gserviceaccount.com" \
  --role="roles/storage.admin"

  6. Assegna il parametro Visualizzatore log (roles/logging.viewer) ruolo IAM all'account di servizio:

    gcloud projects add-iam-policy-binding $projectid \
  --member="serviceAccount:workbench-sa@$projectid.iam.gserviceaccount.com" \
  --role="roles/logging.viewer"

crea l'istanza di Vertex AI Workbench

  1. In Cloud Shell, crea un'istanza di Vertex AI Workbench, specifica l'account di servizio workbench-sa:

    gcloud workbench instances create workbench-tutorial \
  --vm-image-project=deeplearning-platform-release \
  --vm-image-family=common-cpu-notebooks \
  --machine-type=n1-standard-4 \
  --location=us-central1-a \
  --subnet-region=us-central1 \
  --shielded-secure-boot=True \
  --subnet=workbench-subnet \
  --disable-public-ip \
  --service-account-email=workbench-sa@$projectid.iam.gserviceaccount.com

  2. Nella console Google Cloud, vai a Istanze nella pagina Vertex AI Workbench.

    Vai a Vertex AI Workbench

  3. Fai clic su Apri JupyterLab accanto al nome dell'istanza di Vertex AI Workbench (workbench-tutorial).

    L'istanza di Vertex AI Workbench apre JupyterLab.

  4. Seleziona File &gt; Nuovo &gt; Blocco note.

  5. Nel menu Seleziona kernel, seleziona Python 3 (locale) e fai clic su Seleziona.

  6. All'apertura del nuovo blocco note, c'è una cella di codice predefinita in cui puoi inserire il codice. L'icona ha l'aspetto [ ]: seguito da un campo di testo. Il campo di testo è il punto in cui incollare il codice.

    Per installare l'SDK Vertex AI per Python, incolla il seguente codice nella cella e fai clic su  Esegui le celle selezionate e vai avanti:

    !pip3 install --upgrade google-cloud-bigquery scikit-learn==1.2

  7. In questo passaggio e in ciascuno dei seguenti, aggiungi una nuova cella di codice (se necessario) facendo clic su Inserisci una cella sotto, incolla il codice nella cella e poi fai clic su  Esegui le celle selezionate ed avanza.

    Per usare i pacchetti appena installati in questo runtime Jupyter, devi riavvia il runtime:

    # Restart kernel after installs so that your environment can access the new packages
import IPython

app = IPython.Application.instance()
app.kernel.do_shutdown(True)

  8. Imposta le seguenti variabili di ambiente nel tuo notebook JupyterLab, sostituendo PROJECT_ID con il tuo ID progetto.

    # set project ID and location
PROJECT_ID = "PROJECT_ID"
REGION = "us-central1"

  9. Crea un bucket Cloud Storage per la gestione temporanea del job di addestramento:

    BUCKET_NAME = f"{PROJECT_ID}-ml-staging"
BUCKET_URI = f"gs://{BUCKET_NAME}"
!gcloud storage buckets create {BUCKET_URI} --location={REGION} --project={PROJECT_ID}

prepara i dati di addestramento

In questa sezione, preparerai i dati da utilizzare per addestrare un modello di previsione.

  1. Nel tuo blocco note JupyterLab, crea un client BigQuery:

    from google.cloud import bigquery
bq_client = bigquery.Client(project=PROJECT_ID)

  2. Recupera i dati dal set di dati pubblico BigQuery ml_datasets:

    DATA_SOURCE = "bigquery-public-data.ml_datasets.census_adult_income"
# Define the SQL query to fetch the dataset
query = f"""
SELECT * FROM `{DATA_SOURCE}` LIMIT 20000
"""
# Download the dataset to a dataframe
df = bq_client.query(query).to_dataframe()
df.head()

  3. Utilizza la libreria sklearn per suddividere i dati per l'addestramento e il test:

    from sklearn.model_selection import train_test_split
# Split the dataset
X_train, X_test = train_test_split(df, test_size=0.3, random_state=43)
# Print the shapes of train and test sets
print(X_train.shape, X_test.shape)

  4. Esporta i dataframe di addestramento e test in file CSV nel bucket gestione temporanea:

    X_train.to_csv(f"{BUCKET_URI}/train.csv",index=False, quoting=1, quotechar='"')
X_test[[i for i in X_test.columns if i != "income_bracket"]].iloc[:20].to_csv(f"{BUCKET_URI}/test.csv",index=False,quoting=1, quotechar='"')

Prepara l'applicazione di addestramento

In questa sezione devi creare e creare l'applicazione di addestramento Python e la salvi nel bucket di gestione temporanea.

  1. Nel tuo blocco note JupyterLab, crea una nuova cartella per i file dell'applicazione di addestramento:

    !mkdir -p training_package/trainer

    Ora dovresti vedere una cartella denominata training_package nel menu di navigazione di JupyterLab.

  2. Definisci le funzionalità, il target, l'etichetta e i passaggi per l'addestramento e l'esportazione del modello in un file:

    %%writefile training_package/trainer/task.py
from sklearn.ensemble import RandomForestClassifier
from sklearn.feature_selection import SelectKBest
from sklearn.pipeline import FeatureUnion, Pipeline
from sklearn.preprocessing import LabelBinarizer
import pandas as pd
import argparse
import joblib
import os

TARGET = "income_bracket"
# Define the feature columns that you use from the dataset
COLUMNS = (
  "age",
  "workclass",
  "functional_weight",
  "education",
  "education_num",
  "marital_status",
  "occupation",
  "relationship",
  "race",
  "sex",
  "capital_gain",
  "capital_loss",
  "hours_per_week",
  "native_country",
)

# Categorical columns are columns that have string values and
# need to be turned into a numerical value to be used for training
CATEGORICAL_COLUMNS = (
  "workclass",
  "education",
  "marital_status",
  "occupation",
  "relationship",
  "race",
  "sex",
  "native_country",
)

# load the arguments
parser = argparse.ArgumentParser()
parser.add_argument('--training-dir', dest='training_dir', default=os.getenv('AIP_MODEL_DIR'), type=str,help='get the staging directory')
args = parser.parse_args()

# Load the training data
X_train = pd.read_csv(os.path.join(args.training_dir,"train.csv"))
# Remove the column we are trying to predict ('income-level') from our features list
# Convert the Dataframe to a lists of lists
train_features = X_train.drop(TARGET, axis=1).to_numpy().tolist()
# Create our training labels list, convert the Dataframe to a lists of lists
train_labels = X_train[TARGET].to_numpy().tolist()

# Since the census data set has categorical features, we need to convert
# them to numerical values. We'll use a list of pipelines to convert each
# categorical column and then use FeatureUnion to combine them before calling
# the RandomForestClassifier.
categorical_pipelines = []

# Each categorical column needs to be extracted individually and converted to a numerical value.
# To do this, each categorical column will use a pipeline that extracts one feature column via
# SelectKBest(k=1) and a LabelBinarizer() to convert the categorical value to a numerical one.
# A scores array (created below) will select and extract the feature column. The scores array is
# created by iterating over the COLUMNS and checking if it is a CATEGORICAL_COLUMN.
for i, col in enumerate(COLUMNS):
   if col in CATEGORICAL_COLUMNS:
      # Create a scores array to get the individual categorical column.
      # Example:
      #  data = [39, 'State-gov', 77516, 'Bachelors', 13, 'Never-married', 'Adm-clerical',
      #         'Not-in-family', 'White', 'Male', 2174, 0, 40, 'United-States']
      #  scores = [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
      #
      # Returns: [['Sate-gov']]
      scores = []
      # Build the scores array
      for j in range(len(COLUMNS)):
         if i == j:  # This column is the categorical column we want to extract.
            scores.append(1)  # Set to 1 to select this column
         else:  # Every other column should be ignored.
            scores.append(0)
      skb = SelectKBest(k=1)
      skb.scores_ = scores
      # Convert the categorical column to a numerical value
      lbn = LabelBinarizer()
      r = skb.transform(train_features)
      lbn.fit(r)
      # Create the pipeline to extract the categorical feature
      categorical_pipelines.append(
         (
            "categorical-{}".format(i),
            Pipeline([("SKB-{}".format(i), skb), ("LBN-{}".format(i), lbn)]),
         )
      )

# Create pipeline to extract the numerical features
skb = SelectKBest(k=6)
# From COLUMNS use the features that are numerical
skb.scores_ = [1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0]
categorical_pipelines.append(("numerical", skb))

# Combine all the features using FeatureUnion
preprocess = FeatureUnion(categorical_pipelines)

# Create the classifier
classifier = RandomForestClassifier()

# Transform the features and fit them to the classifier
classifier.fit(preprocess.transform(train_features), train_labels)

# Create the overall model as a single pipeline
pipeline = Pipeline([("union", preprocess), ("classifier", classifier)])

# Save the model pipeline
joblib.dump(pipeline, os.path.join(args.training_dir,"model.joblib"))

  3. Crea un __init__.py file in ogni sottodirectory per creare un pacchetto:

    !touch training_package/__init__.py
!touch training_package/trainer/__init__.py

  4. Crea uno script di configurazione del pacchetto Python:

    %%writefile training_package/setup.py
from setuptools import find_packages
from setuptools import setup

setup(
   name='trainer',
   version='0.1',
   packages=find_packages(),
   include_package_data=True,
   description='Training application package for census income classification.'
)

  5. Utilizza la sdist per creare la distribuzione di origine dell'applicazione di addestramento:

    !cd training_package && python setup.py sdist --formats=gztar

  6. Copia il pacchetto Python nel bucket di gestione temporanea:

    !gcloud storage cp training_package/dist/trainer-0.1.tar.gz $BUCKET_URI/

  7. Verifica che il bucket di gestione temporanea contenga tre file:

    !gcloud storage ls $BUCKET_URI

    L'output dovrebbe essere:

    gs://$BUCKET_NAME/test.csv
gs://$BUCKET_NAME/train.csv
gs://$BUCKET_NAME/trainer-0.1.tar.gz

Addestra il modello

In questa sezione addestrerai il modello creando ed eseguendo un addestramento personalizzato un lavoro.

  1. Nel tuo blocco note JupyterLab, esegui il seguente comando per creare un job di addestramento personalizzato:

    !gcloud ai custom-jobs create --display-name=income-classification-training-job \
   --project=$PROJECT_ID \
   --worker-pool-spec=replica-count=1,machine-type='e2-highmem-2',executor-image-uri='us-docker.pkg.dev/vertex-ai/training/sklearn-cpu.1-0:latest',python-module=trainer.task \
   --python-package-uris=$BUCKET_URI/trainer-0.1.tar.gz \
   --args="--training-dir","/gcs/$BUCKET_NAME" \
   --region=$REGION

    L'output dovrebbe essere simile al seguente. Il primo numero in ogni percorso del job personalizzato è il numero del progetto (PROJECT_NUMBER). Il secondo numero è l'ID job personalizzato (CUSTOM_JOB_ID). Prendi nota di questi numeri per poterli utilizzare nel passaggio successivo.

    Using endpoint [https://us-central1-aiplatform.googleapis.com/]
CustomJob [projects/721032480027/locations/us-central1/customJobs/1100328496195960832] is submitted successfully.

Your job is still active. You may view the status of your job with the command

$ gcloud ai custom-jobs describe projects/721032480027/locations/us-central1/customJobs/1100328496195960832

or continue streaming the logs with the command

$ gcloud ai custom-jobs stream-logs projects/721032480027/locations/us-central1/customJobs/1100328496195960832

  2. Esegui il job di addestramento personalizzato e mostra l'avanzamento tramite lo streaming dei log dal job durante l'esecuzione:

    !gcloud ai custom-jobs stream-logs projects/PROJECT_NUMBER/locations/us-central1/customJobs/CUSTOM_JOB_ID

    Sostituisci i seguenti valori:

    • PROJECT_NUMBER: il numero del progetto dall'output del comando precedente
    • CUSTOM_JOB_ID: l'ID job personalizzato dall'output del comando precedente

    Il job di addestramento personalizzato è ora in esecuzione. Il completamento richiede circa 10 minuti.

    Al termine del job, puoi importare il modello dal bucket di gestione temporanea in Vertex AI Model Registry.

Importa il modello

Il job di addestramento personalizzato carica il modello addestrato nel bucket di staging. Quando completato il job, puoi importare il modello dal bucket Vertex AI Model Registry.

  1. Nel blocco note JupyterLab, importa il modello eseguendo quanto segue :

    !gcloud ai models upload --container-image-uri="us-docker.pkg.dev/vertex-ai/prediction/sklearn-cpu.1-2:latest" \
   --display-name=income-classifier-model \
   --artifact-uri=$BUCKET_URI \
   --project=$PROJECT_ID \
   --region=$REGION

  2. Elenca i modelli Vertex AI nel progetto come segue:

    !gcloud ai models list --region=us-central1

    L'output dovrebbe essere simile al seguente. Se sono elencati due o più modelli, il primo nell'elenco è quello importato più di recente.

    Prendi nota del valore nella colonna MODEL_ID. Ti serve per creare la richiesta di previsione batch.

    Using endpoint [https://us-central1-aiplatform.googleapis.com/]
MODEL_ID             DISPLAY_NAME
1871528219660779520  income-classifier-model

    In alternativa, puoi elencare i modelli nel tuo progetto come segue:

    Nella console Google Cloud, nella sezione Vertex AI, vai alla pagina Vertex AI Model Registry.

    Vai alla pagina del registro dei modelli di Vertex AI

    Per visualizzare gli ID e altri dettagli di un modello, fai clic sul suo nome, e fai clic sulla scheda Dettagli versione.

Generare previsioni batch dal modello

Ora puoi richiedere previsioni batch al modello. Le richieste di previsione batch vengono effettuate dall'istanza VM on-prem-client.

Crea la richiesta di previsione batch

In questo passaggio utilizzerai ssh per accedere all'istanza VM on-prem-client. Nell'istanza VM, crei un file di testo denominato request.json che contiene il payload per una richiesta curl di esempio che invii al tuo modello per ottenere previsioni batch.

  1. In Cloud Shell, esegui i seguenti comandi, sostituendo PROJECT_ID con l'ID progetto:

    projectid=PROJECT_ID
gcloud config set project ${projectid}

  2. Accedi all'istanza VM on-prem-client utilizzando ssh:

    gcloud compute ssh on-prem-client \
  --project=$projectid \
  --zone=us-central1-a

  3. Nell'istanza VM on-prem-client, usa un editor di testo come vim o nano per creare un nuovo file denominato request.json contenente quanto segue testo:

    {
  "displayName": "income-classification-batch-job",
  "model": "projects/PROJECT_ID/locations/us-central1/models/MODEL_ID",
  "inputConfig": {
    "instancesFormat": "csv",
    "gcsSource": {
      "uris": ["BUCKET_URI/test.csv"]
    }
  },
  "outputConfig": {
    "predictionsFormat": "jsonl",
    "gcsDestination": {
      "outputUriPrefix": "BUCKET_URI"
    }
  },
  "dedicatedResources": {
    "machineSpec": {
      "machineType": "n1-standard-4",
      "acceleratorCount": "0"
    },
    "startingReplicaCount": 1,
    "maxReplicaCount": 2
  }
}

    Sostituisci i seguenti valori:

    • PROJECT_ID: il tuo ID progetto
    • MODEL_ID: l'ID del modello
    • BUCKET_URI: l'URI del bucket di archiviazione in cui hai eseguito il deployment del modello

  4. Esegui questo comando per inviare la richiesta di previsione batch:

    curl -X POST \
   -H "Authorization: Bearer $(gcloud auth print-access-token)" \
   -H "Content-Type: application/json; charset=utf-8" \
   -d @request.json \
   "https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/batchPredictionJobs"

    Sostituisci PROJECT_ID con l'ID progetto.

    Nella risposta dovresti vedere la seguente riga:

    "state": "JOB_STATE_PENDING"

    Il job di previsione batch ora è in esecuzione in modo asincrono. Sono necessari 20 minuti per l'esecuzione.

  5. Nella console Google Cloud, nella sezione Vertex AI, vai alla pagina Predizioni batch.

    Vai alla pagina Previsioni batch

    Mentre il job di previsione batch è in esecuzione, il suo stato è Running. Al termine, lo stato diventa Finished.

  6. Fai clic sul nome del job di previsione batch (income-classification-batch-job) e fai clic su Località di esportazione link nella pagina dei dettagli per visualizzare i file di output per il job batch in Cloud Storage.

    In alternativa, puoi fare clic sul Visualizza l'output delle previsioni su Cloud Storage (tra la colonna Ultimo aggiornamento e i Azioni).

  7. Fai clic sul prediction.results-00000-of-00002 o prediction.results-00001-of-00002 e fai clic sul link URL autenticato per aprire il file.

    L'output del job di previsione batch dovrebbe essere simile a questo esempio:

    {"instance": ["27", " Private", "391468", " 11th", "7", " Divorced", " Craft-repair", " Own-child", " White", " Male", "0", "0", "40", " United-States"], "prediction": " <=50K"}
{"instance": ["47", " Self-emp-not-inc", "192755", " HS-grad", "9", " Married-civ-spouse", " Machine-op-inspct", " Wife", " White", " Female", "0", "0", "20", " United-States"], "prediction": " <=50K"}
{"instance": ["32", " Self-emp-not-inc", "84119", " HS-grad", "9", " Married-civ-spouse", " Craft-repair", " Husband", " White", " Male", "0", "0", "45", " United-States"], "prediction": " <=50K"}
{"instance": ["32", " Private", "236543", " 12th", "8", " Divorced", " Protective-serv", " Own-child", " White", " Male", "0", "0", "54", " Mexico"], "prediction": " <=50K"}
{"instance": ["60", " Private", "160625", " HS-grad", "9", " Married-civ-spouse", " Prof-specialty", " Husband", " White", " Male", "5013", "0", "40", " United-States"], "prediction": " <=50K"}
{"instance": ["34", " Local-gov", "22641", " HS-grad", "9", " Never-married", " Protective-serv", " Not-in-family", " Amer-Indian-Eskimo", " Male", "0", "0", "40", " United-States"], "prediction": " <=50K"}
{"instance": ["32", " Private", "178623", " HS-grad", "9", " Never-married", " Other-service", " Not-in-family", " Black", " Female", "0", "0", "40", " ?"], "prediction": " <=50K"}
{"instance": ["28", " Private", "54243", " HS-grad", "9", " Divorced", " Transport-moving", " Not-in-family", " White", " Male", "0", "0", "60", " United-States"], "prediction": " <=50K"}
{"instance": ["29", " Local-gov", "214385", " 11th", "7", " Divorced", " Other-service", " Unmarried", " Black", " Female", "0", "0", "20", " United-States"], "prediction": " <=50K"}
{"instance": ["49", " Self-emp-inc", "213140", " HS-grad", "9", " Married-civ-spouse", " Exec-managerial", " Husband", " White", " Male", "0", "1902", "60", " United-States"], "prediction": " >50K"}

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

Puoi eliminare le singole risorse nella console Google Cloud nel seguente modo:

  1. Elimina il job di previsione batch come segue:

    1. Nella console Google Cloud, nella sezione Vertex AI, vai alla pagina Predizioni batch.

      Vai alla pagina Previsioni batch

    2. Accanto al nome del job di previsione batch (income-classification-batch-job), fai clic sul menu Azioni e scegli Elimina job di previsione batch.

  2. Elimina il modello come segue:

    1. Nella console Google Cloud, nella sezione Vertex AI, vai alla pagina Model Registry.

      Vai alla pagina del registro dei modelli

    2. Accanto al nome del modello (income-classifier-model), fai clic su Azioni e scegli Elimina modello.

  3. Elimina l'istanza di Vertex AI Workbench come segue:

    1. Nella sezione Vertex AI della console Google Cloud, vai alla scheda Istanze nella pagina Workbench.

      Vai a Vertex AI Workbench

    2. Seleziona l'workbench-tutorial istanza di Vertex AI Workbench e fai clic su Elimina.

  4. Elimina l'istanza VM di Compute Engine come segue:

    1. Nella console Google Cloud, vai alla pagina Compute Engine.

      Vai a Compute Engine

    2. Seleziona l'istanza VM on-prem-client e fai clic su Elimina.

  5. Elimina i tunnel VPN come segue:

    1. Nella console Google Cloud, vai alla pagina VPN.

      Vai a VPN

    2. Nella pagina VPN, fai clic sulla scheda Tunnel Cloud VPN.

    3. Nell'elenco dei tunnel VPN, seleziona i quattro tunnel VPN che hai creato in questo tutorial e fai clic su Elimina.

  6. Elimina i gateway VPN ad alta disponibilità come segue:

    1. Nella pagina VPN, fai clic sulla scheda Gateway Cloud VPN.

      Vai ai gateway Cloud VPN

    2. Nell'elenco dei gateway VPN, fai clic su onprem-vpn-gw1.

    3. Nella pagina Dettagli gateway Cloud VPN, fai clic su Elimina il gateway VPN.

    4. Se necessario, fai clic sulla freccia Indietro per tornare all'elenco dei gateway VPN, quindi fai clic su vertex-networking-vpn-gw1.

    5. Nella pagina Dettagli gateway Cloud VPN, fai clic su Elimina il gateway VPN.

  7. Elimina i router Cloud come segue:

    1. Vai alla pagina Router Cloud.

      Vai a Router Cloud

    2. Nell'elenco dei router Cloud, seleziona i quattro router creati in questo tutorial.

    3. Per eliminare i router, fai clic su Elimina.

      Verranno eliminati anche i due gateway Cloud NAT collegati ai router Cloud.

  8. Elimina la regola di forwarding pscvertex per vertex-networking-vpc rete VPC come segue:

    1. Vai alla scheda Frontend della pagina Bilanciamento del carico.

      Vai a Frontend

    2. Nell'elenco delle regole di forwarding, fai clic su pscvertex.

    3. Nella pagina Dettagli regola di forwarding, fai clic su Elimina.

  9. Elimina le reti VPC come segue:

    1. Vai alla pagina Reti VPC.

      Vai a Reti VPC

    2. Nell'elenco delle reti VPC, fai clic su onprem-vpc.

    3. Nella pagina Dettagli rete VPC, fai clic su Elimina rete VPC.

      L'eliminazione di ogni rete elimina anche le relative subnet, route e firewall le regole del caso.

    4. Nell'elenco delle reti VPC, fai clic su vertex-networking-vpc.

    5. Nella pagina Dettagli rete VPC, fai clic su Elimina la rete VPC.

  10. Elimina il bucket di archiviazione come segue:

    1. Nella console Google Cloud, vai alla pagina Cloud Storage.

      Vai a Cloud Storage

    2. Seleziona il bucket di archiviazione e fai clic su Elimina.

  11. Elimina gli account di servizio workbench-sa e onprem-user-managed-sa come segue:

    1. Vai alla pagina Account di servizio.

      Vai ad Account di servizio

    2. Seleziona gli account di servizio onprem-user-managed-sa e workbench-sa e fai clic su Elimina.

Passaggi successivi