In questo tutorial utilizzerai la VPN ad alta disponibilità (VPN ad alta disponibilità) per accedere a un endpoint di previsione online sia pubblicamente, tramite Cloud NAT; e in privato tra due reti Virtual Private Cloud può servire 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 e Cloud Shell. Dimestichezza con Vertex AI Workbench è utile ma non obbligatorio.
Obiettivi
- Crea due reti Virtual Private Cloud (VPC), come illustrato nella precedente
diagramma:
- Uno (
on-prem-vpc
) rappresenta una rete on-premise. - L'altra (
aiml-vpc
) è dedicata alla creazione e al deployment di un'istanza Vertex AI un modello di previsione online.
- Uno (
- Esegui il deployment di gateway VPN Cloud VPN disponibilità,
Router Cloud per connettere
aiml-vpc
eon-prem-vpc
. - Crea ed esegui il deployment di un modello di previsione online di Vertex AI.
- Crea un endpoint Private Service Connect (PSC) per l'inoltro richieste di previsione online private al modello di cui è stato eseguito il deployment.
- Abilita la modalità di pubblicità personalizzata del router Cloud in
aiml-vpc
per annunciare le route per l'endpoint Private Service Connect versoon-prem-vpc
. - Crea due istanze VM di Compute Engine in
on-prem-vpc
per rappresentare applicazioni client:- Una (
nat-client
) invia richieste di previsione online al pubblico internet (tramite Cloud NAT). Questo metodo di accesso è indicato da una freccia rossa e dal numero 1 nel diagramma. - L'altro (
private-client
) invia le richieste di previsione privatamente tramite VPN ad alta disponibilità. Questo viene indicato con una freccia verde e il numero 2.
- Una (
Costi
In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:
Per generare una stima dei costi basata sull'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
-
In the Google Cloud console, go to the project selector page.
-
Select or create a Google Cloud project.
-
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 ti consente di gestire progetti e risorse nel browser web.
- In Cloud Shell, imposta il progetto attuale sul
ID progetto Google Cloud e archiviare 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 Individua il tuo ID progetto nella console Google Cloud. Per ulteriori informazioni, vedi Trova il tuo ID progetto. -
Grant roles to your user account. Run the following command once for each of the following IAM roles:
roles/appengine.appViewer, roles/artifactregistry.admin, roles/compute.instanceAdmin.v1, roles/compute.networkAdmin, roles/compute.securityAdmin, roles/dns.admin, roles/iap.admin, roles/iap.tunnelResourceAccessor, roles/notebooks.admin, roles/oauthconfig.editor, roles/resourcemanager.projectIamAdmin, roles/servicemanagement.quotaAdmin, roles/iam.serviceAccountAdmin, roles/iam.serviceAccountUser, roles/servicedirectory.editor, roles/storage.admin, roles/aiplatform.user
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.
- Replace
-
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 creare un modello di previsione online e il deployment in un endpoint, l'altro privato all'endpoint. 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.
Crea la rete VPC per l'endpoint di previsione online (aiml-vpc
)
Crea la rete VPC:
gcloud compute networks create aiml-vpc \ --project=$projectid \ --subnet-mode=custom
Crea una subnet denominata
workbench-subnet
, con un intervallo IPv4 principale di172.16.10.0/28
:gcloud compute networks subnets create workbench-subnet \ --project=$projectid \ --range=172.16.10.0/28 \ --network=aiml-vpc \ --region=us-central1 \ --enable-private-ip-google-access
Crea un router Cloud a livello di regione denominato
cloud-router-us-central1-aiml-nat
:gcloud compute routers create cloud-router-us-central1-aiml-nat \ --network aiml-vpc \ --region us-central1
Aggiungi un gateway Cloud NAT al router Cloud:
gcloud compute routers nats create cloud-nat-us-central1 \ --router=cloud-router-us-central1-aiml-nat \ --auto-allocate-nat-external-ips \ --nat-all-subnet-ip-ranges \ --region us-central1
Crea la risorsa "on-premise" Rete VPC (on-prem-vpc
)
Crea la rete VPC:
gcloud compute networks create on-prem-vpc \ --project=$projectid \ --subnet-mode=custom
Crea una subnet denominata
nat-subnet
, con un intervallo IPv4 principale di192.168.10.0/28
:gcloud compute networks subnets create nat-subnet \ --project=$projectid \ --range=192.168.10.0/28 \ --network=on-prem-vpc \ --region=us-central1
Crea una subnet denominata
private-ip-subnet
, con un intervallo IPv4 principale di192.168.20.0/28
:gcloud compute networks subnets create private-ip-subnet \ --project=$projectid \ --range=192.168.20.0/28 \ --network=on-prem-vpc \ --region=us-central1
Crea un router Cloud a livello di regione denominato
cloud-router-us-central1-on-prem-nat
:gcloud compute routers create cloud-router-us-central1-on-prem-nat \ --network on-prem-vpc \ --region us-central1
Aggiungi un gateway Cloud NAT al router Cloud:
gcloud compute routers nats create cloud-nat-us-central1 \ --router=cloud-router-us-central1-on-prem-nat \ --auto-allocate-nat-external-ips \ --nat-all-subnet-ip-ranges \ --region us-central1
Crea l'endpoint Private Service Connect (PSC)
In questa sezione, creerai il file Private Service Connect (PSC)
endpoint utilizzato dalle istanze VM nella rete on-prem-vpc
per accedere
tramite l'API Vertex AI.
L'endpoint Private Service Connect (PSC) è un indirizzo IP interno
indirizzo nella rete on-prem-vpc
a cui i client possono accedere direttamente
in quella rete. Questo endpoint viene creato eseguendo il deployment di una regola di forwarding
che indirizza il traffico di rete che corrisponde all'indirizzo IP dell'endpoint PSC
a un bundle di API di Google.
L'endpoint PSC
L'indirizzo IP (100.100.10.10
) verrà pubblicizzato dalla
aiml-vpc-cloud-router-vpn
come route annunciata personalizzata verso
la rete on-premise in un passaggio successivo.
Prenota gli indirizzi IP per l'endpoint PSC:
gcloud compute addresses create psc-ip \ --global \ --purpose=PRIVATE_SERVICE_CONNECT \ --addresses=100.100.10.10 \ --network=aiml-vpc
Crea l'endpoint PSC:
gcloud compute forwarding-rules create pscvertex \ --global \ --network=aiml-vpc \ --address=psc-ip \ --target-google-apis-bundle=all-apis
Elenca gli endpoint PSC configurati e verifica che l'endpoint
pscvertex
è stato creato:gcloud compute forwarding-rules list \ --filter target="(all-apis OR vpc-sc)" --global
Ottieni i dettagli dell'endpoint PSC configurato e verifica che l'IP l'indirizzo è
100.100.10.10
:gcloud compute forwarding-rules describe pscvertex \ --global
Configura la connettività ibrida
In questa sezione, creerai due (VPN ad alta disponibilità) collegati tra loro. Ogni gateway contiene un un router Cloud e una coppia di tunnel VPN.
Crea il gateway VPN ad alta disponibilità per la rete VPC
aiml-vpc
:gcloud compute vpn-gateways create aiml-vpn-gw \ --network=aiml-vpc \ --region=us-central1
Crea il gateway VPN ad alta disponibilità per la rete VPC
on-prem-vpc
:gcloud compute vpn-gateways create on-prem-vpn-gw \ --network=on-prem-vpc \ --region=us-central1
Nella console Google Cloud, vai alla pagina VPN.
Nella pagina VPN, fai clic sulla scheda Gateway Cloud VPN.
Nell'elenco dei gateway VPN, verifica che ci siano due gateway e che ciascuno ha due indirizzi IP.
In Cloud Shell, crea un router Cloud per
aiml-vpc
Rete Virtual Private Cloud:gcloud compute routers create aiml-cr-us-central1 \ --region=us-central1 \ --network=aiml-vpc \ --asn=65001
Crea un router Cloud per
on-prem-vpc
Rete Virtual Private Cloud:gcloud compute routers create on-prem-cr-us-central1 \ --region=us-central1 \ --network=on-prem-vpc \ --asn=65002
Crea i tunnel VPN per aiml-vpc
Crea un tunnel VPN denominato
aiml-vpc-tunnel0
:gcloud compute vpn-tunnels create aiml-vpc-tunnel0 \ --peer-gcp-gateway on-prem-vpn-gw \ --region us-central1 \ --ike-version 2 \ --shared-secret [ZzTLxKL8fmRykwNDfCvEFIjmlYLhMucH] \ --router aiml-cr-us-central1 \ --vpn-gateway aiml-vpn-gw \ --interface 0
Crea un tunnel VPN denominato
aiml-vpc-tunnel1
:gcloud compute vpn-tunnels create aiml-vpc-tunnel1 \ --peer-gcp-gateway on-prem-vpn-gw \ --region us-central1 \ --ike-version 2 \ --shared-secret [bcyPaboPl8fSkXRmvONGJzWTrc6tRqY5] \ --router aiml-cr-us-central1 \ --vpn-gateway aiml-vpn-gw \ --interface 1
Crea i tunnel VPN per on-prem-vpc
Crea un tunnel VPN denominato
on-prem-vpc-tunnel0
:gcloud compute vpn-tunnels create on-prem-tunnel0 \ --peer-gcp-gateway aiml-vpn-gw \ --region us-central1 \ --ike-version 2 \ --shared-secret [ZzTLxKL8fmRykwNDfCvEFIjmlYLhMucH] \ --router on-prem-cr-us-central1 \ --vpn-gateway on-prem-vpn-gw \ --interface 0
Crea un tunnel VPN denominato
on-prem-vpc-tunnel1
:gcloud compute vpn-tunnels create on-prem-tunnel1 \ --peer-gcp-gateway aiml-vpn-gw \ --region us-central1 \ --ike-version 2 \ --shared-secret [bcyPaboPl8fSkXRmvONGJzWTrc6tRqY5] \ --router on-prem-cr-us-central1 \ --vpn-gateway on-prem-vpn-gw \ --interface 1
Nella console Google Cloud, vai alla pagina VPN.
Nella pagina VPN, fai clic sulla scheda Tunnel Cloud VPN.
Nell'elenco dei tunnel VPN, verifica che quattro tunnel VPN siano stati la creazione di un progetto.
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, aiml-vpc
) e
rete on-premise (rappresentata da on-prem-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 aiml-vpc
e
due per on-prem-vpc
.
Stabilisci sessioni BGP per aiml-vpc
In Cloud Shell, crea la prima interfaccia BGP:
gcloud compute routers add-interface aiml-cr-us-central1 \ --interface-name if-tunnel0-to-onprem \ --ip-address 169.254.1.1 \ --mask-length 30 \ --vpn-tunnel aiml-vpc-tunnel0 \ --region us-central1
Crea il primo peer BGP:
gcloud compute routers add-bgp-peer aiml-cr-us-central1 \ --peer-name bgp-on-premises-tunnel0 \ --interface if-tunnel1-to-onprem \ --peer-ip-address 169.254.1.2 \ --peer-asn 65002 \ --region us-central1
Crea la seconda interfaccia BGP:
gcloud compute routers add-interface aiml-cr-us-central1 \ --interface-name if-tunnel1-to-onprem \ --ip-address 169.254.2.1 \ --mask-length 30 \ --vpn-tunnel aiml-vpc-tunnel1 \ --region us-central1
Crea il secondo peer BGP:
gcloud compute routers add-bgp-peer aiml-cr-us-central1 \ --peer-name bgp-on-premises-tunnel1 \ --interface if-tunnel2-to-onprem \ --peer-ip-address 169.254.2.2 \ --peer-asn 65002 \ --region us-central1
Stabilisci sessioni BGP per on-prem-vpc
Crea la prima interfaccia BGP:
gcloud compute routers add-interface on-prem-cr-us-central1 \ --interface-name if-tunnel0-to-aiml-vpc \ --ip-address 169.254.1.2 \ --mask-length 30 \ --vpn-tunnel on-prem-tunnel0 \ --region us-central1
Crea il primo peer BGP:
gcloud compute routers add-bgp-peer on-prem-cr-us-central1 \ --peer-name bgp-aiml-vpc-tunnel0 \ --interface if-tunnel1-to-aiml-vpc \ --peer-ip-address 169.254.1.1 \ --peer-asn 65001 \ --region us-central1
Crea la seconda interfaccia BGP:
gcloud compute routers add-interface on-prem-cr-us-central1 \ --interface-name if-tunnel1-to-aiml-vpc \ --ip-address 169.254.2.2 \ --mask-length 30 \ --vpn-tunnel on-prem-tunnel1 \ --region us-central1
Crea il secondo peer BGP:
gcloud compute routers add-bgp-peer on-prem-cr-us-central1 \ --peer-name bgp-aiml-vpc-tunnel1 \ --interface if-tunnel2-to-aiml-vpc \ --peer-ip-address 169.254.2.1 \ --peer-asn 65001 \ --region us-central1
Convalida la creazione di una sessione BGP
Nella console Google Cloud, vai alla pagina VPN.
Nella pagina VPN, fai clic sulla scheda Tunnel Cloud VPN.
Nell'elenco dei tunnel VPN, ora dovresti vedere che il valore nel campo La colonna Stato sessione BGP per ciascuno dei quattro 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.
Verifica che aiml-vpc
abbia appreso route di subnet su VPN ad alta disponibilità
Nella console Google Cloud, vai alla pagina Reti VPC.
Nell'elenco delle reti VPC, fai clic su
aiml-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
aiml-vpc
La rete VPC ha appreso le route La subnetnat-subnet
(192.168.10.0/28
) delle reti VPC dion-prem-vpc
eprivate-ip-subnet
(192.168.20.0/28
).
Verifica che on-prem-vpc
abbia appreso route di subnet su VPN ad alta disponibilità
Nella console Google Cloud, vai alla pagina Reti VPC.
Nell'elenco delle reti VPC, fai clic su
on-prem-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
on-prem-vpc
La rete VPC ha appreso le route Subnetworkbench-subnet
(172.16.10.0/28
) delle reti VPC diaiml-vpc
.
Crea una route pubblicizzata personalizzata per aiml-vpc
L'indirizzo IP dell'endpoint di Private Service Connect non viene automaticamente
pubblicizzato dal router Cloud aiml-cr-us-central1
perché la subnet è
non configurato nella rete VPC.
Di conseguenza, dovrai creare una route annunciata personalizzata dal
aiml-cr-us-central
Router Cloud per l'indirizzo IP dell'endpoint 100.100.10.10
pubblicizzato nell'ambiente on-premise su BGP al on-prem-vpc
.
Nella console Google Cloud, vai alla pagina Router Cloud.
Nell'elenco Router Cloud, fai clic su
aiml-cr-us-central1
.Nella pagina Dettagli router, fai clic su
Modifica.Nella sezione Route annunciate, per Route, seleziona Crea route personalizzate.
Fai clic su Aggiungi una route personalizzata.
Per Origine, seleziona Intervallo IP personalizzato.
In Intervallo di indirizzi IP, inserisci
100.100.10.10
.In Descrizione, inserisci
Private Service Connect Endpoint IP
.Fai clic su Fine e poi su Salva.
Verifica che on-prem-vpc
abbia appreso l'indirizzo IP dell'endpoint PSC tramite la VPN ad alta disponibilità
Nella console Google Cloud, vai alla pagina Reti VPC.
Nell'elenco delle reti VPC, fai clic su
on-prem-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
on-prem-vpc
La rete VPC ha appreso l'indirizzo IP dell'endpoint PSC (100.100.10.10
).
Crea una route pubblicizzata personalizzata per on-prem-vpc
Il router Cloud on-prem-vpc
pubblicizza tutte le subnet per impostazione predefinita,
ma è necessaria solo la subnet private-ip-subnet
.
Nella sezione seguente, aggiorna gli annunci di route dalla
on-prem-cr-us-central1
Router Cloud.
Nella console Google Cloud, vai alla pagina Router Cloud.
Nell'elenco Router Cloud, fai clic su
on-prem-cr-us-central1
.Nella pagina Dettagli router, fai clic su
Modifica.Nella sezione Route annunciate, per Route, seleziona Crea route personalizzate.
Se la casella di controllo Pubblicizza tutte le subnet visibili al router Cloud è selezionato, cancellalo.
Fai clic su Aggiungi una route personalizzata.
Per Origine, seleziona Intervallo IP personalizzato.
In Intervallo di indirizzi IP, inserisci
192.168.20.0/28
.In Descrizione, inserisci
Private Service Connect Endpoint IP subnet (private-ip-subnet)
.Fai clic su Fine e poi su Salva.
Verifica che aiml-vpc
abbia appreso la route private-ip-subnet
da on-prem-vpc
Nella console Google Cloud, vai alla pagina Reti VPC.
Nell'elenco delle reti VPC, fai clic su
aiml-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
aiml-vpc
La rete VPC ha appreso la routeprivate-ip-subnet
(192.168.20.0/28
).
crea le istanze VM di test
Crea un account di servizio gestito dall'utente
Se hai applicazioni che devono chiamare le API Google Cloud, Google consiglia di allegare un account di servizio gestito dall'utente alla VM su cui sono in esecuzione l'applicazione o il carico di lavoro. Di conseguenza, in questa sezione creiamo un account l'account di servizio da applicare alle istanze VM che creerai in seguito questo tutorial.
In Cloud Shell, crea l'account di servizio:
gcloud iam service-accounts create gce-vertex-sa \ --description="service account for vertex" \ --display-name="gce-vertex-sa"
Assegna il parametro Amministratore istanze Compute (v1) (
roles/compute.instanceAdmin.v1
) ruolo IAM all'account di servizio:gcloud projects add-iam-policy-binding $projectid \ --member="serviceAccount:gce-vertex-sa@$projectid.iam.gserviceaccount.com" \ --role="roles/compute.instanceAdmin.v1"
Assegna il parametro Utente Vertex AI (
roles/aiplatform.user
) ruolo IAM all'account di servizio:gcloud projects add-iam-policy-binding $projectid \ --member="serviceAccount:gce-vertex-sa@$projectid.iam.gserviceaccount.com" \ --role="roles/aiplatform.user"
crea le istanze VM di test
In questo passaggio creerai istanze VM di test per convalidare diverse per raggiungere le API Vertex AI, in particolare:
- L'istanza
nat-client
utilizza Cloud NAT per risolvere Vertex AI per accedere all'endpoint di previsione online sulla rete internet pubblica. - L'istanza
private-client
utilizza Private Service Connect Indirizzo IP100.100.10.10
per accedere all'endpoint di previsione online tramite la VPN ad alta disponibilità.
Per consentire a Identity-Aware Proxy (IAP) di connettersi al tuo VM, devi creare una regola firewall che:
- Si applica a tutte le istanze VM che vuoi rendere accessibili IAP.
- Consente il traffico TCP attraverso la porta 22 dall'intervallo IP
35.235.240.0/20
. Questo intervallo contiene tutti gli indirizzi IP Utilizzi IAP per Inoltro TCP.
Crea l'istanza VM
nat-client
:gcloud compute instances create nat-client \ --zone=us-central1-a \ --image-family=debian-11 \ --image-project=debian-cloud \ --subnet=nat-subnet \ --service-account=gce-vertex-sa@$projectid.iam.gserviceaccount.com \ --scopes=https://www.googleapis.com/auth/cloud-platform \ --no-address \ --metadata startup-script="#! /bin/bash sudo apt-get update sudo apt-get install tcpdump dnsutils -y"
Crea l'istanza VM
private-client
:gcloud compute instances create private-client \ --zone=us-central1-a \ --image-family=debian-11 \ --image-project=debian-cloud \ --subnet=private-ip-subnet \ --service-account=gce-vertex-sa@$projectid.iam.gserviceaccount.com \ --scopes=https://www.googleapis.com/auth/cloud-platform \ --no-address \ --metadata startup-script="#! /bin/bash sudo apt-get update sudo apt-get install tcpdump dnsutils -y"
Crea la regola firewall IAP:
gcloud compute firewall-rules create ssh-iap-on-prem-vpc \ --network on-prem-vpc \ --allow tcp:22 \ --source-ranges=35.235.240.0/20
crea un'istanza di Vertex AI Workbench
Crea un account di servizio gestito dall'utente per Vertex AI Workbench
Quando crei un'istanza di Vertex AI Workbench,
Google consiglia vivamente di specificare un account di servizio gestito dall'utente
dell'utilizzo dell'account di servizio predefinito
di Compute Engine.
Se la tua organizzazione non applica in modo forzato
iam.automaticIamGrantsForDefaultServiceAccounts
vincolo dei criteri dell'organizzazione, l'account di servizio predefinito
(quindi chiunque specifichi
come utente istanza) riceve il ruolo Editor (roles/editor
) nel tuo
progetto Google Cloud. Per disattivare questo comportamento, consulta
Disabilita le concessioni automatiche di ruoli per gli account di servizio predefiniti.
In Cloud Shell, crea un account di servizio denominato
workbench-sa
:gcloud iam service-accounts create workbench-sa \ --display-name="workbench-sa"
Assegna il parametro Amministratore Storage (
roles/storage.admin
) ruolo IAM 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 parametro Utente Vertex AI (
roles/aiplatform.user
) ruolo IAM 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 parametro Amministratore Artifact Registry ruolo IAM all'account di servizio:
gcloud projects add-iam-policy-binding $projectid \ --member="serviceAccount:workbench-sa@$projectid.iam.gserviceaccount.com" \ --role="roles/artifactregistry.admin"
crea l'istanza di Vertex AI Workbench
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
Crea ed esegui il deployment di un modello di previsione online
prepara l'ambiente
Nella console Google Cloud, vai a Istanze nella pagina Vertex AI Workbench.
Accanto al nome dell'istanza di Vertex AI Workbench (
workbench-tutorial
), fai clic su Apri JupyterLab.La tua istanza di Vertex AI Workbench apre JupyterLab.
Nel resto di questa sezione, fino al deployment del modello, lavorerai in Jupyterlab, non nella console Google Cloud in Cloud Shell.
Seleziona File > Nuovo > Terminale.
Nel terminale JupyterLab (non in Cloud Shell), devi definire una variabile di ambiente progetto. Sostituisci PROJECT_ID con l'ID progetto:
PROJECT_ID=PROJECT_ID
Crea una nuova directory denominata
cpr-codelab
ecd
al suo interno (ancora in il terminale JupyterLab):mkdir cpr-codelab cd cpr-codelab
Nel browser file
, fai doppio clic sulla nuova cartellacpr-codelab
.Se questa cartella non viene visualizzata nel browser di file, aggiorna Google Cloud nella scheda del browser della console e riprova.
Seleziona File > Nuovo > Blocco note.
Dal menu Seleziona kernel, seleziona Python [conda env:base] * (Local) e fai clic su Seleziona.
Rinomina il nuovo file del blocco note come segue:
Nel browser file
, fai clic con il pulsante destro del mouse sull'icona del fileUntitled.ipynb
e inseriscitask.ipynb
.La directory
cpr-codelab
ora dovrebbe avere il seguente aspetto:+ cpr-codelab/ + task.ipynb
Nei passaggi seguenti, creerai il tuo modello nel blocco note Jupyterlab creando nuove celle del blocco note, incollando codice al loro interno ed eseguire le celle.
Installa le dipendenze come segue.
Quando apri il 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. In questo campo di testo devi incollare il codice.Incolla il codice seguente nella cella e fai clic su
Esegui le celle selezionate e avanza per creare unrequirements.txt
file da utilizzare come input al passaggio seguente:%%writefile requirements.txt fastapi uvicorn==0.17.6 joblib~=1.1.1 numpy>=1.17.3, <1.24.0 scikit-learn>=1.2.2 pandas google-cloud-storage>=2.2.1,<3.0.0dev google-cloud-aiplatform[prediction]>=1.18.2
In questo passaggio e in ognuno di quelli successivi, aggiungi una cella di codice facendo clic su
Inserisci una cella sotto, incolla il codice nella cella e fai clic su Esegui le celle selezionate e avanza.Utilizza
Pip
per installare le dipendenze nell'istanza dei blocchi note:!pip install -U --user -r requirements.txt
Al termine dell'installazione, seleziona Kernel > Riavvia kernel per riavviare il kernel e assicurarsi che la libreria sia disponibile per l'importazione.
Incolla il codice seguente in una nuova cella del blocco note per creare le directory per archiviare il modello e gli artefatti di pre-elaborazione:
USER_SRC_DIR = "src_dir" !mkdir $USER_SRC_DIR !mkdir model_artifacts # copy the requirements to the source dir !cp requirements.txt $USER_SRC_DIR/requirements.txt
Nel browser file
, La struttura della directorycpr-codelab
ora dovrebbe essere simile alla seguente:+ cpr-codelab/ + model_artifacts/ + src_dir/ + requirements.txt + requirements.txt + task.ipynb
Addestra il modello
Continua ad aggiungere celle di codice al blocco note task.ipynb
, quindi incollale
esegui questo codice in ogni nuova cella:
Importa le librerie:
import seaborn as sns import numpy as np import pandas as pd from sklearn import preprocessing from sklearn.ensemble import RandomForestRegressor from sklearn.pipeline import make_pipeline from sklearn.compose import make_column_transformer import joblib import logging # set logging to see the docker container logs logging.basicConfig(level=logging.INFO)
Definisci le seguenti variabili, sostituendo PROJECT_ID con il tuo ID progetto:
REGION = "us-central1" MODEL_ARTIFACT_DIR = "sklearn-model-artifacts" REPOSITORY = "diamonds" IMAGE = "sklearn-image" MODEL_DISPLAY_NAME = "diamonds-cpr" PROJECT_ID = "PROJECT_ID" BUCKET_NAME = "gs://PROJECT_ID-cpr-bucket"
Crea un bucket Cloud Storage:
!gcloud storage buckets create $BUCKET_NAME --location=us-central1
Carica i dati dalla libreria Seaborn e crea due frame di dati, una con le caratteristiche e l'altra con l'etichetta:
data = sns.load_dataset('diamonds', cache=True, data_home=None) label = 'price' y_train = data['price'] x_train = data.drop(columns=['price'])
Osserva i dati di addestramento e verifica che ogni riga rappresenti un rombo.
x_train.head()
Guarda le etichette, che sono i prezzi corrispondenti.
y_train.head()
Definisci una trasformazione di colonna sklearn in con codifica one-hot le caratteristiche categoriche e la scala delle caratteristiche numeriche:
column_transform = make_column_transformer( (preprocessing.OneHotEncoder(), [1,2,3]), (preprocessing.StandardScaler(), [0,4,5,6,7,8]))
Definisci il modello di foresta casuale:
regr = RandomForestRegressor(max_depth=10, random_state=0)
Fai un pipeline sklearn. Questa pipeline prende i dati di input, li codifica e li scala e li passa al modello.
my_pipeline = make_pipeline(column_transform, regr)
Addestra il modello:
my_pipeline.fit(x_train, y_train)
Chiama il metodo di previsione sul modello, passando un campione di test.
my_pipeline.predict([[0.23, 'Ideal', 'E', 'SI2', 61.5, 55.0, 3.95, 3.98, 2.43]])
Potresti vedere avvisi come
"X does not have valid feature names, but"
, ma puoi ignorarli.Salva la pipeline nella directory
model_artifacts
e copiala nella tua Bucket Cloud Storage:joblib.dump(my_pipeline, 'model_artifacts/model.joblib') !gcloud storage cp model_artifacts/model.joblib {BUCKET_NAME}/{MODEL_ARTIFACT_DIR}/
Salva un artefatto di pre-elaborazione
Creare un artefatto di pre-elaborazione. Questo artefatto verrà caricato container personalizzato all'avvio del server del modello. La tua pre-elaborazione l'artefatto può essere di quasi ogni formato (ad esempio un file di pickle), ma in questo caso, scriverai un dizionario in un file JSON:
clarity_dict={"Flawless": "FL", "Internally Flawless": "IF", "Very Very Slightly Included": "VVS1", "Very Slightly Included": "VS2", "Slightly Included": "S12", "Included": "I3"}
Crea un container di pubblicazione personalizzato utilizzando il server del modello CPR
La funzionalità
clarity
nei nostri dati di addestramento era sempre in forma abbreviata (ad es. "FL" anziché "Flawless"). Al momento della pubblicazione, vogliamo controllare anche i dati per questa funzione sono abbreviati. Questo perché le nostre modello sa come codificare a caldo "FL" ma non "impeccabile". Scriverai questa logica di pre-elaborazione personalizzata in un secondo momento. Ma per il momento, ti basta salvare di ricerca in un file JSON e scrivilo nel tuo Bucket Cloud Storage:import json with open("model_artifacts/preprocessor.json", "w") as f: json.dump(clarity_dict, f) !gcloud storage cp model_artifacts/preprocessor.json {BUCKET_NAME}/{MODEL_ARTIFACT_DIR}/
Nel browser file
, la struttura della directory dovrebbe avere un aspetto nel seguente modo:+ cpr-codelab/ + model_artifacts/ + model.joblib + preprocessor.json + src_dir/ + requirements.txt + requirements.txt + task.ipynb
Nel blocco note, incolla ed esegui il codice seguente per creare una sottoclasse
SklearnPredictor
e scrivilo in un file Python nel filesrc_dir/
. Tieni presente che in questo esempio stiamo personalizzando solo il caricamento, la pre-elaborazione post-elaborazione e non il metodo di previsione.%%writefile $USER_SRC_DIR/predictor.py import joblib import numpy as np import json from google.cloud import storage from google.cloud.aiplatform.prediction.sklearn.predictor import SklearnPredictor class CprPredictor(SklearnPredictor): def __init__(self): return def load(self, artifacts_uri: str) -> None: """Loads the sklearn pipeline and preprocessing artifact.""" super().load(artifacts_uri) # open preprocessing artifact with open("preprocessor.json", "rb") as f: self._preprocessor = json.load(f) def preprocess(self, prediction_input: np.ndarray) -> np.ndarray: """Performs preprocessing by checking if clarity feature is in abbreviated form.""" inputs = super().preprocess(prediction_input) for sample in inputs: if sample[3] not in self._preprocessor.values(): sample[3] = self._preprocessor[sample[3]] return inputs def postprocess(self, prediction_results: np.ndarray) -> dict: """Performs postprocessing by rounding predictions and converting to str.""" return {"predictions": [f"${value}" for value in np.round(prediction_results)]}
Usa l'SDK Vertex AI per Python per creare l'immagine utilizzando la previsione personalizzata di Google Cloud. Viene generato il Dockerfile e viene creata un'immagine per te.
from google.cloud import aiplatform aiplatform.init(project=PROJECT_ID, location=REGION) import os from google.cloud.aiplatform.prediction import LocalModel from src_dir.predictor import CprPredictor # Should be path of variable $USER_SRC_DIR local_model = LocalModel.build_cpr_model( USER_SRC_DIR, f"{REGION}-docker.pkg.dev/{PROJECT_ID}/{REPOSITORY}/{IMAGE}", predictor=CprPredictor, requirements_path=os.path.join(USER_SRC_DIR, "requirements.txt"), )
Scrivi un file di test con due esempi per la previsione. Uno dei istanze ha il nome chiaro abbreviato, ma l'altra deve convertire per prima cosa.
import json sample = {"instances": [ [0.23, 'Ideal', 'E', 'VS2', 61.5, 55.0, 3.95, 3.98, 2.43], [0.29, 'Premium', 'J', 'Internally Flawless', 52.5, 49.0, 4.00, 2.13, 3.11]]} with open('instances.json', 'w') as fp: json.dump(sample, fp)
Testa il container in locale eseguendo il deployment di un modello locale.
with local_model.deploy_to_local_endpoint( artifact_uri = 'model_artifacts/', # local path to artifacts ) as local_endpoint: predict_response = local_endpoint.predict( request_file='instances.json', headers={"Content-Type": "application/json"}, ) health_check_response = local_endpoint.run_health_check()
Puoi vedere i risultati della previsione con:
predict_response.content
L'output è simile al seguente:
b'{"predictions": ["$479.0", "$586.0"]}'
esegui il deployment del modello nell'endpoint del modello di previsione online
Ora che hai testato il container in locale, è il momento di eseguire il push dell'immagine in Artifact Registry e caricare il modello in Vertex AI Model Registry.
Configurare Docker per accedere ad Artifact Registry.
!gcloud artifacts repositories create {REPOSITORY} \ --repository-format=docker \ --location=us-central1 \ --description="Docker repository" !gcloud auth configure-docker {REGION}-docker.pkg.dev --quiet
Esegui il push dell'immagine.
local_model.push_image()
Carica il modello.
model = aiplatform.Model.upload(local_model = local_model, display_name=MODEL_DISPLAY_NAME, artifact_uri=f"{BUCKET_NAME}/{MODEL_ARTIFACT_DIR}",)
Esegui il deployment del modello:
endpoint = model.deploy(machine_type="n1-standard-2")
Attendi il deployment del modello prima di andare al passaggio successivo. Il deployment richiede circa 10-15 minuti.
Testa il modello di cui hai eseguito il deployment ricevendo una previsione:
endpoint.predict(instances=[[0.23, 'Ideal', 'E', 'VS2', 61.5, 55.0, 3.95, 3.98, 2.43]])
L'output è simile al seguente:
Prediction(predictions=['$479.0'], deployed_model_id='3171115779319922688', metadata=None, model_version_id='1', model_resource_name='projects/721032480027/locations/us-central1/models/8554949231515795456', explanations=None)
Convalida l'accesso a internet pubblico alle API Vertex AI
In questa sezione, accederai alla VM nat-client
in una scheda della sessione Cloud Shell e utilizzarne un'altra
scheda di sessione per convalidare la connettività a Vertex AI
le API eseguendo i comandi dig
e tcpdump
sul dominio
us-central1-aiplatform.googleapis.com
.
In Cloud Shell (Tab Uno), esegui seguenti comandi, sostituendo PROJECT_ID con ID progetto:
projectid=PROJECT_ID gcloud config set project ${projectid}
Accedi all'istanza VM
nat-client
utilizzando IAP:gcloud compute ssh nat-client \ --project=$projectid \ --zone=us-central1-a \ --tunnel-through-iap
Esegui il comando
dig
:dig us-central1-aiplatform.googleapis.com
Dalla VM
nat-client
(scheda Uno), esegui questo comando per convalidare la risoluzione DNS quando invii richiesta di previsione online all'endpoint.sudo tcpdump -i any port 53 -n
Apri una nuova sessione di Cloud Shell (scheda due) facendo clic su
apri una nuova scheda in in Cloud Shell.Nella nuova sessione di Cloud Shell (scheda due), esegui questo comando: sostituendo PROJECT_ID con il tuo ID progetto:
projectid=PROJECT_ID gcloud config set project ${projectid}
Accedi all'istanza VM
nat-client
:gcloud compute ssh --zone "us-central1-a" "nat-client" --project "$projectid"
Dalla VM
nat-client
(scheda 2), utilizza un editor di testo comevim
onano
per creare un fileinstances.json
. Devi anteporresudo
in per avere l'autorizzazione a scrivere sul file, ad esempio:sudo vim instances.json
Aggiungi la seguente stringa di dati al file:
{"instances": [ [0.23, 'Ideal', 'E', 'VS2', 61.5, 55.0, 3.95, 3.98, 2.43], [0.29, 'Premium', 'J', 'Internally Flawless', 52.5, 49.0, 4.00, 2.13, 3.11]]}
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, quindi digitaControl+X
per uscire.
- Se utilizzi
Individua l'ID endpoint di previsione online per Endpoint PSC:
Nella console Google Cloud, nella sezione Vertex AI, vai a scheda Endpoint nella pagina Previsione online.
Trova la riga dell'endpoint che hai creato e denominato
diamonds-cpr_endpoint
.Individua l'ID endpoint a 19 cifre nella colonna ID e copialo.
In Cloud Shell, dalla VM
nat-client
(scheda 2), esegui seguenti comandi, sostituendo PROJECT_ID con ID progetto e ENDPOINT_ID con l'ID endpoint PSC:projectid=PROJECT_ID gcloud config set project ${projectid} ENDPOINT_ID=ENDPOINT_ID
Dalla VM
nat-client
(scheda 2), esegui questo comando per inviare una richiesta di previsione online:curl -X POST -H "Authorization: Bearer $(gcloud auth print-access-token)" -H "Content-Type: application/json" https://us-central1-aiplatform.googleapis.com/v1/projects/${projectid}/locations/us-central1/endpoints/${ENDPOINT_ID}:predict -d @instances.json
Ora che hai eseguito la previsione, vedrai che i risultati di tcpdump
(Scheda uno) mostra l'istanza VM nat-client
(192.168.10.2
) che esegue una
la query Cloud DNS al server DNS locale (169.254.169.254
) per
Dominio API Vertex AI (us-central1-aiplatform.googleapis.com
).
La query DNS restituisce gli indirizzi IP virtuali (VIP) pubblici per
le API Vertex AI.
Convalida l'accesso privato alle API Vertex AI
In questa sezione accederai all'istanza VM private-client
utilizzando
Identity-Aware Proxy in una nuova sessione di Cloud Shell (scheda tre),
e poi si convalida
la connettività alle API Vertex AI eseguendo dig
contro
Dominio Vertex AI (us-central1-aiplatform.googleapis.com
).
Apri una nuova sessione di Cloud Shell (scheda tre) facendo clic su
apri una nuova scheda in in Cloud Shell. Questa è la terza scheda.Nella nuova sessione di Cloud Shell (scheda tre), esegui questo comando: sostituendo PROJECT_ID con il tuo ID progetto:
projectid=PROJECT_ID gcloud config set project ${projectid}
Accedi all'istanza VM
private-client
utilizzando IAP:gcloud compute ssh private-client \ --project=$projectid \ --zone=us-central1-a \ --tunnel-through-iap
Esegui il comando
dig
:dig us-central1-aiplatform.googleapis.com
Nell'istanza VM
private-client
(scheda tre), utilizza un editor di testo comevim
onano
per aggiungere la seguente riga al file/etc/hosts
:100.100.10.10 us-central1-aiplatform.googleapis.com
Questa riga assegna l'indirizzo IP dell'endpoint PSC (
100.100.10.10
) al nome di dominio completo 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 100.100.10.10 us-central1-aiplatform.googleapis.com # Added by you 192.168.20.2 private-client.c.$projectid.internal private-client # Added by Google 169.254.169.254 metadata.google.internal # Added by Google
Dalla VM
private-client
(scheda tre), esegui il ping di Vertex AI endpoint eControl+C
per uscire quando viene visualizzato l'output:ping us-central1-aiplatform.googleapis.com
Il comando
ping
restituisce il seguente output contenente Indirizzo IP dell'endpoint PSC:PING us-central1-aiplatform.googleapis.com (100.100.10.10) 56(84) bytes of data.
Dalla VM
private-client
(scheda tre), usatcpdump
per eseguire seguente comando per la risoluzione DNS e il percorso dei dati IP quando invii richiesta di previsione online all'endpoint:sudo tcpdump -i any port 53 -n or host 100.100.10.10
Apri una nuova sessione di Cloud Shell (scheda 4) facendo clic su
apri una nuova scheda in in Cloud Shell.Nella nuova sessione di Cloud Shell (scheda 4), esegui questi comandi: sostituzione di PROJECT_ID con il tuo ID progetto:
projectid=PROJECT_ID gcloud config set project ${projectid}
Nella scheda quattro, accedi all'istanza
private-client
:gcloud compute ssh \ --zone "us-central1-a" "private-client" \ --project "$projectid"
Dalla VM
private-client
(scheda quattro), utilizzando un editor di testo comevim
onano
, crea un Fileinstances.json
contenente la seguente stringa di dati:{"instances": [ [0.23, 'Ideal', 'E', 'VS2', 61.5, 55.0, 3.95, 3.98, 2.43], [0.29, 'Premium', 'J', 'Internally Flawless', 52.5, 49.0, 4.00, 2.13, 3.11]]}
Dalla VM
private-client
(scheda quattro), esegui questi comandi: sostituendo PROJECT_ID con il nome del tuo progetto ENDPOINT_ID con l'ID endpoint PSC:projectid=PROJECT_ID echo $projectid ENDPOINT_ID=ENDPOINT_ID
Dalla VM
private-client
(scheda 4), esegui questo comando per inviare una richiesta di previsione online:curl -v -X POST -H "Authorization: Bearer $(gcloud auth print-access-token)" -H "Content-Type: application/json" https://us-central1-aiplatform.googleapis.com/v1/projects/${projectid}/locations/us-central1/endpoints/${ENDPOINT_ID}:predict -d @instances.json
Dalla VM
private-client
in Cloud Shell (scheda tre), verifica che PSC l'indirizzo IP dell'endpoint (100.100.10.10
) è stato utilizzato per accedere le API Vertex AI.Dal terminale
private-client
tcpdump
nella scheda tre di Cloud Shell, puoi vedere che una ricerca DNS perus-central1-aiplatform.googleapis.com
non è necessario, perché la riga aggiunta al file/etc/hosts
e nel percorso dei dati viene utilizzato l'indirizzo IP PSC100.100.10.10
.
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 mantenere il progetto ed eliminare Google Cloud.
Puoi eliminare le singole risorse nel progetto nel seguente modo:
Elimina l'istanza di Vertex AI Workbench come segue:
Nella console Google Cloud, nella sezione Vertex AI, vai a Scheda Istanze nella pagina Workbench.
Seleziona
workbench-tutorial
Istanza di Vertex AI Workbench e fai clic su Elimina.
Elimina l'immagine container come segue:
Nella console Google Cloud, vai alla pagina Artifact Registry.
Seleziona il container Docker
diamonds
e fai clic su Elimina.
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.
Annulla il deployment del modello dall'endpoint nel seguente modo:
Nella console Google Cloud, nella sezione Vertex AI, vai a la pagina Endpoint.
Fai clic su
diamonds-cpr_endpoint
per andare alla pagina dei dettagli dell'endpoint.Nella riga relativa al modello,
diamonds-cpr
, fai clic su Annulla deployment modello .Nella finestra di dialogo Annulla il deployment del modello nell'endpoint, fai clic su Annulla deployment.
Elimina il modello come segue:
Nella console Google Cloud, nella sezione Vertex AI, vai alla pagina Model Registry.
Seleziona il modello
diamonds-cpr
.Per eliminare il modello, fai clic su
Azioni e poi fai clic su Elimina modello.
Elimina l'endpoint di previsione online come segue:
Nella console Google Cloud, nella sezione Vertex AI, vai alla pagina Previsione online.
Seleziona l'endpoint
diamonds-cpr_endpoint
.Per eliminare l'endpoint, fai clic su
Azioni, quindi fai clic su Elimina endpoint.
In Cloud Shell, elimina le risorse rimanenti eseguendo questi comandi.
projectid=PROJECT_ID gcloud config set project ${projectid}
gcloud compute forwarding-rules delete pscvertex \ --global \ --quiet
gcloud compute addresses delete psc-ip \ --global \ --quiet
gcloud compute networks subnets delete workbench-subnet \ --region=us-central1 \ --quiet
gcloud compute vpn-tunnels delete aiml-vpc-tunnel0 aiml-vpc-tunnel1 on-prem-tunnel0 on-prem-tunnel1 \ --region=us-central1 \ --quiet
gcloud compute vpn-gateways delete aiml-vpn-gw on-prem-vpn-gw \ --region=us-central1 \ --quiet
gcloud compute routers delete aiml-cr-us-central1 cloud-router-us-central1-aiml-nat \ --region=us-central1 \ --quiet
gcloud compute routers delete cloud-router-us-central1-on-prem-nat on-prem-cr-us-central1 \ --region=us-central1 \ --quiet
gcloud compute instances delete nat-client private-client \ --zone=us-central1-a \ --quiet
gcloud compute firewall-rules delete ssh-iap-on-prem-vpc \ --quiet
gcloud compute networks subnets delete nat-subnet private-ip-subnet \ --region=us-central1 \ --quiet
gcloud compute networks delete on-prem-vpc \ --quiet
gcloud compute networks delete aiml-vpc \ --quiet
Passaggi successivi
- Informazioni su opzioni di networking aziendali per accedere agli endpoint e ai servizi Vertex AI
- Impara 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 ad 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
su larga scala ambienti di produzione.