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

Gli host on-premise possono raggiungere un endpoint di previsione online di Vertex AI tramite internet pubblico o in privato tramite un'architettura di rete ibrida che utilizza Private Service Connect (PSC) su Cloud VPN o Cloud Interconnect. Entrambe le opzioni offrono la crittografia SSL/TLS. Tuttavia, l'opzione privata offre prestazioni molto migliori ed è quindi consigliata per le applicazioni critiche.

In questo tutorial utilizzi la VPN ad alta disponibilità (HA VPN) per accedere a un endpoint di previsione online sia pubblicamente, tramite Cloud NAT, sia privatamente, tra due reti Virtual Private Cloud che possono servire da base per la connettività privata multi-cloud e on-premise.

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

Diagramma di architettura per l'accesso a un endpoint di previsione online tramite Private Service Connect.

Obiettivi

  • Crea due reti Virtual Private Cloud (VPC), come mostrato nel diagramma precedente:
    • Uno (on-prem-vpc) rappresenta una rete on-premise.
    • L'altro (aiml-vpc) è per la creazione e il deployment di un modello di previsione online di Vertex AI.
  • Esegui il deployment di gateway VPN ad alta disponibilità, tunnel Cloud VPN e router Cloud per connettere aiml-vpc e on-prem-vpc.
  • Crea ed esegui il deployment di un modello di previsione online di Vertex AI.
  • Crea un endpoint Private Service Connect (PSC) per inoltrare le richieste di previsione online private al modello di cui è stato eseguito il deployment.
  • Attiva la modalità di annuncio personalizzato del router Cloud in aiml-vpc per annunci route per l'endpoint Private Service Connect a on-prem-vpc.
  • Crea due istanze VM Compute Engine in on-prem-vpc per rappresentare le applicazioni client:
    • Uno (nat-client) invia richieste di previsione online tramite internet pubblico (tramite Cloud NAT). Questo metodo di accesso è indicato da una freccia rossa e dal numero 1 nel diagramma.
    • L'altra (private-client) invia richieste di previsione in privato tramite VPN ad alta disponibilità. Questo metodo di accesso è indicato da una freccia verde e dal numero 2.

Costi

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

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

Al termine delle attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la sezione 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 i tuoi progetti e le tue risorse dal 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. 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: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.

  7. 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 crei due reti VPC: una per creare un modello di previsione online ed eseguirne il deployment in un endpoint e l'altra per l'accesso privato a quell'endpoint. In ognuna 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 per l'endpoint di previsione online (aiml-vpc)

  1. Crea la rete VPC:

    gcloud compute networks create aiml-vpc \
    --project=$projectid \
    --subnet-mode=custom

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

  3. Crea un router Cloud regionale denominato cloud-router-us-central1-aiml-nat:

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

  4. 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 rete VPC "on-premise" (on-prem-vpc)

  1. Crea la rete VPC:

    gcloud compute networks create on-prem-vpc \
    --project=$projectid \
    --subnet-mode=custom

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

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

  4. Crea un router Cloud regionale 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

  5. 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 crei l'endpoint Private Service Connect (PSC) utilizzato dalle istanze VM nella rete on-prem-vpc per accedere all'endpoint di previsione online tramite l'API Vertex AI. L'endpoint Private Service Connect (PSC) è un indirizzo IP interno della rete on-prem-vpc a cui i client della rete possono accedere direttamente. Questo endpoint viene creato eseguendo il deployment di una regola di forwarding che indirizza il traffico di rete corrispondente all'indirizzo IP dell'endpoint PSC a un bundle di API di Google. L'indirizzo IP (100.100.10.10) dell'endpoint PSC verrà annunciato dal router Cloud aiml-cr-us-central1 come route annunciata personalizzata alla rete on-prem-vpc in un passaggio successivo.

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

  2. Crea l'endpoint PSC:

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

  3. Elenca gli endpoint PSC configurati e verifica che l'endpoint pscvertex sia stato creato:

    gcloud compute forwarding-rules list \
    --filter target="(all-apis OR vpc-sc)" --global

  4. Visualizza i dettagli dell'endpoint PSC configurato e verifica che l'indirizzo IP sia 100.100.10.10:

    gcloud compute forwarding-rules describe pscvertex \
    --global

Configura la connettività ibrida

In questa sezione crei due gateway VPN ad alta disponibilità connessi tra loro. Ogni gateway contiene un router Cloud e una coppia di tunnel VPN.

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

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

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

    Vai a VPN

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

  5. Nell'elenco dei gateway VPN, verifica che siano presenti due gateway e che ciascuno abbia due indirizzi IP.

  6. In Cloud Shell, crea un router Cloud per la rete aiml-vpc Virtual Private Cloud:

    gcloud compute routers create aiml-cr-us-central1 \
    --region=us-central1 \
    --network=aiml-vpc \
    --asn=65001

  7. Crea un router Cloud per la rete on-prem-vpc 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

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

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

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

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

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

    Vai a VPN

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

  5. Nell'elenco dei tunnel VPN, verifica che siano stati stabiliti quattro tunnel VPN.

Definizione di sessioni BGP

Router Cloud utilizza il protocollo BGP (Border Gateway Protocol) per scambiare le route tra la tua rete VPC (in questo caso aiml-vpc) e la tua rete on-premise (rappresentata da on-prem-vpc). Su Cloud Router, 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 altre due per on-prem-vpc.

Stabilisci sessioni BGP per aiml-vpc

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

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

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

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

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

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

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

  4. 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 della sessione BGP

  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, ora dovresti vedere che il valore nella colonna Stato sessione BGP per ciascuno dei quattro tunnel è passato da Configura sessione BGP a BGP stabilito. Per visualizzare i nuovi valori, potresti dover aggiornare la scheda del browser della console Google Cloud.

Verifica che aiml-vpc abbia appreso le route delle sottoreti tramite la VPN ad alta disponibilità

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

    Vai a Reti VPC

  2. Nell'elenco delle reti VPC, fai clic su aiml-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 la rete VPC aiml-vpc abbia appreso le route dalle subnet nat-subnet (192.168.10.0/28) e private-ip-subnet (192.168.20.0/28) delle reti VPC on-prem-vpc.

Verifica che on-prem-vpc abbia appreso le route delle sottoreti tramite la VPN ad alta disponibilità

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

    Vai a Reti VPC

  2. Nell'elenco delle reti VPC, fai clic su on-prem-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 la rete VPC on-prem-vpc abbia appreso i route dalla subnet workbench-subnet (172.16.10.0/28) delle reti VPC aiml-vpc.

Creare una route pubblicizzata personalizzata per aiml-vpc

L'indirizzo IP dell'endpoint Private Service Connect non viene pubblicizzato automaticamente dal router cloud aiml-cr-us-central1 perché la subnet non è configurata nella rete VPC.

Di conseguenza, dovrai creare una route annunciata personalizzata dal router Cloud aiml-cr-us-central per l'indirizzo IP dell'endpoint 100.100.10.10 annunciata all'ambiente on-premise tramite BGP a on-prem-vpc.

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

    Vai a Router Cloud

  2. Nell'elenco dei router Cloud, fai clic su aiml-cr-us-central1.

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

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

  5. Fai clic su Aggiungi un percorso personalizzato.

  6. In Origine, seleziona Intervallo IP personalizzato.

  7. In Intervallo di indirizzi IP, inserisci 100.100.10.10.

  8. In Descrizione, inserisci Private Service Connect Endpoint IP.

  9. 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à

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

    Vai a Reti VPC

  2. Nell'elenco delle reti VPC, fai clic su on-prem-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 la rete VPC on-prem-vpc abbia appreso l'indirizzo IP dell'endpoint PSC (100.100.10.10).

Creare una route pubblicizzata personalizzata per on-prem-vpc

Per impostazione predefinita, il router Cloud on-prem-vpc pubblicizza tutte le subnet, ma è necessaria solo la subnet private-ip-subnet.

Nella sezione seguente, aggiorna gli annunci di route dal on-prem-cr-us-central1 router Cloud.

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

    Vai a Router Cloud

  2. Nell'elenco dei router Cloud, fai clic su on-prem-cr-us-central1.

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

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

  5. Se la casella di controllo Annuncia tutte le subnet visibili al router Cloud è selezionata, deselezionala.

  6. Fai clic su Aggiungi un percorso personalizzato.

  7. In Origine, seleziona Intervallo IP personalizzato.

  8. In Intervallo di indirizzi IP, inserisci 192.168.20.0/28.

  9. In Descrizione, inserisci Private Service Connect Endpoint IP subnet (private-ip-subnet).

  10. Fai clic su Fine e poi su Salva.

Verifica che aiml-vpc abbia appreso il percorso private-ip-subnet dal on-prem-vpc

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

    Vai a Reti VPC

  2. Nell'elenco delle reti VPC, fai clic su aiml-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 la rete VPC aiml-vpc abbia appreso la route private-ip-subnet (192.168.20.0/28).

Crea le istanze VM di test

Creare un account di servizio gestito dall'utente

Se hai applicazioni che devono chiamare le API Google Cloud, Google consiglia di collegare un account di servizio gestito dall'utente alla VM su cui è in esecuzione l'applicazione o il carico di lavoro. Di conseguenza, in questa sezione crei un account di servizio gestito dall'utente da applicare alle istanze VM che crei in seguito in questo tutorial.

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

  2. Assegna il ruolo IAM Amministratore istanze Compute (v1) (roles/compute.instanceAdmin.v1) 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"

  3. Assegna il ruolo IAM Utente Vertex AI (roles/aiplatform.user) 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 crei istanze VM di test per convalidare diversi metodi 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 tramite la rete internet pubblica.
  • L'istanza private-client utilizza l'indirizzo IP 100.100.10.10 di Private Service Connect per accedere all'endpoint di previsione online tramite VPN ad alta disponibilità.

Per consentire a Identity-Aware Proxy (IAP) di connettersi alle tue istanze VM, crea una regola firewall che:

  • Si applica a tutte le istanze VM che vuoi rendere accessibili tramite IAP.
  • Consente il traffico TCP attraverso la porta 22 dall'intervallo IP 35.235.240.0/20. Questo intervallo contiene tutti gli indirizzi IP utilizzati da IAP per l'inoltro TCP.

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

  2. 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"

  3. 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 anziché utilizzare l'account di servizio predefinito di Compute Engine. Se la tua organizzazione non applica il vincolo delle norme dell'organizzazione iam.automaticIamGrantsForDefaultServiceAccounts, all'account di servizio predefinito di Compute Engine (e quindi a chiunque tu specifichi come utente dell'istanza) viene concesso il ruolo Editor (roles/editor) nel tuo progetto Google Cloud. Per disattivare questo comportamento, consulta Disattivare la concessione automatica dei ruoli per gli account di servizio predefiniti.

  1. In Cloud Shell, crea un account di servizio denominato workbench-sa:

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

  2. Assegna il ruolo IAM Amministratore dello spazio di 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"

  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 ruolo IAM Amministratore del registry di elementi 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

  1. In Cloud Shell, crea un'istanza di Vertex AI Workbench, specificando il 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

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

    Vai a Vertex AI Workbench

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

    L'istanza di Vertex AI Workbench apre JupyterLab.

    Nel resto di questa sezione, fino al deployment del modello incluso, lavorerai in Jupyterlab, non nella console Google Cloud o in Cloud Shell.

  3. Seleziona File > Nuovo > Terminale.

  4. Nel terminale JupyterLab (non in Cloud Shell), definisci una variabile di ambiente per il progetto. Sostituisci PROJECT_ID con l'ID progetto:

    PROJECT_ID=PROJECT_ID

  5. Crea una nuova directory denominata cpr-codelab e cd al suo interno (ancora nel terminale JupyterLab):

    mkdir cpr-codelab
cd cpr-codelab

  6. Nel  File Browser, fai doppio clic sulla nuova cartella cpr-codelab.

    Se questa cartella non viene visualizzata nel browser dei file, aggiorna la scheda del browser della console Google Cloud e riprova.

  7. Seleziona File > Nuovo > Notebook.

  8. Nel menu Seleziona kernel, seleziona Python [conda env:base] * (locale) e fai clic su Seleziona.

  9. Rinomina il nuovo file del notebook come segue:

    Nel  File Browser, fai clic con il tasto destro del mouse sull'icona del file Untitled.ipynb e inserisci task.ipynb.

    La directory cpr-codelab dovrebbe avere il seguente aspetto:

    + cpr-codelab/
   + task.ipynb

    Nei passaggi seguenti, crei il modello nel notebook Jupyterlab creando nuove celle del notebook, incollando il codice al loro interno ed eseguendole.

  10. Installa le dipendenze come segue.

    1. Quando apri il nuovo notebook, è presente una cella di codice predefinita in cui inserire il codice. Sembra [ ]: seguito da un campo di testo. In questo campo di testo devi incollare il codice.

      Incolla il seguente codice nella cella e fai clic su  Esegui le celle selezionate e vai avanti per creare un file requirements.txt da utilizzare come input per il passaggio successivo:

      %%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

    2. In questo passaggio e in ciascuno dei seguenti, aggiungi una cella di codice facendo clic su Inserisci una cella sotto, incolla il codice nella cella e poi fai clic su  Esegui le celle selezionate ed esegui l'avanzamento.

      Utilizza Pip per installare le dipendenze nell'istanza di Notebooks:

      !pip install -U --user -r requirements.txt

    3. Al termine dell'installazione, seleziona Kernel > Riavvia kernel per riavviare il kernel e assicurarti che la libreria sia disponibile per l'importazione.

    4. Incolla il seguente codice in una nuova cella del notebook per creare le directory per archiviare il modello e gli elementi di preelaborazione:

      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  File Browser, la struttura di directory cpr-codelab dovrebbe avere il seguente aspetto:

    + cpr-codelab/
  + model_artifacts/
  + src_dir/
     + requirements.txt
  + requirements.txt
  + task.ipynb

Addestra il modello

Continua ad aggiungere celle di codice al notebook task.ipynb, incolla e esegui il seguente codice in ogni nuova cella:

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

  2. 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"

  3. Crea un bucket Cloud Storage:

    !gcloud storage buckets create $BUCKET_NAME --location=us-central1

  4. Carica i dati dalla libreria seaborn e poi crea due frame di dati, uno con gli elementi e l'altro 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'])

  5. Esamina i dati di addestramento e verifica che ogni riga rappresenti un diamante.

    x_train.head()

  6. Guarda le etichette, che corrispondono ai prezzi.

    y_train.head()

  7. Definisci una trasformazione della colonna sklearn per codificare one-hot le caratteristiche categoriche e eseguire la scalatura delle caratteristiche numeriche:

    column_transform = make_column_transformer(
   (preprocessing.OneHotEncoder(), [1,2,3]),
   (preprocessing.StandardScaler(), [0,4,5,6,7,8]))

  8. Definisci il modello di foresta casuale:

    regr = RandomForestRegressor(max_depth=10, random_state=0)

  9. Crea una 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)

  10. Addestra il modello:

    my_pipeline.fit(x_train, y_train)

  11. Chiama il metodo di previsione sul modello, passando un esempio di test.

    my_pipeline.predict([[0.23, 'Ideal', 'E', 'SI2', 61.5, 55.0, 3.95, 3.98, 2.43]])

    Potresti visualizzare avvisi come "X does not have valid feature names, but", ma puoi ignorarli.

  12. Salva la pipeline nella directory model_artifacts e copiala nel tuo bucket Cloud Storage:

    joblib.dump(my_pipeline, 'model_artifacts/model.joblib')

!gcloud storage cp model_artifacts/model.joblib {BUCKET_NAME}/{MODEL_ARTIFACT_DIR}/

Salvare un artefatto di preelaborazione

  1. Crea un artefatto di preelaborazione. Questo artefatto verrà caricato nel contenitore personalizzato all'avvio del server del modello. L'elemento pre-elaborazione può essere di quasi qualsiasi forma (ad esempio un file 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 contenitore di pubblicazione personalizzato utilizzando il server del modello CPR

  1. La funzionalità clarity nei nostri dati di addestramento era sempre nella forma abbreviata (ad es. "FL" anziché "Perfetto"). Al momento della pubblicazione, vogliamo verificare che anche i dati relativi a questa funzionalità siano abbreviati. Questo perché il nostro modello sa come codificare in one-hot "FL", ma non "Flawless". Scriverai questa logica di preelaborazione personalizzata in un secondo momento. Per il momento, salva questa tabella di ricerca in un file JSON e poi scrivila 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  File Browser, la struttura di directory dovrebbe avere il seguente aspetto:

    + cpr-codelab/
   + model_artifacts/
      + model.joblib
      + preprocessor.json
   + src_dir/
      + requirements.txt
   + requirements.txt
   + task.ipynb

  2. Nel notebook, incolla ed esegui il seguente codice per creare una sottoclasse di SklearnPredictor e scriverla in un file Python in src_dir/. Tieni presente che in questo esempio personalizziamo solo i metodi load, preprocess e postprocess, non il metodo predict.

    %%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)]}

  3. Utilizza l'SDK Vertex AI per Python per creare l'immagine utilizzando routine di previsione personalizzate. Il Dockerfile viene generato e viene creata un'immagine.

    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"),
)

  4. Scrivi un file di test con due esempi per la previsione. Una delle istanze ha il nome abbreviato della chiarezza, ma l'altra deve essere prima convertita.

    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)

  5. Testa il contenitore localmente 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()

  6. Puoi visualizzare i risultati della previsione con:

    predict_response.content

    L'output è il seguente:

    b'{"predictions": ["$479.0", "$586.0"]}'

Esegui il deployment del modello nell'endpoint del modello di previsione online

Ora che hai testato il contenitore in locale, è il momento di eseguire il push dell'immagine in Artifact Registry e caricare il modello in Vertex AI Model Registry.

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

  2. Esegui il push dell'immagine.

    local_model.push_image()

  3. Carica il modello.

    model = aiplatform.Model.upload(local_model = local_model,
                                display_name=MODEL_DISPLAY_NAME,
                                artifact_uri=f"{BUCKET_NAME}/{MODEL_ARTIFACT_DIR}",)

  4. Esegui il deployment del modello:

    endpoint = model.deploy(machine_type="n1-standard-2")

    Attendi il deployment del modello prima di procedere al passaggio successivo. Il deployment dovrebbe richiedere circa 10-15 minuti.

  5. Testa il modello di cui è stato eseguito il deployment ottenendo una previsione:

    endpoint.predict(instances=[[0.23, 'Ideal', 'E', 'VS2', 61.5, 55.0, 3.95, 3.98, 2.43]])

    L'output è il 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 pubblico a internet alle API Vertex AI

In questa sezione, accedi all'istanza VM nat-client in una scheda della sessione Cloud Shell e utilizza un'altra scheda della sessione per convalidare la connettività alle API Vertex AI eseguendo i comandi dig e tcpdump sul dominio us-central1-aiplatform.googleapis.com.

  1. In Cloud Shell (scheda 1), esegui i comandi seguenti, sostituendo PROJECT_ID con il tuo ID progetto:

    projectid=PROJECT_ID
gcloud config set project ${projectid}

  2. Accedi all'istanza VM nat-client utilizzando IAP:

    gcloud compute ssh nat-client \
    --project=$projectid \
    --zone=us-central1-a \
    --tunnel-through-iap

  3. Esegui il comando dig:

    dig us-central1-aiplatform.googleapis.com

  4. Dalla VM nat-client (scheda 1), esegui il seguente comando per verificare la risoluzione DNS quando invii una richiesta di previsione online all'endpoint.

    sudo tcpdump -i any port 53 -n

  5. Apri una nuova sessione Cloud Shell (scheda 2) facendo clic su Apri una nuova scheda in Cloud Shell.

  6. Nella nuova sessione Cloud Shell (scheda 2), esegui i seguenti comandi, sostituendo PROJECT_ID con l'ID progetto:

    projectid=PROJECT_ID
gcloud config set project ${projectid}

  7. Accedi all'istanza VM nat-client:

    gcloud compute ssh --zone "us-central1-a" "nat-client" --project "$projectid"

  8. Dalla VM nat-client (scheda 2), utilizza un editor di testo come vim o nano per creare un file instances.json. Devi anteporre sudo per avere l'autorizzazione di scrittura nel file, ad esempio:

    sudo vim instances.json

  9. 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]]}

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

  11. Individua l'ID endpoint di previsione online per l'endpoint PSC:

    1. Nella console Google Cloud, nella sezione Vertex AI, vai alla scheda Endpoint nella pagina Previsione online.

      Vai a Endpoints

    2. Trova la riga dell'endpoint che hai creato, nominato diamonds-cpr_endpoint.

    3. Individua l'ID endpoint di 19 cifre nella colonna ID e copialo.

  12. In Cloud Shell, dalla VM nat-client (scheda 2), esegui i seguenti comandi, sostituendo PROJECT_ID con il tuo ID progetto e ENDPOINT_ID con l'ID endpoint PSC:

    projectid=PROJECT_ID
gcloud config set project ${projectid}
ENDPOINT_ID=ENDPOINT_ID

  13. Dalla VM nat-client (scheda 2), esegui il seguente 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 tcpdump (scheda 1) mostrano l'istanza VM nat-client (192.168.10.2) che esegue una query Cloud DNS al server DNS locale (169.254.169.254) per il dominio dell'API Vertex AI (us-central1-aiplatform.googleapis.com). La query DNS restituisce indirizzi IP virtuali pubblici (VIP) per le API Vertex AI.

Convalida l'accesso privato alle API Vertex AI

In questa sezione, accedi all'istanza VM private-client utilizzando Identity-Aware Proxy in una nuova sessione Cloud Shell (scheda 3), quindi convalida la connettività alle API Vertex AI eseguendo il comando dig sul dominio Vertex AI (us-central1-aiplatform.googleapis.com).

  1. Apri una nuova sessione Cloud Shell (scheda 3) facendo clic su Apri una nuova scheda in Cloud Shell. Questa è la scheda Tre.

  2. Nella nuova sessione Cloud Shell (scheda 3), esegui i seguenti comandi, sostituendo PROJECT_ID con l'ID progetto:

    projectid=PROJECT_ID
gcloud config set project ${projectid}

  3. Accedi all'istanza VM private-client utilizzando IAP:

    gcloud compute ssh private-client \
    --project=$projectid \
    --zone=us-central1-a \
    --tunnel-through-iap

  4. Esegui il comando dig:

    dig us-central1-aiplatform.googleapis.com

  5. Nell'istanza VM private-client (scheda 3), utilizza un editor di testo come vim o nano 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 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

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

  6. Dalla VM private-client (scheda 3), esegui un ping all'endpoint Vertex AI e premi Control+C per uscire quando viene visualizzato l'output:

    ping us-central1-aiplatform.googleapis.com

    Il comando ping restituisce il seguente output contenente l'indirizzo IP dell'endpoint PSC:

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

  7. Dalla VM private-client (scheda 3), utilizza tcpdump per eseguire il seguente comando per convalidare la risoluzione DNS e il percorso dei dati IP quando invii una richiesta di previsione online all'endpoint:

     sudo tcpdump -i any port 53 -n or host 100.100.10.10

  8. Apri una nuova sessione Cloud Shell (scheda 4) facendo clic su Apri una nuova scheda in Cloud Shell.

  9. Nella nuova sessione Cloud Shell (scheda 4), esegui i seguenti comandi, sostituendo PROJECT_ID con l'ID progetto:

    projectid=PROJECT_ID
gcloud config set project ${projectid}

  10. Nella scheda Quattro, accedi all'istanza private-client:

    gcloud compute ssh \
    --zone "us-central1-a" "private-client" \
    --project "$projectid"

  11. Dalla VM private-client (scheda 4), utilizzando un editor di testo come vim o nano, crea un file instances.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]]}

  12. Dalla VM private-client (scheda 4), esegui i seguenti comandi, sostituendo PROJECT_ID con il nome del progetto e ENDPOINT_ID con l'ID endpoint PSC:

    projectid=PROJECT_ID
echo $projectid
ENDPOINT_ID=ENDPOINT_ID

  13. Dalla VM private-client (scheda 4), esegui il seguente 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

  14. Dalla VM private-client in Cloud Shell (scheda 3), verifica che l'indirizzo IP dell'endpoint PSC (100.100.10.10) sia stato utilizzato per accedere alle API Vertex AI.

    Dal terminale private-client tcpdump nella scheda 3 di Cloud Shell, puoi vedere che non è necessaria una ricerca DNS per us-central1-aiplatform.googleapis.com perché la riga che hai aggiunto al file /etc/hosts ha la precedenza e l'indirizzo IP del PSC 100.100.10.10 viene utilizzato nel percorso dei dati.

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 del progetto nel seguente modo:

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

  2. Elimina l'immagine del contenitore come segue:

    1. Nella console Google Cloud, vai alla pagina Artifact Registry.

      Vai ad Artifact Registry

    2. Seleziona il contenitore Docker diamonds e fai clic su Elimina.

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

  4. Annullare il deployment del modello dall'endpoint come segue:

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

      Vai a Endpoints

    2. Fai clic su diamonds-cpr_endpoint per andare alla pagina dei dettagli dell'endpoint.

    3. Nella riga del modello, diamonds-cpr, fai clic su Annulla il deployment del modello .

    4. Nella finestra di dialogo Annulla il deployment del modello nell'endpoint, fai clic su Annulla deployment.

  5. Elimina il modello come segue:

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

      Vai a Model Registry

    2. Seleziona il modello diamonds-cpr.

    3. Per eliminare il modello, fai clic su Azioni e poi su Elimina modello.

  6. Elimina l'endpoint di previsione online come segue:

    1. Nella console Google Cloud, nella sezione Vertex AI, vai alla pagina Previsione online.

      Vai a Previsione online

    2. Seleziona l'endpoint diamonds-cpr_endpoint.

    3. Per eliminare l'endpoint, fai clic su Azioni e poi su Elimina endpoint.

  7. In Cloud Shell, elimina le risorse rimanenti eseguendo i seguenti comandi.

    Vai a Cloud Shell

    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 nats delete cloud-nat-us-central1 \
    --router=cloud-router-us-central1-aiml-nat \
    --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

    gcloud iam service-accounts delete gce-vertex-sa@$projectid.iam.gserviceaccount.com \
    --quiet

    gcloud iam service-accounts delete workbench-sa@$projectid.iam.gserviceaccount.com \
    --quiet

Passaggi successivi