Questa pagina è stata tradotta dall'API Cloud Translation.

Utilizzare Private Service Connect per accedere alle pipeline di addestramento on-premise

Vertex AI Pipelines è un servizio gestito che ti aiuta a creare, eseguire il deployment e gestire i flussi di lavoro di machine learning (ML) end-to-end sulla piattaforma Google Cloud. Fornisce un ambiente serverless per l'esecuzione delle pipeline, quindi non devi preoccuparti di gestire l'infrastruttura.

In questo tutorial utilizzerai Vertex AI Pipelines per eseguire un job di addestramento personalizzato e implementare il modello addestrato in Vertex AI, in un ambiente di rete ibrido.

L'intera procedura richiede da due a tre ore, inclusi circa 50 minuti per l'esecuzione della pipeline.

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 che mostra l'utilizzo di Private Service Connect per accedere alle pipeline di addestramento.

Obiettivi

Crea due reti Virtual Private Cloud (VPC):
- Uno (vertex-networking-vpc) è per l'utilizzo dell'API Vertex AI Pipelines per creare e ospitare un modello di pipeline per l'addestramento di un modello di machine learning e il relativo deployment in un endpoint.
- L'altra (onprem-dataservice-vpc) rappresenta una rete on-premise.
Collega le due reti VPC come segue:
- Esegui il deployment di gateway VPN ad alta disponibilità, tunnel Cloud VPN e router Cloud per connettere vertex-networking-vpc e onprem-dataservice-vpc.
- Crea un endpoint Private Service Connect (PSC) per inoltrare le richieste private all'API REST di Vertex AI Pipelines.
- Configura un annuncio di route personalizzato del router Cloud in vertex-networking-vpc per annunciare le route per l'onprem-dataservice-vpc endpoint Private Service Connect.
Crea un'istanza Filestore nella rete VPConprem-dataservice-vpc e aggiungi i dati di addestramento in una condivisione NFS.
Crea un'applicazione del pacchetto Python per il job di addestramento.
Crea un modello di job Vertex AI Pipelines per eseguire le seguenti operazioni:
- Crea ed esegui il job di addestramento sui dati della condivisione NFS.
- Importa il modello addestrato e caricalo in Vertex AI Model Registry.
- Crea un endpoint Vertex AI per le previsioni online.
- Esegui il deployment del modello nell'endpoint.
Carica il modello di pipeline in un repository Artifact Registry.
Utilizza l'API REST di Vertex AI Pipelines per attivare l'esecuzione di una pipeline da un host di servizio dati on-premise (on-prem-dataservice-host).

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

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

Go to project selector
Select or create a Google Cloud project.
Make sure that billing is enabled for your Google Cloud project.
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.
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.
Se non sei il proprietario del progetto, chiedigli di concederti il ruolo Amministratore IAM del progetto (roles/resourcemanager.projectIamAdmin). Devi disporre di questo ruolo per concedere i ruoli IAM nel passaggio successivo.
Grant roles to your user account. Run the following command once for each of the following IAM roles: roles/artifactregistry.admin, roles/artifactregistry.repoAdmin, roles/compute.instanceAdmin.v1, roles/compute.networkAdmin, roles/compute.securityAdmin, roles/dns.admin, roles/file.editor, roles/logging.viewer, roles/logging.admin, roles/notebooks.admin, roles/iam.serviceAccountAdmin, roles/iam.serviceAccountUser, roles/servicedirectory.editor, roles/servicemanagement.quotaAdmin, roles/serviceusage.serviceUsageAdmin, roles/storage.admin, roles/storage.objectAdmin, roles/aiplatform.admin, roles/aiplatform.user, roles/aiplatform.viewer, roles/iap.admin, roles/iap.tunnelResourceAccessor, roles/resourcemanager.projectIamAdmin
```
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.

Enable the DNS, Artifact Registry, IAM, Compute Engine, Cloud Logging, Network Connectivity, Notebooks, Cloud Filestore, Service Networking, Service Usage, and Vertex AI APIs:

gcloud services enable dns.googleapis.com artifactregistry.googleapis.com iam.googleapis.com compute.googleapis.com logging.googleapis.com networkconnectivity.googleapis.com notebooks.googleapis.com file.googleapis.com servicenetworking.googleapis.com serviceusage.googleapis.com aiplatform.googleapis.com

Crea le reti VPC

In questa sezione crei due reti VPC: una per accedere alle API di Google per Vertex AI Pipelines e l'altra per simulare una rete on-premise. 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.

In Cloud Shell, esegui i seguenti comandi, sostituendo PROJECT_ID con l'ID progetto:
```
projectid=PROJECT_ID
gcloud config set project ${projectid}
```

Crea la rete VPC vertex-networking-vpc:

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

Nella rete vertex-networking-vpc, crea una subnet denominata pipeline-networking-subnet1 con un intervallo IPv4 principale di 10.0.0.0/24:

gcloud compute networks subnets create pipeline-networking-subnet1 \
    --range=10.0.0.0/24 \
    --network=vertex-networking-vpc \
    --region=us-central1 \
    --enable-private-ip-google-access

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

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

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

gcloud compute networks subnets create onprem-dataservice-vpc-subnet1 \
    --network onprem-dataservice-vpc \
    --range 172.16.10.0/24 \
    --region us-central1 \
    --enable-private-ip-google-access

Verificare che le reti VPC siano configurate correttamente

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

Vai a Reti VPC
Nell'elenco delle reti VPC, verifica che le due reti siano state create: vertex-networking-vpc e onprem-dataservice-vpc.
Fai clic sulla scheda Subnet nel progetto attuale.
Nell'elenco delle subnet VPC, verifica che le subnet pipeline-networking-subnet1 e onprem-dataservice-vpc-subnet1 siano state create.

Configura la connettività ibrida

In questa sezione crei due gateway VPN ad alta disponibilità connessi tra loro. Uno si trova nella rete VPCvertex-networking-vpc. L'altra si trova nella rete VPConprem-dataservice-vpc. Ogni gateway contiene un router Cloud e una coppia di tunnel VPN.

Crea i gateway VPN ad alta disponibilità

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

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

Crea il gateway VPN ad alta disponibilità per la rete VPC onprem-dataservice-vpc:

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

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

Vai a VPN
Verifica che i due gateway (vertex-networking-vpn-gw1 e onprem-vpn-gw1) siano stati creati e che ogni gateway abbia due indirizzi IP di interfaccia.

Crea router Cloud e gateway Cloud NAT

In ognuna delle due reti VPC, crea due router Cloud: uno da utilizzare con Cloud NAT e uno per gestire le sessioni BGP per la VPN ad alta disponibilità.

In Cloud Shell, crea un router Cloud per la rete VPC vertex-networking-vpc che verrà utilizzata per la VPN:

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

Crea un router Cloud per la rete VPC onprem-dataservice-vpc che verrà utilizzata per la VPN:

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

Crea un router Cloud per la rete VPC vertex-networking-vpc che verrà utilizzata per Cloud NAT:

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

Configura un gateway Cloud NAT sul router Cloud:

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

Crea un router Cloud per la rete VPC onprem-dataservice-vpc che verrà utilizzata per Cloud NAT:

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

Configura un gateway Cloud NAT sul router Cloud:

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

Nella console Google Cloud, vai alla pagina Cloud Routers.

Vai a Router Cloud
Nell'elenco Cloud Routers (Router cloud), verifica che siano stati creati i seguenti router:
- cloud-router-us-central1-onprem-nat
- cloud-router-us-central1-vertex-nat
- onprem-dataservice-vpc-router1
- vertex-networking-vpc-router1
Potresti dover aggiornare la scheda del browser della console Google Cloud per visualizzare i nuovi valori.
Nell'elenco dei router Cloud, fai clic su cloud-router-us-central1-vertex-nat.
Nella pagina Dettagli router, verifica che il gateway Cloud NAT cloud-nat-us-central1 sia stato creato.
Fai clic sulla Freccia indietro per tornare alla pagina Router Cloud.
Nell'elenco dei router Cloud, fai clic su cloud-router-us-central1-onprem-nat.
Nella pagina Dettagli router, verifica che il gateway Cloud NATcloud-nat-us-central1-on-prem sia stato creato.

Crea tunnel VPN

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

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

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

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

Nella rete onprem-dataservice-vpc, crea un tunnel VPN denominato onprem-dataservice-vpc-tunnel0:

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

Nella rete onprem-dataservice-vpc, crea un tunnel VPN denominato onprem-dataservice-vpc-tunnel1:

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

Nella console Google Cloud, vai alla pagina VPN.

Vai a VPN
Nell'elenco dei tunnel VPN, verifica che i quattro tunnel VPN siano stati creati.

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 vertex-networking-vpc) e la tua rete on-premise (rappresentata da onprem-dataservice-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 vertex-networking-vpc e altre due per onprem-dataservice-vpc.

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

Stabilisci sessioni BGP per `vertex-networking-vpc`

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

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

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

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

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

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

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

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

Stabilisci sessioni BGP per `onprem-dataservice-vpc`

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

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

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

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

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

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

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

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

Convalida la creazione della sessione BGP

Nella console Google Cloud, vai alla pagina VPN.

Vai a VPN
Nell'elenco dei tunnel VPN, verifica che il valore nella colonna Stato sessione BGP per ogni tunnel sia passato da Configura sessione BGP a BGP stabilito. Per visualizzare i nuovi valori, potresti dover aggiornare la scheda del browser della console Google Cloud.

Convalida i percorsi `onprem-dataservice-vpc` appresi

Nella console Google Cloud, vai alla pagina Reti VPC.

Vai a Reti VPC
Nell'elenco delle reti VPC, fai clic su onprem-dataservice-vpc.
Fai clic sulla scheda Percorsi.
Seleziona us-central1 (Iowa) nell'elenco Regione e fai clic su Visualizza.
Nella colonna Intervallo IP di destinazione, verifica che l'intervallo IP della subnet pipeline-networking-subnet1 (10.0.0.0/24) venga visualizzato due volte.

Potresti dover aggiornare la scheda del browser della console Google Cloud per visualizzare entrambe le voci.

Convalida i percorsi `vertex-networking-vpc` appresi

Fai clic sulla Freccia indietro per tornare alla pagina Reti VPC.
Nell'elenco delle reti VPC, fai clic su vertex-networking-vpc.
Fai clic sulla scheda Percorsi.
Seleziona us-central1 (Iowa) nell'elenco Regione e fai clic su Visualizza.
Nella colonna Intervallo IP di destinazione, verifica che l'intervallo IP della subnet onprem-dataservice-vpc-subnet1 (172.16.10.0/24) venga visualizzato due volte.

Creare un endpoint Private Service Connect per le API di Google

In questa sezione crei un endpoint Private Service Connect per le API di Google che utilizzerai per accedere all'API REST di Vertex AI Pipelines dalla tua rete on-premise.

In Cloud Shell, prenota un indirizzo IP dell'endpoint consumer che verrà utilizzato per accedere alle API di Google:

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

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

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

Crea annunci di route personalizzati per `vertex-networking-vpc`

In questa sezione, crei un annuncio di route personalizzato per vertex-networking-vpc-router1 (il router cloud per vertex-networking-vpc) per pubblicizzare l'indirizzo IP dell'endpoint PSC alla rete VPC onprem-dataservice-vpc.

Nella console Google Cloud, vai alla pagina Cloud Routers.

Vai a Router Cloud
Nell'elenco dei router Cloud, fai clic su vertex-networking-vpc-router1.
Nella pagina Dettagli del router, fai clic su Modifica.
Nella sezione Route annunciate, per Route, seleziona Crea route personalizzate.
Seleziona la casella di controllo Annuncia tutte le subnet visibili al router Cloud per continuare a pubblicizzare le subnet disponibili per il router Cloud. L'attivazione di questa opzione simula il comportamento del router Cloud in modalità di annuncio predefinita.
Fai clic su Aggiungi un percorso personalizzato.
In Origine, seleziona Intervallo IP personalizzato.
In Intervallo di indirizzi IP, inserisci il seguente indirizzo IP:
```
192.168.0.1
```

In Descrizione, inserisci il seguente testo:

Custom route to advertise Private Service Connect endpoint IP address

Fai clic su Fine e poi su Salva.

Verifica che `onprem-dataservice-vpc` abbia appreso le route annunciate

Nella console Google Cloud, vai alla pagina Route.

Vai a Route
Nella scheda Route operative, procedi nel seguente modo:
1. In Rete, scegli onprem-dataservice-vpc.
2. In Regione, scegli us-central1 (Iowa).
3. Fai clic su Visualizza.
4. Nell'elenco dei percorsi, verifica che siano presenti due voci i cui nomi inizino con onprem-dataservice-vpc-router1-bgp-vertex-networking-vpc-tunnel0 e due che inizino con onprem-dataservice-vpc-router1-bgp-vertex-networking-vpc-tunnel1.
  
  Se queste voci non vengono visualizzate immediatamente, attendi qualche minuto e poi aggiorna la scheda del browser della console Google Cloud.
5. Verifica che due delle voci abbiano un intervallo IP di destinazione di 192.168.0.1/32 e due un intervallo IP di destinazione di 10.0.0.0/24.

Crea un'istanza VM in `onprem-dataservice-vpc`

In questa sezione, crei un'istanza VM che simula un host di servizio di dati on-premise. In base alle best practice di Compute Engine e IAM, questa VM utilizza un account di servizio gestito dall'utente anziché l'account di servizio predefinito di Compute Engine.

Crea l'account di servizio gestito dall'utente per l'istanza VM

In Cloud Shell, esegui i seguenti comandi, sostituendo PROJECT_ID con l'ID progetto:
```
projectid=PROJECT_ID
gcloud config set project ${projectid}
```

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

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

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

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

Assegna il ruolo Vertex AI Viewer (roles/aiplatform.viewer):

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

Assegna il ruolo Filestore Editor (roles/file.editor):

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

Assegna il ruolo Amministratore account di servizio (roles/iam.serviceAccountAdmin):

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

Assegna il ruolo Utente account di servizio (roles/iam.serviceAccountUser):

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

Assegna il ruolo Artifact Registry Reader (roles/artifactregistry.reader):

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

Assegna il ruolo Amministratore oggetti Storage (roles/storage.objectAdmin):

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

Assegna il ruolo Amministratore Logging (roles/logging.admin):

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

Crea l'istanza VM `on-prem-dataservice-host`

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

In Cloud Shell, crea l'istanza VM on-prem-dataservice-host:

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

Crea una regola firewall per consentire a IAP di connettersi all'istanza VM:

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

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

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

In Cloud Shell, accedi all'istanza VM on-prem-dataservice-host utilizzando IAP:

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

Nell'istanza VM on-prem-dataservice-host, utilizza un editor di testo come vim o nano per aprire il file /etc/hosts, ad esempio:
```
sudo vim /etc/hosts
```

Aggiungi la seguente riga al file:

192.168.0.1 us-central1-aiplatform.googleapis.com

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

Il file modificato dovrebbe avere il seguente aspetto:

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

192.168.0.1 us-central1-aiplatform.googleapis.com  # Added by you
172.16.10.6 on-prem-dataservice-host.us-central1-a.c.PROJECT_ID.internal on-prem-dataservice-host  # Added by Google
169.254.169.254 metadata.google.internal  # Added by Google

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.
Esegui un ping all'endpoint dell'API Vertex AI come segue:
```
ping us-central1-aiplatform.googleapis.com
```
Il comando ping dovrebbe restituire il seguente output. 192.168.0.1 è l'indirizzo IP dell'endpoint PSC:
```
PING us-central1-aiplatform.googleapis.com (192.168.0.1) 56(84) bytes of data.
```
Digita Control+C per uscire da ping.
Digita exit per uscire dall'istanza VM on-prem-dataservice-host e tornare al prompt Cloud Shell.

Configurare il networking per un'istanza Filestore

In questa sezione, attivi l'accesso ai servizi privati per la rete VPC, in preparazione alla creazione di un'istanza Filestore e al suo montaggio come condivisione Network File System (NFS). Per capire cosa stai facendo in questa sezione e in quella successiva, consulta Montare una condivisione NFS per l'addestramento personalizzato e Configurare il peering di rete VPC.

Attivare l'accesso privato ai servizi su una rete VPC

In questa sezione, crei una connessione Service Networking e la utilizzi per attivare l'accesso dei servizi privati alla rete VPC onprem-dataservice-vpc tramite il peering di rete VPC.

In Cloud Shell, imposta un intervallo di indirizzi IP riservati utilizzando gcloud compute addresses create:

gcloud compute addresses create filestore-subnet \
   --global \
   --purpose=VPC_PEERING \
   --addresses=10.243.208.0 \
   --prefix-length=24 \
   --description="filestore subnet" \
   --network=onprem-dataservice-vpc

Stabilisci una connessione in peering tra la rete VPC onprem-dataservice-vpc e Service Networking di Google utilizzando gcloud services vpc-peerings connect:

gcloud services vpc-peerings connect \
    --service=servicenetworking.googleapis.com \
    --ranges=filestore-subnet \
    --network=onprem-dataservice-vpc

Aggiorna il peering di rete VPC per abilitare l'importazione e l'esportazione delle route apprese personalizzate:

gcloud compute networks peerings update servicenetworking-googleapis-com \
    --network=onprem-dataservice-vpc \
    --import-custom-routes \
    --export-custom-routes

Nella console Google Cloud, vai alla pagina Peering di reti VPC.

Vai al peering di rete VPC
Nell'elenco dei peering VPC, verifica che sia presente una voce per il peering tra servicenetworking.googleapis.com e la rete VPC onprem-dataservice-vpc.

Crea annunci di route personalizzati per `filestore-subnet`

Nella console Google Cloud, vai alla pagina Cloud Routers.

Vai a Router Cloud
Nell'elenco dei router Cloud, fai clic su onprem-dataservice-vpc-router1.
Nella pagina Dettagli del router, fai clic su Modifica.
Nella sezione Route annunciate, per Route, seleziona Crea route personalizzate.
Seleziona la casella di controllo Annuncia tutte le subnet visibili al router Cloud per continuare a pubblicizzare le subnet disponibili per il router Cloud. L'attivazione di questa opzione simula il comportamento del router Cloud in modalità di annuncio predefinita.
Fai clic su Aggiungi un percorso personalizzato.
In Origine, seleziona Intervallo IP personalizzato.
In Intervallo di indirizzi IP, inserisci il seguente intervallo di indirizzi IP:
```
10.243.208.0/24
```
In Descrizione, inserisci il seguente testo:
```
Filestore reserved IP address range
```
Fai clic su Fine e poi su Salva.

Crea l'istanza Filestore nella rete `onprem-dataservice-vpc`

Dopo aver attivato l'accesso ai servizi privati per la rete VPC, crea un'istanza Filestore e montala come condivisione NFS per il tuo job di addestramento personalizzato. In questo modo, i job di addestramento possono accedere ai file remoti come se fossero locali, consentendo una maggiore velocità effettiva e una bassa latenza.

Crea l'istanza Filestore

Nella console Google Cloud, vai alla pagina Istanze Filestore.

Vai a Istanze di Filestore
Fai clic su Crea istanza e configura l'istanza come segue:
- Imposta ID istanza su quanto segue:
```
image-data-instance
```
- Imposta Tipo di istanza su Base.
- Imposta Tipo di archiviazione su HDD.
- Imposta Alloca capacità su 1 TiB.
- Imposta Regione su us-central1 e Zona su us-central1-c.
- Imposta Rete VPC su onprem-dataservice-vpc.
- Imposta Intervallo IP allocato su Utilizza un intervallo IP allocato esistente e scegli filestore-subnet.
- Imposta Nome condivisione file su quanto segue:
```
vol1
```
- Imposta Controlli di accesso su Concedi l'accesso a tutti i client della rete VPC.
Fai clic su Crea.
Prendi nota dell'indirizzo IP della nuova istanza Filestore. Potresti dover aggiornare la scheda del browser della console Google Cloud per vedere la nuova istanza.

Monta la condivisione file di Filestore

In Cloud Shell, esegui i seguenti comandi, sostituendo PROJECT_ID con l'ID progetto:
```
projectid=PROJECT_ID
gcloud config set project ${projectid}
```

Accedi all'istanza VM on-prem-dataservice-host:

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

Installa il pacchetto NFS sull'istanza VM:

sudo apt-get update -y
sudo apt-get -y install nfs-common

Crea una directory di montaggio per la condivisione file di Filestore:
```
sudo mkdir -p /mnt/nfs
```
Nota: assicurati che il nome della cartella del punto di montaggio all'interno di /mnt/ sia nfs. Questo perché la condivisione file NFS è montata in /mnt/nfs/ all'interno del job di addestramento personalizzato.
Monta la condivisione file, sostituendo FILESTORE_INSTANCE_IP con l'indirizzo IP dell'istanza Filestore:
```
sudo mount FILESTORE_INSTANCE_IP:/vol1 /mnt/nfs
```
Se la connessione scade, assicurati di fornire l'indirizzo IP corretto dell'istanza Filestore.

Verifica che il montaggio NFS sia andato a buon fine eseguendo il seguente comando:

df -h

Verifica che la condivisione file /mnt/nfs venga visualizzata nel risultato:

Filesystem           Size  Used Avail Use% Mounted on
udev                 1.8G     0  1.8G   0% /dev
tmpfs                368M  396K  368M   1% /run
/dev/sda1            9.7G  1.9G  7.3G  21% /
tmpfs                1.8G     0  1.8G   0% /dev/shm
tmpfs                5.0M     0  5.0M   0% /run/lock
/dev/sda15           124M   11M  114M   9% /boot/efi
tmpfs                368M     0  368M   0% /run/user
10.243.208.2:/vol1  1007G     0  956G   0% /mnt/nfs

Rendi la condivisione file accessibile modificando le autorizzazioni:
```
sudo chmod go+rw /mnt/nfs
```
Nota: in un ambiente di produzione, ti consigliamo di impostare autorizzazioni più granulari. Per ulteriori informazioni, consulta la pagina sulla configurazione dell'accesso per una condivisione file.

Scarica il set di dati nella condivisione file

Nell'istanza VM on-prem-dataservice-host, scarica il set di dati nella condivisione file:
```
gcloud storage cp gs://cloud-samples-data/vertex-ai/dataset-management/datasets/fungi_dataset /mnt/nfs/ --recursive
```
Il download richiede diversi minuti.
Verifica che il set di dati sia stato copiato correttamente eseguendo il seguente comando:
```
sudo du -sh /mnt/nfs
```
L'output previsto è:
```
104M    /mnt/nfs
```
Digita exit per uscire dall'istanza VM on-prem-dataservice-host e tornare al prompt Cloud Shell.

Crea un bucket di staging per la pipeline

Vertex AI Pipelines archivia gli artefatti delle esecuzioni della pipeline utilizzando Cloud Storage. Prima di eseguire la pipeline, devi creare un bucket Cloud Storage per le esecuzioni di staging della pipeline.

In Cloud Shell, crea un bucket Cloud Storage:

gcloud storage buckets create gs://pipelines-staging-bucket-$projectid --location=us-central1

Crea un account di servizio gestito dall'utente per Vertex AI Workbench

In Cloud Shell, crea un account di servizio:

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

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

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

Assegna il ruolo Amministratore di Artifact Registry (artifactregistry.admin):

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

Assegna il ruolo Amministratore archiviazione (storage.admin):

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

Crea l'applicazione di addestramento Python

In questa sezione crei un'istanza di Vertex AI Workbench e la utilizzi per creare un pacchetto di applicazioni di addestramento personalizzato in Python.

Crea un'istanza di Vertex AI Workbench

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

Vai a Vertex AI Workbench
Fai clic su Crea nuova e poi su Opzioni avanzate.

Viene visualizzata la pagina Nuova istanza.
Nella pagina Nuova istanza, nella sezione Dettagli, fornisci le seguenti informazioni per la nuova istanza e poi fai clic su Continua:
- Nome: inserisci quanto segue, sostituendo PROJECT_ID con l'ID progetto:
```
pipeline-tutorial-PROJECT_ID
```
- Regione: seleziona us-central1.
- Zona: seleziona us-central1-a.
- Deseleziona la casella di controllo Abilita sessioni interattive serverless di Dataproc.
Nella sezione Ambiente, fai clic su Continua.
Nella sezione Tipo di macchina, fornisci quanto segue e poi fai clic su Continua:
- Tipo di macchina: scegli N1 e seleziona n1-standard-4 nel menu Tipo di macchina.
- VM protetta: seleziona le seguenti caselle di controllo:
  - Avvio protetto
  - Virtual Trusted Platform Module (vTPM)
  - Monitoraggio dell'integrità
Nella sezione Dischi, assicurati che sia selezionata l'opzione Chiave di crittografia gestita da Google, quindi fai clic su Continua:
Nella sezione Networking, fornisci quanto segue e poi fai clic su Continua:
- Networking: seleziona Rete in questo progetto e completa i seguenti passaggi:
  1. Nel campo Rete, seleziona vertex-networking-vpc.
  2. Nel campo Subnet, seleziona pipeline-networking-subnet1.
  3. Deseleziona la casella di controllo Assegna indirizzo IP esterno. La mancata assegnazione di un indirizzo IP esterno impedisce all'istanza di ricevere comunicazioni non richieste dall'internet o da altre reti VPC.
  4. Seleziona la casella di controllo Consenti accesso proxy.
Nella sezione IAM e sicurezza, fornisci quanto segue e poi fai clic su Continua:
- IAM e sicurezza: per concedere a un singolo utente l'accesso all'interfaccia JupyterLab dell'istanza, completa i seguenti passaggi:
  1. Seleziona Service account (Account di servizio).
  2. Deseleziona la casella di controllo Utilizza l'account di servizio predefinito di Compute Engine. Questo passaggio è importante perché l'account di servizio predefinito di Compute Engine (e quindi il singolo utente che hai appena specificato) potrebbe avere il ruolo Editor (roles/editor) nel tuo progetto.
  3. Nel campo Indirizzo email account di servizio, inserisci quanto segue, sostituendo PROJECT_ID con l'ID progetto:
```
workbench-sa@PROJECT_ID.iam.gserviceaccount.com
```
    Si tratta dell'indirizzo email dell'account di servizio personalizzato che hai creato in precedenza. Questo account di servizio ha autorizzazioni limitate.
    
    Per saperne di più sulla concessione dell'accesso, consulta Gestire l'accesso all'interfaccia JupyterLab di un'istanza di Vertex AI Workbench.
- Opzioni di sicurezza: deseleziona la seguente casella di controllo:
  - Accesso root all'istanza
  Seleziona la seguente casella di controllo:
  - nbconvert: nbconvert consente agli utenti di esportare e scaricare un file del notebook come un altro tipo di file, ad esempio HTML, PDF o LaTeX. Questa impostazione è richiesta da alcuni dei notebook nel repository GitHub di Google Cloud Generative AI.
  Deseleziona la seguente casella di controllo:
  - Download dei file
  Seleziona la seguente casella di controllo, a meno che non ti trovi in un ambiente di produzione:
  - Accesso al terminale: consente l'accesso al terminale dell'istanza dall'interfaccia utente di JupyterLab.
Nella sezione Integrità del sistema, deseleziona Upgrade automatico dell'ambiente e fornisci quanto segue:
- In Report, seleziona le seguenti caselle di controllo:
  - Segnalare lo stato del sistema
  - Segnalare metriche personalizzate a Cloud Monitoring
  - Installa Cloud Monitoring
  - Segnalare lo stato del DNS per i domini Google richiesti
Fai clic su Crea e attendi qualche minuto per la creazione dell'istanza di Vertex AI Workbench.

Esegui l'applicazione di addestramento nell'istanza di Vertex AI Workbench

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

Vai a Vertex AI Workbench
Fai clic su Apri JupyterLab accanto al nome dell'istanza Vertex AI Workbench (pipeline-tutorial-PROJECT_ID), dove PROJECT_ID è l'ID progetto.

L'istanza di Vertex AI Workbench si apre in JupyterLab.
Seleziona File > Nuovo > Terminale.
Nel terminale JupyterLab (non in Cloud Shell), definisci una variabile di ambiente per il progetto. Sostituisci PROJECT_ID con l'ID progetto:
```
projectid=PROJECT_ID
```
Crea le directory principali per l'applicazione di addestramento (ancora nel terminale JupyterLab):
```
mkdir fungi_training_package
mkdir fungi_training_package/trainer
```
Nel Browser di file, fai doppio clic sulla cartella fungi_training_package e poi sulla cartella trainer.
In File Browser, fai clic con il tasto destro del mouse sull'elenco di file vuoto (sotto l'intestazione Nome) e seleziona Nuovo file.
Fai clic con il tasto destro del mouse sul nuovo file e seleziona Rinomina file.
Rinomina il file da untitled.txt in task.py.
Fai doppio clic sul file task.py per aprirlo.

Copia il seguente codice in task.py:

# Import the libraries
import tensorflow as tf
from tensorflow.python.client import device_lib
import argparse
import os
import sys
# add parser arguments
parser = argparse.ArgumentParser()
parser.add_argument('--data-dir', dest='dataset_dir', type=str, 
                 help='Dir to access dataset.')
parser.add_argument('--model-dir', dest='model_dir', default=os.getenv("AIP_MODEL_DIR"), type=str,
                 help='Dir to save the model.')
parser.add_argument('--epochs', dest='epochs', default=10, type=int,
                 help='Number of epochs.')
parser.add_argument('--batch-size', dest='batch_size', default=32, type=int,
                 help='Number of images per batch.')
parser.add_argument('--distribute', dest='distribute', default='single', type=str, 
                 help='distributed training strategy.')
args = parser.parse_args()
# print the tf version and config
print('Python Version = {}'.format(sys.version))
print('TensorFlow Version = {}'.format(tf.__version__))
print('TF_CONFIG = {}'.format(os.environ.get('TF_CONFIG', 'Not found')))
print('DEVICES', device_lib.list_local_devices())

# Single Machine, single compute device
if args.distribute == 'single':
    if tf.test.is_gpu_available():
        strategy = tf.distribute.OneDeviceStrategy(device="/gpu:0")
    else:
        strategy = tf.distribute.OneDeviceStrategy(device="/cpu:0")
# Single Machine, multiple compute device
elif args.distribute == 'mirror':
    strategy = tf.distribute.MirroredStrategy()
# Multiple Machine, multiple compute device
elif args.distribute == 'multi':
    strategy = tf.distribute.experimental.MultiWorkerMirroredStrategy()

# Multi-worker configuration
print('num_replicas_in_sync = {}'.format(strategy.num_replicas_in_sync))

# Preparing dataset
BUFFER_SIZE = 1000
IMG_HEIGHT = 224
IMG_WIDTH = 224

def make_datasets_batched(dataset_path, global_batch_size):
    # Configure the training data generator
    train_data_dir = os.path.join(dataset_path,"train/")
    train_ds = tf.keras.utils.image_dataset_from_directory(
                         train_data_dir,
                         seed=36,
                         image_size=(IMG_HEIGHT, IMG_WIDTH),
                         batch_size=global_batch_size
               )
    # Configure the validation data generator
    val_data_dir = os.path.join(dataset_path,"valid/")
    val_ds = tf.keras.utils.image_dataset_from_directory(
                       val_data_dir,
                       seed=36,
                       image_size=(IMG_HEIGHT, IMG_WIDTH),
                       batch_size=global_batch_size
             )
    # get the number of classes in the data
    num_classes = len(train_ds.class_names)

    # Configure the dataset for performance
    AUTOTUNE = tf.data.AUTOTUNE
    train_ds = train_ds.cache().shuffle(BUFFER_SIZE).prefetch(buffer_size=AUTOTUNE)
    val_ds = val_ds.cache().prefetch(buffer_size=AUTOTUNE)
    return train_ds, val_ds, num_classes

# Build the Keras model
def build_and_compile_cnn_model(num_classes):
    # build a CNN model
    model = tf.keras.models.Sequential([
      tf.keras.layers.Rescaling(1./255, input_shape=(IMG_HEIGHT, IMG_WIDTH, 3)),
      tf.keras.layers.Conv2D(16, 3, padding='same', activation='relu'),
      tf.keras.layers.MaxPooling2D(),
      tf.keras.layers.Conv2D(32, 3, padding='same', activation='relu'),
      tf.keras.layers.MaxPooling2D(),
      tf.keras.layers.Conv2D(64, 3, padding='same', activation='relu'),
      tf.keras.layers.MaxPooling2D(),
      tf.keras.layers.Flatten(),
      tf.keras.layers.Dense(128, activation='relu'),
      tf.keras.layers.Dense(num_classes)
    ])
    # compile the CNN model
    model.compile(optimizer='adam',
               loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
               metrics=['accuracy'])
    return model

# Get the strategy data
NUM_WORKERS = strategy.num_replicas_in_sync
# Here the batch size scales up by number of workers
GLOBAL_BATCH_SIZE = args.batch_size * NUM_WORKERS

# Create dataset generator objects
train_ds, val_ds, num_classes = make_datasets_batched(args.dataset_dir, GLOBAL_BATCH_SIZE)
# Compile the model
with strategy.scope():
    # Creation of dataset, and model building/compiling need to be within
    # `strategy.scope()`.
    model = build_and_compile_cnn_model(num_classes)
# fit the model on the data
history = model.fit(train_ds, validation_data=val_ds, epochs=args.epochs)
# save the model to the output dir
model.save(args.model_dir)

Seleziona File > Salva file Python.
Nel terminale JupyterLab, crea un __init__.py file in ogni sottodirectory per creare un pacchetto:
```
touch fungi_training_package/__init__.py
touch fungi_training_package/trainer/__init__.py
```
Nel Browser dei file, fai doppio clic sulla cartella fungi_training_package.
Seleziona File > Nuovo > File Python.
Fai clic con il tasto destro del mouse sul nuovo file e seleziona Rinomina file.
Rinomina il file da untitled.py in setup.py.
Fai doppio clic sul file setup.py per aprirlo.

Copia il seguente codice in setup.py:

from setuptools import find_packages
from setuptools import setup
setup(
   name='trainer',
   version='0.1',
   packages=find_packages(),
   include_package_data=True,
   description='Training application package for fungi-classification.'
)

Seleziona File > Salva file Python.
Nel terminale, vai alla directory fungi_training_package:
```
cd fungi_training_package
```
Utilizza il comando sdist per creare la distribuzione di origine dell'applicazione di addestramento:
```
python setup.py sdist --formats=gztar
```
Vai alla directory principale:
```
cd ..
```
Verifica di trovarti nella directory corretta:
```
pwd
```
L'output è il seguente:
```
/home/jupyter
```

Copia il pacchetto Python nel bucket di staging:

gcloud storage cp fungi_training_package/dist/trainer-0.1.tar.gz gs://pipelines-staging-bucket-$projectid/training_package/

Verifica che il bucket di staging contenga il pacchetto:

gcloud storage ls gs://pipelines-staging-bucket-$projectid/training_package

L'output è:

gs://pipelines-staging-bucket-PROJECT_ID/training_package/trainer-0.1.tar.gz

Crea la connessione di Service Networking per le pipeline Vertex AI

In questa sezione crei una connessione Service Networking che viene utilizzata per stabilire i servizi di produzione collegati alla vertex-networking-vpc rete VPC tramite il peering di rete VPC. Per ulteriori informazioni, consulta Peering di rete VPC.

In Cloud Shell, esegui i seguenti comandi, sostituendo PROJECT_ID con l'ID progetto:
```
projectid=PROJECT_ID
gcloud config set project ${projectid}
```

Imposta un intervallo di indirizzi IP riservato utilizzando gcloud compute addresses create:

gcloud compute addresses create vertex-pipeline-subnet \
    --global \
    --purpose=VPC_PEERING \
    --addresses=192.168.10.0 \
    --prefix-length=24 \
    --description="pipeline subnet" \
    --network=vertex-networking-vpc

Stabilisci una connessione in peering tra la rete VPC vertex-networking-vpc e Service Networking di Google utilizzando gcloud services vpc-peerings connect:

gcloud services vpc-peerings connect \
    --service=servicenetworking.googleapis.com \
    --ranges=vertex-pipeline-subnet \
    --network=vertex-networking-vpc

Aggiorna la connessione in peering VPC per abilitare l'importazione e l'esportazione delle route apprese personalizzate:

gcloud compute networks peerings update servicenetworking-googleapis-com \
    --network=vertex-networking-vpc \
    --import-custom-routes \
    --export-custom-routes

Annuncia la subnet della pipeline dal router Cloud `pipeline-networking`

Nella console Google Cloud, vai alla pagina Cloud Router.

Vai a Router Cloud
Nell'elenco dei router Cloud, fai clic su vertex-networking-vpc-router1.
Nella pagina Dettagli del router, fai clic su Modifica.
Fai clic su Aggiungi un percorso personalizzato.
In Origine, seleziona Intervallo IP personalizzato.
In Intervallo di indirizzi IP, inserisci il seguente intervallo di indirizzi IP:
```
192.168.10.0/24
```
In Descrizione, inserisci il seguente testo:
```
Vertex AI Pipelines reserved subnet
```
Fai clic su Fine e poi su Salva.

Crea un modello di pipeline e caricalo in Artifact Registry

In questa sezione crei e carichi un modello di pipeline Kubeflow Pipelines (KFP). Questo modello contiene una definizione di flusso di lavoro che può essere riutilizzata più volte da un singolo utente o da più utenti.

Definisci e compila la pipeline

In Jupyterlab, nel File Browser, fai doppio clic sulla cartella di primo livello.
Seleziona File > Nuovo > Notebook.
Nel menu Seleziona kernel, seleziona Python 3 (ipykernel) e fai clic su Seleziona.
In una nuova cella del notebook, esegui il seguente comando per assicurarti di avere la versione più recente di pip:
```
!python -m pip install --upgrade pip
```
Esegui il comando seguente per installare l'SDK Google Cloud Pipeline Components dall'indice dei pacchetti Python (PyPI):
```
!pip install --upgrade google-cloud-pipeline-components
```
Al termine dell'installazione, seleziona Kernel > Riavvia kernel per riavviare il kernel e assicurarti che la libreria sia disponibile per l'importazione.

Esegui il seguente codice in una nuova cella del notebook per definire la pipeline:

from kfp import dsl
# define the train-deploy pipeline
@dsl.pipeline(name="custom-image-classification-pipeline")
def custom_image_classification_pipeline(
 project: str,
 training_job_display_name: str,
 worker_pool_specs: list,
 base_output_dir: str,
 model_artifact_uri: str,
 prediction_container_uri: str,
 model_display_name: str,
 endpoint_display_name: str,
 network: str = '',
 location: str="us-central1",
 serving_machine_type: str="n1-standard-4",
 serving_min_replica_count: int=1,
 serving_max_replica_count: int=1
 ):
 from google_cloud_pipeline_components.types import artifact_types
 from google_cloud_pipeline_components.v1.custom_job import CustomTrainingJobOp
 from google_cloud_pipeline_components.v1.model import ModelUploadOp
 from google_cloud_pipeline_components.v1.endpoint import (EndpointCreateOp,
                                                           ModelDeployOp)
 from kfp.dsl import importer

 # Train the model task
 custom_job_task = CustomTrainingJobOp(
      project=project,
      display_name=training_job_display_name,
      worker_pool_specs=worker_pool_specs,
      base_output_directory=base_output_dir,
      location=location,
      network=network
      )

 # Import the model task
 import_unmanaged_model_task = importer(
      artifact_uri=model_artifact_uri,
      artifact_class=artifact_types.UnmanagedContainerModel,
      metadata={
         "containerSpec": {
            "imageUri": prediction_container_uri,
            },
         },
         ).after(custom_job_task)
 # Model upload task
 model_upload_op = ModelUploadOp(
      project=project,
      display_name=model_display_name,
      unmanaged_container_model=import_unmanaged_model_task.outputs["artifact"],
      )
 model_upload_op.after(import_unmanaged_model_task)
 # Create Endpoint task
 endpoint_create_op = EndpointCreateOp(
      project=project,
      display_name=endpoint_display_name,
      )
 # Deploy the model to the endpoint
 ModelDeployOp(
      endpoint=endpoint_create_op.outputs["endpoint"],
      model=model_upload_op.outputs["model"],
      dedicated_resources_machine_type=serving_machine_type,
      dedicated_resources_min_replica_count=serving_min_replica_count,
      dedicated_resources_max_replica_count=serving_max_replica_count,
      )

Esegui il seguente codice in una nuova cella del notebook per compilare la definizione della pipeline:
```
from kfp import compiler 
PIPELINE_FILE = "pipeline_config.yaml"
compiler.Compiler().compile(
    pipeline_func=custom_image_classification_pipeline,
    package_path=PIPELINE_FILE,
)
```
Nel Browser di file, un file denominato pipeline_config.yaml viene visualizzato nell'elenco dei file.

Crea un repository Artifact Registry

Esegui il seguente codice in una nuova cella del notebook per creare un repository di elementi di tipo KFP:

REPO_NAME="fungi-repo"
REGION="us-central1"
!gcloud artifacts repositories create $REPO_NAME --location=$REGION --repository-format=KFP

Carica il modello di pipeline in Artifact Registry

In questa sezione, configuri un client di registry dell'SDK Kubeflow Pipelines e carichi il modello di pipeline compilato in Artifact Registry dal notebook JupyterLab.

Nel tuo notebook JupyterLab, esegui il seguente codice per caricare il modello di pipeline, sostituendo PROJECT_ID con il tuo ID progetto:

PROJECT_ID = "PROJECT_ID"
from kfp.registry import RegistryClient
host = f"https://{REGION}-kfp.pkg.dev/{PROJECT_ID}/{REPO_NAME}"
client = RegistryClient(host=host)
TEMPLATE_NAME, VERSION_NAME = client.upload_pipeline(
   file_name=PIPELINE_FILE,
   tags=["v1", "latest"],
   extra_headers={"description":"This is an example pipeline template."})

Nella console Google Cloud, per verificare che il modello sia stato caricato, vai a Modelli di pipeline Vertex AI.

Vai a Pipeline
Per aprire il riquadro Seleziona repository, fai clic su Seleziona repository.
Nell'elenco dei repository, fai clic sul repository che hai creato (fungi-repo) e poi su Seleziona.
Verifica che la pipeline (custom-image-classification-pipeline) sia riportata nell'elenco.

Attivare l'esecuzione di una pipeline da on-premise

In questa sezione, ora che il modello di pipeline e il pacchetto di addestramento sono pronti, utilizzerai cURL per attivare l'esecuzione di una pipeline dalla tua applicazione on-premise.

Fornisci i parametri della pipeline

Nel tuo blocco note JupyterLab, esegui il seguente comando per verificare il nome del modello di pipeline:
```
print (TEMPLATE_NAME)
```
Il nome del modello restituito è:
```
custom-image-classification-pipeline
```
Esegui il seguente comando per ottenere la versione del modello di pipeline:
```
print (VERSION_NAME)
```
Il nome della versione del modello di pipeline restituito è simile al seguente:
```
sha256:41eea21e0d890460b6e6333c8070d7d23d314afd9c7314c165efd41cddff86c7
```
Prendi nota dell'intera stringa del nome della versione.
In Cloud Shell, esegui i seguenti comandi, sostituendo PROJECT_ID con l'ID progetto:
```
projectid=PROJECT_ID
gcloud config set project ${projectid}
```