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 flussi di lavoro di machine learning (ML) end-to-end sulla piattaforma Google Cloud. Fornisce un ambiente serverless per l'esecuzione delle pipeline, in modo da non doverti preoccupare della gestione dell'infrastruttura.

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

L'intera procedura richiede 2-3 ore, inclusi circa 50 minuti per l'esecuzione della pipeline.

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

Diagramma architetturale dell'utilizzo di Private Service Connect per accedere alle pipeline di addestramento.

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 ciascuna delle due reti VPC, crei 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 il tuo 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

Verifica che le reti VPC siano configurate correttamente

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

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

Configura la connettività ibrida

In questa sezione, crei due gateway VPN ad alta disponibilità connessi tra loro. Una si trova nella rete VPC vertex-networking-vpc. L'altro si trova nella rete VPC onprem-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 Cloud VPN nella pagina VPN.

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

Crea router Cloud e gateway Cloud NAT

In ciascuna delle due reti VPC, crei due Cloud Router: 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 Google Cloud console, vai alla pagina Cloud Router.

Vai a Router Cloud
Nell'elenco Router Cloud, verifica che siano stati creati i seguenti router:
- cloud-router-us-central1-onprem-nat
- cloud-router-us-central1-vertex-nat
- onprem-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 sia stato creato il gateway Cloud NAT cloud-nat-us-central1.
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 sia stato creato il gateway Cloud NAT cloud-nat-us-central1-on-prem.

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 alla VPN
Nell'elenco dei tunnel VPN, verifica che siano stati creati i quattro tunnel VPN.

Definizione di sessioni BGP

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

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

Definisci 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

Definisci 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 alla VPN
Nell'elenco dei tunnel VPN, verifica che il valore nella colonna Stato sessione BGP per ciascun tunnel sia cambiato da Configura sessione BGP a BGP stabilito. Potresti dover aggiornare la scheda del browser della console per visualizzare i nuovi valori. Google Cloud

Convalida le route apprese `onprem-dataservice-vpc`

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 le route apprese `vertex-networking-vpc`

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.

Crea 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 endpoint consumer che verrà utilizzato per accedere alle API di Google:

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

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

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

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

In questa sezione, crei una pubblicità di route personalizzata 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 Google Cloud console, vai alla pagina Cloud Router.

Vai a Router Cloud
Nell'elenco dei router Cloud, fai clic su vertex-networking-vpc-router1.
Nella pagina Dettagli router, fai clic su Modifica.
Nella sezione Route pubblicizzate, per Route, seleziona Crea route personalizzate.
Seleziona la casella di controllo Annuncia tutte le subnet visibili al router Cloud per continuare ad annunciare le subnet disponibili per il router Cloud. L'attivazione di questa opzione simula il comportamento del router Cloud in modalità di pubblicità 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
```

Per 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 delle route, verifica che siano presenti due voci i cui nomi iniziano con onprem-dataservice-vpc-router1-bgp-vertex-networking-vpc-tunnel0 e due che iniziano con onprem-dataservice-vpc-router1-bgp-vertex-networking-vpc-tunnel1.
  
  Se queste voci non vengono visualizzate immediatamente, attendi qualche minuto, quindi 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 abbiano un intervallo IP di destinazione di 10.0.0.0/24.

Crea una VM nell'istanza in `onprem-dataservice-vpc`

In questa sezione, creerai un'istanza VM che simula un host del servizio dati on-premise. Seguendo le best practice di Compute Engine e IAM, questa VM utilizza un account di servizio gestito dall'utente anziché il service account predefinito di Compute Engine.

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

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

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

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

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

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

Assegna il ruolo Visualizzatore Vertex AI (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 Editor Filestore (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 service account (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 Service Account User (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 Logging Admin (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 alla tua 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 fa sì che le richieste inviate all'endpoint del servizio pubblico (us-central1-aiplatform.googleapis.com) vengano reindirizzate 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, quindi digita :wq per salvare il file e uscire.
- Se utilizzi nano, digita Control+O e premi Enter per salvare il file, quindi digita Control+X per uscire.
Esegui il ping dell'endpoint API Vertex AI nel seguente modo:
```
ping us-central1-aiplatform.googleapis.com
```
Il comando ping dovrebbe restituire l'output seguente. 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 di Cloud Shell.

Configura il networking per un'istanza Filestore

In questa sezione, attivi l'accesso privato ai servizi per la tua 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 nella successiva, consulta Montare una condivisione NFS per l'addestramento personalizzato e Configurare il peering di rete VPC.

Abilitare l'accesso privato ai servizi su una rete VPC

In questa sezione, crei una connessione Service Networking e la utilizzi per attivare l'accesso privato ai servizi 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 di route personalizzate apprese:

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.

Creare annunci di route personalizzati per `filestore-subnet`

Nella Google Cloud console, vai alla pagina Cloud Router.

Vai a Router Cloud
Nell'elenco dei router Cloud, fai clic su onprem-dataservice-vpc-router1.
Nella pagina Dettagli router, fai clic su Modifica.
Nella sezione Route pubblicizzate, per Route, seleziona Crea route personalizzate.
Seleziona la casella di controllo Annuncia tutte le subnet visibili al router Cloud per continuare ad annunciare le subnet disponibili per il router Cloud. L'attivazione di questa opzione simula il comportamento del router Cloud in modalità di pubblicità predefinita.
Fai clic su Aggiungi un percorso personalizzato.
In Origine, seleziona Intervallo IP personalizzato.
Per Intervallo di indirizzi IP, inserisci il seguente intervallo di indirizzi IP:
```
10.243.208.0/24
```
Per 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 privato ai servizi per la tua rete VPC, crea un'istanza Filestore e monta l'istanza 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 velocità effettiva elevata e 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:
```
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 di Filestore. Potresti dover aggiornare la scheda del browser della console per visualizzare la nuova istanza. Google Cloud

Monta la condivisione file di Filestore

In Cloud Shell, esegui i seguenti comandi, sostituendo PROJECT_ID con il tuo 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 di 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, verifica di aver fornito l'indirizzo IP corretto dell'istanza Filestore.

Verifica che il montaggio NFS sia andato a buon fine eseguendo questo 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.

Scaricare 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 di 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 preparare le esecuzioni 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) al 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 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 Storage (storage.admin):

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

Creare l'applicazione di addestramento Python

In questa sezione, crei un'istanza di Vertex AI Workbench e la utilizzi per creare un pacchetto di applicazione di addestramento personalizzato 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 nuovo 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, quindi seleziona n1-standard-4 dal menu Tipo di macchina.
- Shielded VM: seleziona le seguenti caselle di controllo:
  - Avvio protetto
  - Virtual Trusted Platform Module (vTPM)
  - Monitoraggio dell'integrità
Nella sezione Dischi, assicurati che l'opzione Google-managed encryption key sia selezionata, quindi fai clic su Continua:
Nella sezione Networking, fornisci le seguenti informazioni e 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 da 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 Usa account di servizio predefinito di Compute Engine. Questo passaggio è importante perché il 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 Email service account, inserisci quanto segue sostituendo PROJECT_ID con l'ID progetto:
```
workbench-sa@PROJECT_ID.iam.gserviceaccount.com
```
    (Si tratta dell'indirizzo email del service account personalizzato che hai creato in precedenza.) Questo service account dispone di 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 notebook come un tipo di file diverso, ad esempio HTML, PDF o LaTeX. Questa impostazione è richiesta da alcuni notebook nel repository GitHub Google Cloud Generative AI.
  Deseleziona la seguente casella di controllo:
  - Download di file
  Seleziona la casella di controllo seguente, a meno che tu non ti trovi in un ambiente di produzione:
  - Accesso al terminale: consente l'accesso al terminale all'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:
  - Segnala integrità del sistema
  - Segnala metriche personalizzate a Cloud Monitoring
  - Installa Cloud Monitoring
  - Segnala 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
Accanto al nome dell'istanza di Vertex AI Workbench (pipeline-tutorial-PROJECT_ID), dove PROJECT_ID è l'ID progetto, fai clic su Apri JupyterLab.

L'istanza di Vertex AI Workbench si apre in JupyterLab.
Seleziona File > Nuovo > Terminale.
Nel terminale JupyterLab (non Cloud Shell), definisci una variabile di ambiente per il tuo 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 dei file, fai doppio clic sulla cartella fungi_training_package e poi sulla cartella trainer.
Nel browser dei file , fai clic con il tasto destro del mouse sull'elenco dei 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 a 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 file __init__.py in ogni sottodirectory per trasformarla in 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 a 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 ha il seguente aspetto:
```
/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 Service Networking per Vertex AI Pipelines

In questa sezione, crei una connessione Service Networking che viene utilizzata per stabilire i servizi del producer connessi alla rete VPC vertex-networking-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 il tuo ID progetto:
```
projectid=PROJECT_ID
gcloud config set project ${projectid}
```

Imposta un intervallo di indirizzi IP riservati 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 di peering VPC per abilitare l'importazione e l'esportazione di route personalizzate apprese:

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 Google Cloud console, vai alla pagina Cloud Router.

Vai a Router Cloud
Nell'elenco dei router Cloud, fai clic su vertex-networking-vpc-router1.
Nella pagina Dettagli router, fai clic su Modifica.
Fai clic su Aggiungi un percorso personalizzato.
In Origine, seleziona Intervallo IP personalizzato.
Per Intervallo di indirizzi IP, inserisci il seguente intervallo di indirizzi IP:
```
192.168.10.0/24
```
Per 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 su Artifact Registry

In questa sezione, creerai e caricherai un modello di pipeline Kubeflow Pipelines (KFP). Questo modello contiene una definizione del 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 > Blocco note.
Nel menu Seleziona kernel, seleziona Python 3 (ipykernel) e fai clic su Seleziona.
In una nuova cella del notebook, esegui questo comando per assicurarti di avere l'ultima versione di pip:
```
!python -m pip install --upgrade pip
```
Esegui il seguente comando 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 questo 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 questo 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 questo codice in una nuova cella del notebook per creare un repository di artefatti 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 configurerai un client di registro dell'SDK Kubeflow Pipelines e caricherai il modello di pipeline compilato in Artifact Registry dal tuo notebook JupyterLab.

Nel 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 Vertex AI Pipelines.

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), quindi fai clic su Seleziona.
Verifica che la tua pipeline (custom-image-classification-pipeline) venga visualizzata 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, utilizzi cURL per attivare l'esecuzione di una pipeline dalla tua applicazione on-premise.

Fornisci i parametri della pipeline

Nel notebook 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 questo comando per ottenere la versione del modello di pipeline:
```
print (VERSION_NAME)
```
Il nome della versione del modello di pipeline restituito ha questo aspetto:
```
sha256:41eea21e0d890460b6e6333c8070d7d23d314afd9c7314c165efd41cddff86c7
```
Prendi nota dell'intera stringa del nome della versione.
In Cloud Shell, esegui i seguenti comandi, sostituendo PROJECT_ID con il tuo ID progetto:
```
projectid=PROJECT_ID
gcloud config set project ${projectid}
```