Le previsioni batch sono richieste asincrone che richiedono previsioni direttamente dalla risorsa del modello senza la necessità di eseguire il deployment del modello su un endpoint.
In questo tutorial utilizzerai una VPN ad alta disponibilità (VPN ad alta disponibilità) per inviare in modo privato richieste di previsione batch a un modello addestrato, tra due reti Virtual Private Cloud che possono fungere da base per la connettività privata on-premise e multi-cloud.
Questo tutorial è rivolto ad amministratori di reti aziendali, data scientist e ricercatori che hanno familiarità con Vertex AI, VPC (Virtual Private Cloud), console Google Cloud e Cloud Shell. La familiarità con Vertex AI Workbench è utile ma non obbligatoria.
Obiettivi
- Crea due reti Virtual Private Cloud (VPC), come mostrato nello schema precedente:
- Uno (
vertex-networking-vpc
) riguarda l'accesso alle API di Google per la previsione in batch. - L'altro (
onprem-vpc
) rappresenta una rete on-premise.
- Uno (
- Esegui il deployment di gateway VPN ad alta disponibilità, tunnel Cloud VPN e router Cloud per connettere
vertex-networking-vpc
eonprem-vpc
. - Creare un modello di previsione batch Vertex AI e caricarlo in un bucket Cloud Storage.
- Creare un endpoint Private Service Connect (PSC) per inoltrare le richieste private all'API REST di previsione batch di Vertex AI.
- Configura un annuncio di route personalizzata del router Cloud in
vertex-networking-vpc
per annunciare le route per l'endpoint Private Service Connect aonprem-vpc
. - Crea un'istanza VM di Compute Engine in
onprem-vpc
per rappresentare un'applicazione client (on-prem-client
) che invia in privato richieste di previsione batch tramite VPN ad alta disponibilità.
Costi
In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:
Per generare una stima dei costi in base all'utilizzo previsto,
utilizza il Calcolatore prezzi.
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
-
Nella console Google Cloud, vai alla pagina del selettore progetto.
-
Seleziona o crea un progetto Google Cloud.
-
Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.
- Apri Cloud Shell per eseguire i comandi elencati in questo tutorial. Cloud Shell è un ambiente shell interattivo per Google Cloud che consente di gestire progetti e risorse dal browser web.
- In Cloud Shell, imposta il progetto corrente sul tuo
ID progetto Google Cloud e archivia lo stesso
ID progetto nella variabile shell
projectid
:projectid="PROJECT_ID" gcloud config set project ${projectid}
Sostituisci PROJECT_ID con il tuo ID progetto. Se necessario, puoi individuare il tuo ID progetto nella console Google Cloud. Per maggiori informazioni, consulta Trovare l'ID progetto. - Se non sei il proprietario del progetto, chiedi al proprietario del progetto di concederti il ruolo Amministratore IAM progetto (roles/resourcemanager.projectIamAdmin). Devi avere questo ruolo per concedere i ruoli IAM nel passaggio successivo.
-
Concedi i ruoli al tuo Account Google. Esegui questo comando una volta per ciascuno dei seguenti ruoli IAM:
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:EMAIL_ADDRESS" --role=ROLE
- Sostituisci
PROJECT_ID
con l'ID progetto. - Sostituisci
EMAIL_ADDRESS
con il tuo indirizzo email. - Sostituisci
ROLE
con ogni singolo ruolo.
- Sostituisci
-
Abilita le API DNS, Artifact Registry, IAM, Compute Engine, Notebooks, and Vertex AI.
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 l'accesso alle API di Google per la previsione batch e l'altra per simulare una rete on-premise. In ciascuna delle due reti VPC, crea un router Cloud e un gateway Cloud NAT. Un gateway Cloud NAT fornisce connettività in uscita per le istanze di macchine virtuali (VM) Compute Engine senza indirizzi IP esterni.
Crea la rete VPC
vertex-networking-vpc
:gcloud compute networks create vertex-networking-vpc \ --subnet-mode custom
Nella rete
vertex-networking-vpc
, crea una subnet denominataworkbench-subnet
, con un intervallo IPv4 principale pari a10.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
Crea la rete VPC per simulare la rete on-premise (
onprem-vpc
):gcloud compute networks create onprem-vpc \ --subnet-mode custom
Nella rete
onprem-vpc
, crea una subnet denominataonprem-vpc-subnet1
, con un intervallo IPv4 principale172.16.10.0/29
:gcloud compute networks subnets create onprem-vpc-subnet1 \ --network onprem-vpc \ --range 172.16.10.0/29 \ --region us-central1
Verifica che le reti VPC siano configurate correttamente
Nella console Google Cloud, vai alla scheda Reti nel progetto attuale nella pagina Reti VPC.
Nell'elenco delle reti VPC, verifica che siano state create le due reti:
vertex-networking-vpc
eonprem-vpc
.Fai clic sulla scheda Subnet nel progetto corrente.
Nell'elenco delle subnet VPC, verifica che le subnet
workbench-subnet
eonprem-vpc-subnet1
siano state create.
Configura la connettività ibrida
In questa sezione creerai due gateway VPN ad alta disponibilità connessi tra loro. Uno si trova nella
rete VPC vertex-networking-vpc
. L'altro si trova nella
rete VPC onprem-vpc
. Ogni gateway contiene un router Cloud e una coppia di tunnel VPN.
Crea i gateway VPN ad alta disponibilità
In Cloud Shell, crea il gateway VPN ad alta disponibilità per la rete VPC
vertex-networking-vpc
:gcloud compute vpn-gateways create vertex-networking-vpn-gw1 \ --network vertex-networking-vpc \ --region us-central1
Crea il gateway VPN ad alta disponibilità per la rete VPC
onprem-vpc
:gcloud compute vpn-gateways create onprem-vpn-gw1 \ --network onprem-vpc \ --region us-central1
Nella console Google Cloud, vai alla scheda Gateway Cloud VPN nella pagina VPN.
Verifica che i due gateway (
vertex-networking-vpn-gw1
eonprem-vpn-gw1
) siano stati creati 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 ognuno dei router Cloud a livello di regione, crea un gateway Cloud NAT. I gateway Cloud NAT forniscono connettività in uscita per le istanze di macchine virtuali (VM) Compute Engine che non hanno indirizzi IP esterni.
In Cloud Shell, crea un router Cloud per la rete VPC
vertex-networking-vpc
:gcloud compute routers create vertex-networking-vpc-router1 \ --region us-central1\ --network vertex-networking-vpc \ --asn 65001
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
Crea un router Cloud a livello di regione per la rete VPC
vertex-networking-vpc
:gcloud compute routers create cloud-router-us-central1-vertex-nat \ --network vertex-networking-vpc \ --region us-central1
Configura un gateway Cloud NAT sul router Cloud a livello di regione:
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
Crea un router Cloud a livello di regione per la rete VPC
onprem-vpc
:gcloud compute routers create cloud-router-us-central1-onprem-nat \ --network onprem-vpc \ --region us-central1
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
Nella console Google Cloud, vai alla pagina Router Cloud.
Nell'elenco 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
Per visualizzare i nuovi valori, potrebbe essere necessario aggiornare la scheda del browser della console Google Cloud.
Nell'elenco dei router Cloud, fai clic su
cloud-router-us-central1-vertex-nat
.Nella pagina Dettagli router, verifica che il gateway Cloud NAT
cloud-nat-us-central1
sia stato creato.Fai clic sulla
Freccia indietro per tornare alla pagina Router Cloud.Nell'elenco di router, fai clic su
cloud-router-us-central1-onprem-nat
.Nella pagina Dettagli router, verifica che il gateway Cloud NAT
cloud-nat-us-central1-on-prem
sia stato creato.
Crea tunnel VPN
In Cloud Shell, nella rete
vertex-networking-vpc
, crea un tunnel VPN denominatovertex-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
Nella rete
vertex-networking-vpc
, crea un tunnel VPN denominatovertex-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
Nella rete
onprem-vpc
, crea un tunnel VPN denominatoonprem-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
Nella rete
onprem-vpc
, crea un tunnel VPN denominatoonprem-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
Nella console Google Cloud, vai alla pagina VPN.
Nell'elenco dei tunnel VPN, verifica che siano stati creati i quattro tunnel VPN.
Definizione di sessioni BGP
Il router Cloud utilizza il protocollo BGP (Border Gateway Protocol) per scambiare le route tra la tua rete VPC (in questo caso, vertex-networking-vpc
) e la tua rete on-premise (rappresentata da onprem-vpc
). Sul router Cloud, configuri un'interfaccia e un peer BGP per il tuo router on-premise.
L'interfaccia e la configurazione del peer BGP formano insieme una sessione BGP.
In questa sezione creerai due sessioni BGP per vertex-networking-vpc
e
due per onprem-vpc
.
Una volta configurate le interfacce e i peer BGP tra i router, questi inizieranno automaticamente a scambiare le route.
Stabilisci sessioni BGP per vertex-networking-vpc
In Cloud Shell, nella rete
vertex-networking-vpc
, crea un'interfaccia BGP pervertex-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
Nella rete
vertex-networking-vpc
, crea un peer BGP perbgp-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
Nella rete
vertex-networking-vpc
, crea un'interfaccia BGP pervertex-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
Nella rete
vertex-networking-vpc
, crea un peer BGP perbgp-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
Nella rete
onprem-vpc
, crea un'interfaccia BGP peronprem-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
Nella rete
onprem-vpc
, crea un peer BGP perbgp-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
Nella rete
onprem-vpc
, crea un'interfaccia BGP peronprem-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
Nella rete
onprem-vpc
, crea un peer BGP perbgp-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 di sessioni BGP
Nella console Google Cloud, vai alla pagina VPN.
Nell'elenco dei tunnel VPN, verifica che il valore nella colonna Stato sessione BGP per ciascuno dei tunnel sia cambiato da Configura sessione BGP in BGP stabilito. Per visualizzare i nuovi valori, potresti dover aggiornare la scheda del browser della console Google Cloud.
Convalida vertex-networking-vpc
route apprese
Nella console Google Cloud, vai alla pagina Reti VPC.
Nell'elenco delle reti VPC, fai clic su
vertex-networking-vpc
.Fai clic sulla scheda Route.
Seleziona us-central1 (Iowa) nell'elenco Regione e fai clic su Visualizza.
Nella colonna Intervallo IP di destinazione, verifica che l'intervallo IP della subnet
onprem-vpc-subnet1
(172.16.10.0/29
) sia presente due volte.
Convalida onprem-vpc
route apprese
Fai clic sulla
Freccia indietro per tornare alla pagina Reti VPC.Nell'elenco delle reti VPC, fai clic su
onprem-vpc
.Fai clic sulla scheda Route.
Seleziona us-central1 (Iowa) nell'elenco Regione e fai clic su Visualizza.
Nella colonna Intervallo IP di destinazione, verifica che l'intervallo IP di subnet
workbench-subnet
(10.0.1.0/28
) sia presente due volte.
Crea l'endpoint consumer Private Service Connect
In Cloud Shell, prenota un indirizzo IP dell'endpoint consumer che verrà utilizzato 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
Crea una regola di forwarding per connettere 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 annunci di route personalizzati per vertex-networking-vpc
In questa sezione creerai un annuncio di route personalizzata per vertex-networking-vpc-router1
(il router Cloud di vertex-networking-vpc
) per pubblicizzare l'indirizzo IP dell'endpoint PSC alla rete onprem-vpc
.
Nella console Google Cloud, vai alla pagina Router Cloud.
Nell'elenco di router Cloud, fai clic su
vertex-networking-vpc-router1
.Nella pagina Dettagli router, fai clic su
Modifica.Nella sezione Route annunciate, per Route seleziona Crea route personalizzate.
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 imita il comportamento del router Cloud nella modalità pubblicitaria predefinita.
Fai clic su Aggiungi una route personalizzata.
In Origine, seleziona Intervallo IP personalizzato.
In Intervallo di indirizzi IP, inserisci il seguente indirizzo IP:
192.168.0.1
In Descrizione, inserisci il seguente testo:
Custom route to advertise Private Service Connect endpoint IP address
Fai clic su Fine, poi su Salva.
Verifica che onprem-vpc
abbia appreso le route annunciate
Nella console Google Cloud, vai alla pagina Route.
Nella scheda Route operative, segui questi passaggi:
- In corrispondenza di Rete, scegli
onprem-vpc
. - In corrispondenza di Regione, scegli
us-central1 (Iowa)
. - Fai clic su Visualizza.
Nell'elenco delle route, verifica che siano presenti voci i cui nomi iniziano con
onprem-vpc-router1-bgp-vertex-networking-vpc-tunnel0
eonprem-vpc-router1-bgp-vfertex-networking-vpc-tunnel1
e che entrambe abbiano un intervallo IP di destinazione di192.168.0.1
.Se queste voci non vengono visualizzate immediatamente, attendi qualche minuto e poi aggiorna la scheda del browser della console Google Cloud.
- In corrispondenza di Rete, scegli
Crea in onprem-vpc
una VM che utilizza un account di servizio gestito dall'utente
In questa sezione creerai un'istanza VM che simula un'applicazione client on-premise che invia richieste di previsione batch. Seguendo le best practice di Compute Engine e IAM, questa VM utilizza un account di servizio gestito dall'utente anziché l'account di servizio predefinito di Compute Engine.
Creare un account di servizio gestito dall'utente
In Cloud Shell, esegui questi comandi, sostituendo PROJECT_ID con il tuo ID progetto:
projectid=PROJECT_ID gcloud config set project ${projectid}
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"
Assegna il ruolo Utente Vertex AI (
roles/aiplatform.user
) 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"
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 consente l'accesso diretto su internet. Per abilitare l'accesso amministrativo alla VM, utilizza l'inoltro TCP di Identity-Aware Proxy (IAP).
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=http://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"
Crea una regola firewall per consentire a IAP di connettersi alla tua istanza VM:
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 dall'istanza VM on-prem-client
all'API Vertex AI (us-central1-aiplatform.googleapis.com
). L'output dig
mostra che l'accesso predefinito utilizza solo i VIP pubblici per accedere all'API Vertex AI.
Nella sezione successiva configurerai l'accesso privato all'API Vertex AI.
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
Nell'istanza VM
on-prem-client
, esegui il comandodig
: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
Configurare e convalidare l'accesso privato all'API Vertex AI
In questa sezione configurerai l'accesso privato all'API Vertex AI in modo che, quando invii richieste di previsione batch, vengano reindirizzate al tuo endpoint PSC. L'endpoint PSC a sua volta inoltra queste richieste private all'API REST per la previsione batch di Vertex AI.
Aggiorna il file /etc/hosts
in modo che punti all'endpoint PSC
In questo passaggio, aggiungerai una riga al file /etc/hosts
che comporta il reindirizzamento delle richieste inviate all'endpoint di servizio pubblico (us-central1-aiplatform.googleapis.com
) all'endpoint PSC (192.168.0.1
).
Nell'istanza VM
on-prem-client
, utilizza un editor di testo comevim
onano
per aprire il file/etc/hosts
:sudo vim /etc/hosts
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 di 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
Salva il file come segue:
- Se utilizzi
vim
, premi il tastoEsc
, quindi digita:wq
per salvare il file e uscire. - Se utilizzi
nano
, digitaControl+O
e premiEnter
per salvare il file, poi digitaControl+X
per uscire.
- Se utilizzi
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.
Digita
Control+C
per uscire daping
.Digita
exit
per uscire dall'istanza VMon-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 di Vertex AI Workbench, dovrai creare un account di servizio gestito dall'utente e assegnare ruoli IAM all'account di servizio. Quando crei l'istanza, specifichi l'account di servizio.
In Cloud Shell, esegui questi comandi, sostituendo PROJECT_ID con il tuo ID progetto:
projectid=PROJECT_ID gcloud config set project ${projectid}
Crea un account di servizio denominato
workbench-sa
:gcloud iam service-accounts create workbench-sa \ --display-name="workbench-sa"
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"
Assegna il ruolo IAM Utente BigQuery (
roles/bigquery.user
) all'account di servizio:gcloud projects add-iam-policy-binding $projectid \ --member="serviceAccount:workbench-sa@$projectid.iam.gserviceaccount.com" \ --role="roles/bigquery.user"
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"
Assegna il ruolo IAM Visualizzatore log (
roles/logging.viewer
) 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
In Cloud Shell, crea un'istanza di Vertex AI Workbench, specificando 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
Nella console Google Cloud, vai alla scheda Istanze nella pagina Vertex AI Workbench.
Accanto al nome dell'istanza di Vertex AI Workbench (
workbench-tutorial
), fai clic su Apri JupyterLab.L'istanza di Vertex AI Workbench apre JupyterLab.
Seleziona File > Nuovo > Blocco note.
Dal menu Seleziona kernel, seleziona Python 3 (locale) e fai clic su Seleziona.
Quando si apre il nuovo blocco note, c'è una cella di codice predefinita in cui puoi inserire il codice.
[ ]:
seguito da un campo di testo. Il campo di testo è il campo in cui incolli 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 avanza:!pip3 install --upgrade google-cloud-bigquery scikit-learn==1.2
In questo passaggio e in ciascuno di quelli seguenti, aggiungi una nuova cella di codice (se necessario) facendo clic su
Inserisci una cella qui sotto, incolla il codice nella cella e fai clic su Esegui le celle selezionate e avanza.Per utilizzare i pacchetti appena installati in questo runtime Jupyter, devi riavviare 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)
Imposta le seguenti variabili di ambiente nel blocco note JupyterLab, sostituendo PROJECT_ID con il tuo ID progetto.
# set project ID and location PROJECT_ID = "PROJECT_ID" REGION = "us-central1"
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}" !gsutil mb -l {REGION} -p {PROJECT_ID} {BUCKET_URI}
prepara i dati di addestramento
In questa sezione preparerai i dati da utilizzare per addestrare un modello di previsione.
Nel tuo blocco note JupyterLab, crea un client BigQuery:
from google.cloud import bigquery bq_client = bigquery.Client(project=PROJECT_ID)
Recupera i dati dal set di dati pubblico
ml_datasets
di BigQuery: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()
Utilizza la libreria
sklearn
per suddividere i dati per l'addestramento e i 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)
Esporta i dataframe di addestramento e test in file CSV nel bucket di 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 imparerai a creare e creare l'applicazione di addestramento Python, e a salvarla nel bucket di gestione temporanea.
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.Definisci le caratteristiche, 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"))
Crea un file
__init__.py
in ogni sottodirectory per renderlo un pacchetto:!touch training_package/__init__.py !touch training_package/trainer/__init__.py
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.' )
Utilizza il comando
sdist
per creare la distribuzione di origine dell'applicazione di addestramento:!cd training_package && python setup.py sdist --formats=gztar
Copia il pacchetto Python nel bucket di gestione temporanea:
!gsutil cp training_package/dist/trainer-0.1.tar.gz $BUCKET_URI/
Verifica che il bucket di gestione temporanea contenga tre file:
!gsutil 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 job di addestramento personalizzato.
Nel tuo blocco note JupyterLab, esegui questo 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 corrisponde all'ID job personalizzato (CUSTOM_JOB_ID). Annota questi numeri in modo da poterli utilizzare nel passaggio successivo.
Using endpoint [http://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
Esegui il job di addestramento personalizzato e mostra l'avanzamento tramite 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 nell'output del comando precedente
- CUSTOM_JOB_ID: l'ID job personalizzato dell'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 a Vertex AI Model Registry.
Importa il modello
Il job di addestramento personalizzato carica il modello addestrato nel bucket di gestione temporanea. Al termine del job, puoi importare il modello dal bucket in Vertex AI Model Registry.
Nel tuo blocco note JupyterLab, importa il modello eseguendo questo comando:
!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
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 [http://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 sezione Vertex AI della console Google Cloud, vai alla pagina Vertex AI Model Registry.
Vai alla pagina di Vertex AI Model Registry
Per visualizzare gli ID e altri dettagli di un modello, fai clic sul nome del modello, poi fai clic sulla scheda Dettagli versione.
Ottieni previsioni batch dal modello
Ora puoi richiedere previsioni batch dal 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 da inviare al modello per ottenere previsioni batch.
In Cloud Shell, esegui questi comandi, sostituendo PROJECT_ID con il tuo ID progetto:
projectid=PROJECT_ID gcloud config set project ${projectid}
Accedi all'istanza VM
on-prem-client
utilizzandossh
:gcloud compute ssh on-prem-client \ --project=$projectid \ --zone=us-central1-a
Nell'istanza VM
on-prem-client
, utilizza un editor di testo comevim
onano
per creare un nuovo file denominatorequest.json
contenente il seguente 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 l'archiviazione temporanea del modello
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 \ "http://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. L'esecuzione richiede circa 20 minuti.
Nella sezione Vertex AI della console Google Cloud, vai alla pagina Previsioni batch.
Vai alla pagina Previsioni batch
Mentre il job di previsione batch è in esecuzione, il suo stato è
Running
. Al termine, lo stato diventaFinished
.Fai clic sul nome del job di previsione batch (
income-classification-batch-job
), quindi sul link Esporta percorso nella pagina dei dettagli per visualizzare i file di output del job batch in Cloud Storage.In alternativa, puoi fare clic sull'icona
Visualizza output previsione su Cloud Storage (tra la colonna Ultimo aggiornamento e il menu Azioni).Fai clic sul link al file
prediction.results-00000-of-00002
oprediction.results-00001-of-00002
, quindi 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 le contiene oppure mantieni il progetto ed elimina le singole risorse.
Puoi eliminare le singole risorse nella console Google Cloud come segue:
Elimina il job di previsione batch come segue:
Nella sezione Vertex AI della console Google Cloud, vai alla pagina Previsioni batch.
Accanto al nome del job di previsione batch (
income-classification-batch-job
), fai clic sul menu Azioni e scegli Elimina job di previsione batch.
Elimina il modello come segue:
Nella sezione Vertex AI della console Google Cloud, vai alla pagina Model Registry.
Accanto al nome del modello (
income-classifier-model
), fai clic sul menu Azioni e scegli Elimina modello.
Elimina l'istanza di Vertex AI Workbench come segue:
Nella sezione Vertex AI della console Google Cloud, vai alla scheda Istanze nella pagina Workbench.
Seleziona l'istanza
workbench-tutorial
Vertex AI Workbench e fai clic su Elimina.
Elimina l'istanza VM di Compute Engine come segue:
Nella console Google Cloud, vai alla pagina Compute Engine.
Seleziona l'istanza VM
on-prem-client
e fai clic su Elimina.
Elimina i tunnel VPN come segue:
Nella console Google Cloud, vai alla pagina VPN.
Nella pagina VPN, fai clic sulla scheda Tunnel Cloud VPN.
Nell'elenco dei tunnel VPN, seleziona i quattro tunnel VPN che hai creato in questo tutorial e fai clic su
Elimina.
Elimina i gateway VPN ad alta disponibilità come segue:
Nella pagina VPN, fai clic sulla scheda Gateway Cloud VPN.
Nell'elenco dei gateway VPN, fai clic su
onprem-vpn-gw1
.Nella pagina Dettagli gateway Cloud VPN, fai clic su
Elimina gateway VPN.Fai clic sulla
Freccia indietro, se necessario, per tornare all'elenco di gateway VPN, quindi fai clic suvertex-networking-vpn-gw1
.Nella pagina Dettagli gateway Cloud VPN, fai clic su
Elimina gateway VPN.
Elimina i router Cloud come segue:
Vai alla pagina Router Cloud.
Nell'elenco dei router Cloud, seleziona i quattro router che hai creato in questo tutorial.
Per eliminare i router, fai clic su
Elimina.Verranno eliminati anche i due gateway Cloud NAT connessi ai router Cloud.
Elimina la regola di forwarding
pscvertex
per la rete VPCvertex-networking-vpc
come segue:Vai alla scheda Frontend della pagina Bilanciamento del carico.
Nell'elenco delle regole di forwarding, fai clic su
pscvertex
.Nella pagina Dettagli regola di forwarding, fai clic su
Elimina.
Elimina le reti VPC nel seguente modo:
Vai alla pagina Reti VPC.
Nell'elenco delle reti VPC, fai clic su
onprem-vpc
.Nella pagina Dettagli rete VPC, fai clic su
Elimina rete VPC.L'eliminazione di ogni rete comporta anche l'eliminazione delle relative subnet, route e regole firewall.
Nell'elenco delle reti VPC, fai clic su
vertex-networking-vpc
.Nella pagina Dettagli rete VPC, fai clic su
Elimina rete VPC.
Elimina il bucket di archiviazione come segue:
Nella console Google Cloud, vai alla pagina Cloud Storage.
Seleziona il bucket di archiviazione e fai clic su
Elimina.
Elimina gli account di servizio
workbench-sa
eonprem-user-managed-sa
come segue:Vai alla pagina Account di servizio.
Seleziona gli account di servizio
onprem-user-managed-sa
eworkbench-sa
e fai clic su Elimina.
Passaggi successivi
- Scopri di più sulle opzioni di networking aziendali per accedere agli endpoint e ai servizi di Vertex AI
- Scopri come funziona Private Service Connect e perché offre vantaggi significativi in termini di prestazioni.
- Scopri come utilizzare i Controlli di servizio VPC per creare perimetri sicuri per consentire o negare l'accesso a Vertex AI e altre API di Google sul tuo endpoint di previsione online.
- Scopri come e perché utilizzare una zona di inoltro DNS anziché aggiornare il file
/etc/hosts
in ambienti di produzione e su larga scala.