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

Crea le reti VPC

In questa sezione creerai due reti VPC: una per la creazione di un modello di previsione online e il relativo deployment in un endpoint, l'altra per l'accesso privato a quell'endpoint. In ciascuna delle due reti VPC, crea un router Cloud e un gateway Cloud NAT. Un gateway Cloud NAT fornisce connettività in uscita per le istanze di macchine virtuali (VM) Compute Engine senza indirizzi IP esterni.

Crea la rete VPC 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 172.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 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
   

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

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 creerai 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 nella rete on-prem-vpc a cui i client in quella 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 dell'endpoint PSC (100.100.10.10) verrà pubblicizzato nell'aiml-vpc-cloud-router-vpn come pubblicità personalizzata del router sulla rete on-premise 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. Recupera 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, creerai 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 alla 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 Virtual Private Cloud aiml-vpc:

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

7. Crea un router Cloud per la rete Virtual Private Cloud on-prem-vpc:

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

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 la tua rete on-premise (rappresentata da on-prem-vpc). Sul router Cloud, configuri un'interfaccia e un peer BGP per il tuo router on-premise. L'interfaccia e la configurazione del peer BGP formano insieme una sessione BGP. In questa sezione creerai due sessioni BGP per aiml-vpc e 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 di sessioni BGP

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

   Vai alla 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 è cambiato da Configura sessione BGP in BGP stabilito. Per visualizzare i nuovi valori, potresti dover aggiornare la scheda del browser della console Google Cloud.

Verifica che aiml-vpc abbia appreso route di subnet tramite 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 Route.

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 dalla subnet nat-subnet (192.168.10.0/28) e dalla subnet private-ip-subnet (192.168.20.0/28) delle reti VPC on-prem-vpc.

Verifica che on-prem-vpc abbia appreso route di subnet tramite 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 Route.

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 le route dalla subnet workbench-subnet delle reti VPC aiml-vpc (172.16.10.0/28).

Crea annunci di route personalizzati per aiml-vpc

L'indirizzo IP dell'endpoint di 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 un annuncio di route personalizzato dal router Cloud aiml-cr-us-central per l'indirizzo IP dell'endpoint 100.100.10.10, che verrà pubblicizzato nell'ambiente on-premise tramite BGP su on-prem-vpc.

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

   Vai ai router Cloud

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

3. Nella pagina Dettagli router, fai clic su editModifica.

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

5. Fai clic su Aggiungi una route personalizzata.

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, 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 Route.

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

Crea annunci di route personalizzati 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 dal router Cloud on-prem-cr-us-central1.

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

   Vai ai router Cloud

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

3. Nella pagina Dettagli router, fai clic su editModifica.

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

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

6. Fai clic su Aggiungi una route personalizzata.

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, poi su Salva.

Verifica che aiml-vpc abbia appreso la route private-ip-subnet da 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 Route.

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 creerai un account di servizio gestito dall'utente da applicare alle istanze VM che creerai 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 creerai un'istanza VM di test per convalidare diversi metodi per raggiungere le API Vertex AI, nello specifico:

• L'istanza nat-client utilizza Cloud NAT per risolvere Vertex AI e accedere all'endpoint di previsione online sulla 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, puoi creare 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 dell'intervallo IP 35.235.240.0/20. Questo intervallo contiene tutti gli indirizzi IP che IAP utilizza 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=http://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=http://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 blocchi note gestiti dall'utente

Creare un account di servizio gestito dall'utente

Quando crei un'istanza di blocchi note gestiti dall'utente 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. All'account di servizio predefinito di Compute Engine (e quindi a chiunque specifichi come utente dell'istanza) viene concesso il ruolo Editor (roles/editor) nel tuo progetto Google Cloud. Puoi disabilitare questo comportamento disattivando le concessioni automatiche dei ruoli per gli account di servizio predefiniti.

1. In Cloud Shell, crea un account di servizio denominato user-managed-notebook-sa:

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

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

   gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:user-managed-notebook-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:user-managed-notebook-sa@$projectid.iam.gserviceaccount.com" --role="roles/aiplatform.user"
   

4. Assegna il ruolo IAM Amministratore Artifact Registry all'account di servizio:

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

Crea l'istanza di blocchi note gestiti dall'utente

Creare un'istanza di blocchi note gestiti dall'utente, specificando l'account di servizio user-managed-notebook-sa.

1. Crea l'istanza di blocchi note gestiti dall'utente:

   gcloud notebooks 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 \
      --subnet=workbench-subnet \
      --no-public-ip \
      --service-account=user-managed-notebook-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 Blocchi note gestiti dall'utente nella pagina Vertex AI Workbench.

   Vai ai blocchi note gestiti dall'utente

2. Fai clic su Apri JupyterLab accanto al nome dell'istanza di blocchi note gestiti dall'utente.

   L'istanza di blocchi note gestiti dall'utente apre JupyterLab.

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

3. Seleziona File > Nuovo > Terminale.

4. Nel terminale JupyterLab (non in Cloud Shell), definisci una variabile di ambiente per il tuo 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 browser di file folder, fai doppio clic sulla nuova cartella cpr-codelab.

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

7. Seleziona File > Nuovo > Blocco note.

8. Dal menu Seleziona kernel, seleziona Python 3 e fai clic su Seleziona.

9. Rinomina il nuovo file di blocco note come segue:

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

   La directory cpr-codelab ora dovrebbe avere il seguente aspetto:

   + cpr-codelab/
      + task.ipynb
   

   Nei passaggi seguenti, puoi creare il modello nel blocco note Jupyterlab creando nuove celle del blocco note, incollando il codice ed eseguendo le celle.

10. Installa le dipendenze nel seguente modo.

    1. Quando apri il nuovo blocco note, viene visualizzata una cella di codice predefinita in cui puoi inserire il codice. [ ]: seguito da un campo di testo. Il campo di testo è il punto in cui incolli il codice.

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

       %%writefile requirements.txt
       fastapi
       uvicorn==0.17.6
       joblib~=1.1.1
       numpy>=1.17.3, <1.24.0
       scikit-learn~=1.0.0
       pandas
       google-cloud-storage>=2.2.1,<3.0.0dev
       google-cloud-aiplatform[prediction]>=1.18.2
       

    2. In questo passaggio e in ciascuno di quelli seguenti, aggiungi una cella di codice facendo clic su add Inserisci una cella qui sotto, incolla il codice nella cella e fai clic su play_arrow Esegui le celle selezionate e avanza.

       Utilizza Pip per installare le dipendenze nell'istanza di blocchi note:

       !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 blocco note per creare le directory in cui 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 di file folder, la struttura della directory cpr-codelab dovrebbe ora 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 blocco note task.ipynb, quindi incolla ed 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:

   !gsutil mb -l us-central1 $BUCKET_NAME
   

4. Carica i dati dalla libreria Seaborn, quindi crea due frame di dati, uno con le caratteristiche 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 rombo.

   x_train.head()
   

6. Osserva le etichette, che sono i prezzi corrispondenti.

   y_train.head()
   

7. Definisci una trasformazione della colonna sklearn in una codifica a caldo delle caratteristiche categoriche e scala le caratteristiche numeriche:

   column_transform = make_column_transformer(
      (preprocessing.OneHotEncoder(sparse=False), [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 di sklearn. Questa pipeline acquisisce 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. Richiama il metodo di previsione sul modello, passando un campione di prova.

    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 bucket Cloud Storage:

    joblib.dump(my_pipeline, 'model_artifacts/model.joblib')
    
    !gsutil cp model_artifacts/model.joblib {BUCKET_NAME}/{MODEL_ARTIFACT_DIR}/
    

Salva un artefatto di pre-elaborazione

1. Crea un artefatto di pre-elaborazione. Questo artefatto verrà caricato nel container personalizzato all'avvio del server del modello. L'artefatto di pre-elaborazione può avere quasi qualsiasi forma (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"}
   

Creazione di un container di pubblicazione personalizzato utilizzando il server modello CPR

1. La funzionalità clarity nei nostri dati di addestramento era sempre in forma abbreviata (ad es. "FL" invece di "Flawless"). Al momento della pubblicazione, vogliamo verificare che i dati relativi a questa funzionalità siano abbreviati. Questo perché il nostro modello sa come eseguire una codifica a caldo "FL" ma non "Flawless". scriverai questa logica di pre-elaborazione personalizzata in un secondo momento. Per il momento, però, salva questa tabella di ricerca in un file JSON e poi scrivila nel bucket Cloud Storage:

   import json
   with open("model_artifacts/preprocessor.json", "w") as f:
      json.dump(clarity_dict, f)
   
   !gsutil cp model_artifacts/preprocessor.json {BUCKET_NAME}/{MODEL_ARTIFACT_DIR}/
   

   Nel browser di file folder, la struttura della directory dovrebbe ora avere il seguente aspetto:

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

2. Nel tuo blocco note, incolla ed esegui il codice seguente per sottoclassere lo SklearnPredictor e scriverlo in un file Python in src_dir/. Tieni presente che in questo esempio stiamo personalizzando solo i metodi di caricamento, pre-elaborazione e post-elaborazione, 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)]}
   

3. Usa l'SDK Vertex AI per Python per creare l'immagine utilizzando routine di previsione personalizzate. Il Dockerfile viene generato 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"),
   )
   

4. Scrivi un file di test con due esempi per la previsione. Una delle istanze ha il nome di chiarezza abbreviata, ma deve prima essere 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 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()
   

6. Puoi vedere i risultati della previsione con:

   predict_response.content
   

esegui il deployment del modello sull'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.

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 andare al passaggio successivo. Il deployment dovrebbe richiedere almeno 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]])
   

Convalida l'accesso a internet pubblico alle API Vertex AI

In questa sezione, accedi all'istanza VM nat-client in una scheda della sessione di Cloud Shell e utilizzi un'altra scheda di 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 Uno), 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 Uno), esegui il comando seguente per convalidare la risoluzione DNS quando invii una richiesta di previsione online all'endpoint.

    sudo tcpdump -i any port 53 -n
   

5. Apri una nuova sessione di Cloud Shell (scheda Due) facendo clic su add apri una nuova scheda in Cloud Shell.

6. Nella nuova sessione di Cloud Shell (scheda Due), esegui i comandi seguenti, sostituendo PROJECT_ID con il tuo 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 Due), usa 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, quindi digita :wq per salvare il file e uscire.
    • Se utilizzi nano, digita Control+O e premi Enter per salvare il file, poi digita Control+X per uscire.

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

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

       Vai a Endpoints

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

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

12. In Cloud Shell, dalla VM nat-client (scheda Due), esegui i comandi seguenti, 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 Due), 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" http://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) 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 (VIP) pubblici 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 di Cloud Shell (scheda Tre), quindi convalidi la connettività alle API Vertex AI eseguendo il comando dig sul dominio Vertex AI (us-central1-aiplatform.googleapis.com).

1. Apri una nuova sessione di Cloud Shell (scheda Tre) facendo clic su add apri una nuova scheda in Cloud Shell. Questa è la scheda tre.

2. Nella nuova sessione di Cloud Shell (scheda Tre), esegui i comandi seguenti, sostituendo PROJECT_ID con il tuo ID progetto:

   projectid=PROJECT_ID
   gcloud config set project ${projectid}
   

3. Accedi all'istanza VM private-client tramite 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 Tre), 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 di Google Vertex AI (us-central1-aiplatform.googleapis.com). Il file modificato dovrebbe avere il seguente aspetto:

   127.0.0.1       localhost
   ::1             localhost ip6-localhost ip6-loopback
   ff02::1         ip6-allnodes
   ff02::2         ip6-allrouters
   
   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 Tre), invia un ping all'endpoint Vertex AI e a Control+C per uscire quando vedi l'output:

   ping us-central1-aiplatform.googleapis.com
   

   Il comando ping dovrebbe restituire 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 Tre), utilizza tcpdump per eseguire il comando seguente in modo da convalidare la risoluzione DNS e il percorso 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 di Cloud Shell (scheda Quattro) facendo clic su add apri una nuova scheda in Cloud Shell.

9. Nella nuova sessione di Cloud Shell (scheda Quattro), esegui i comandi seguenti, sostituendo PROJECT_ID con il tuo 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 Quattro), 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 Quattro), esegui i comandi seguenti, sostituendo PROJECT_ID con il nome del progetto e ENDPOINT_ID con l'ID dell'endpoint PSC:

    projectid=PROJECT_ID
    echo $projectid
    ENDPOINT_ID=ENDPOINT_ID
    

13. Dalla VM private-client (scheda Quattro), 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" http://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 Tre), verifica che l'indirizzo IP dell'endpoint PSC (100.100.10.10) sia stato utilizzato per accedere alle API Vertex AI.

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