Private Service Connect für den Zugriff auf Trainingspipelines lokal verwenden

Vertex AI Pipelines ist ein verwalteter Dienst, mit dem Sie End-to-End-Workflows für maschinelles Lernen (ML) auf der Google Cloud-Plattform erstellen, bereitstellen und verwalten können. Sie bietet eine serverlose Umgebung zum Ausführen Ihrer Pipelines, sodass Sie sich keine Gedanken über die Verwaltung der Infrastruktur machen müssen.

In dieser Anleitung verwenden Sie Vertex AI Pipelines, um einen benutzerdefinierten Trainingsjob auszuführen und das trainierte Modell in Vertex AI in einer hybriden Netzwerkumgebung bereitzustellen.

Der gesamte Vorgang dauert zwei bis drei Stunden, einschließlich etwa 50 Minuten für die Pipelineausführung.

Diese Anleitung richtet sich an Unternehmensnetzwerkadministratoren, Data Scientists und Forscher, die mit Vertex AI, Virtual Private Cloud (VPC), der Google Cloud Console und Cloud Shell vertraut sind. Kenntnisse über Vertex AI Workbench sind hilfreich, aber nicht erforderlich.

Architekturdiagramm zur Verwendung von Private Service Connect für den Zugriff auf Trainingspipelines

Ziele

Erstellen Sie zwei VPC-Netzwerke (Virtual Private Cloud):
- Mit der ersten (vertex-networking-vpc) können Sie mit der Vertex AI Pipelines API eine Pipeline-Vorlage zum Trainieren eines Machine-Learning-Modells erstellen und hosten und es dann an einem Endpunkt bereitstellen.
- Das andere (onprem-dataservice-vpc) steht für ein lokales Netzwerk.
Verbinden Sie die beiden VPC-Netzwerke so:
- Stellen Sie HA VPN-Gateways, Cloud VPN-Tunnel und Cloud Router bereit, um vertex-networking-vpc und onprem-dataservice-vpc zu verbinden.
- Erstellen Sie einen PSC-Endpunkt (Private Service Connect), um private Anfragen an die Vertex AI Pipelines REST API weiterzuleiten.
- Konfigurieren Sie ein benutzerdefiniertes Cloud Router Route Advertisement in vertex-networking-vpc, um Routen für den Private Service Connect-Endpunkt gegenüber onprem-dataservice-vpc anzukündigen.
Erstellen Sie eine Filestore-Instanz im onprem-dataservice-vpc-VPC-Netzwerk und fügen Sie ihr Trainingsdaten in einer NFS-Freigabe hinzu.
Erstellen Sie eine Python-Paketanwendung für den Trainingsjob.
Erstellen Sie eine Vertex AI Pipelines-Jobvorlage, um Folgendes zu tun:
- Erstellen und führen Sie den Trainingsjob mit den Daten aus der NFS-Freigabe aus.
- Importieren Sie das trainierte Modell und laden Sie es in die Vertex AI Model Registry hoch.
- Erstellen Sie einen Vertex AI-Endpunkt für Onlinevorhersagen.
- Stellen Sie das Modell für den Endpunkt bereit.
Laden Sie die Pipelinevorlage in ein Artifact Registry-Repository hoch.
Verwenden Sie die Vertex AI Pipelines REST API, um einen Pipelineausführung von einem lokalen Datendiensthost (on-prem-dataservice-host) auszulösen.

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten von Google Cloud:

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen. Neuen Google Cloud-Nutzern steht möglicherweise eine kostenlose Testversion zur Verfügung.

Nach Abschluss der in diesem Dokument beschriebenen Aufgaben können Sie weitere Kosten vermeiden, indem Sie die erstellten Ressourcen löschen. Weitere Informationen finden Sie unter Bereinigen.

Vorbereitung

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.
Öffnen Sie Cloud Shell, um die in dieser Anleitung aufgeführten Befehle auszuführen. Cloud Shell ist eine interaktive Shell-Umgebung für Google Cloud, mit der Sie Projekte und Ressourcen über Ihren Webbrowser verwalten können.
Legen Sie in Cloud Shell das aktuelle Projekt auf Ihre Google Cloud-Projekt-ID fest und speichern Sie dann dieselbe Projekt-ID in der Shell-Variablen projectid:
```
  projectid="PROJECT_ID"
  gcloud config set project ${projectid}
```
Ersetzen Sie PROJECT_ID durch Ihre Projekt-ID. Sie finden Ihre Projekt-ID gegebenenfalls in der Google Cloud Console. Weitere Informationen finden Sie unter Projekt-ID ermitteln.
Wenn Sie nicht der Projektinhaber sind, bitten Sie den Projektinhaber, Ihnen die Rolle Projekt-IAM-Administrator (roles/resourcemanager.projectIamAdmin) zuzuweisen. Sie benötigen diese Rolle, um im nächsten Schritt IAM-Rollen zuzuweisen.
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

VPC-Netzwerke erstellen

In diesem Abschnitt erstellen Sie zwei VPC-Netzwerke: Ein VPC-Netzwerk für den Zugriff auf Google APIs für Vertex AI Pipelines und das andere zur Simulation eines lokalen Netzwerks. In jedem der beiden VPC-Netzwerke erstellen Sie einen Cloud Router und ein Cloud NAT-Gateway. Ein Cloud NAT-Gateway bietet ausgehende Verbindungen für Compute Engine-VM-Instanzen ohne externe IP-Adressen.

Führen Sie in der Cloud Shell die folgenden Befehle aus und ersetzen Sie dabei PROJECT_ID durch Ihre Projekt-ID:
```
projectid=PROJECT_ID
gcloud config set project ${projectid}
```

vertex-networking-vpc-VPC-Netzwerk erstellen

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

Erstellen Sie im Netzwerk vertex-networking-vpc ein Subnetz mit dem Namen pipeline-networking-subnet1 und dem primären IPv4-Bereich von 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

Erstellen Sie das VPC-Netzwerk, um das lokale Netzwerk (onprem-dataservice-vpc) zu simulieren:
```
gcloud compute networks create onprem-dataservice-vpc \
    --subnet-mode custom
```

Erstellen Sie im Netzwerk onprem-dataservice-vpc ein Subnetz mit dem Namen onprem-dataservice-vpc-subnet1 und dem primären IPv4-Bereich von 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

Prüfen, ob die VPC-Netzwerke richtig konfiguriert sind

Rufen Sie in der Google Cloud Console den Tab Netzwerke im aktuellen Projekt auf der Seite VPC-Netzwerke auf.

Zur Seite VPC-Netzwerke
Prüfen Sie in der Liste der VPC-Netzwerke, ob die beiden Netzwerke erstellt wurden: vertex-networking-vpc und onprem-dataservice-vpc.
Klicken Sie auf den Tab Subnetze im aktuellen Projekt.
Prüfen Sie in der Liste der VPC-Subnetze, ob die Subnetze pipeline-networking-subnet1 und onprem-dataservice-vpc-subnet1 erstellt wurden.

Hybridkonnektivität konfigurieren

In diesem Abschnitt erstellen Sie zwei (HA VPN)-Gateways, die miteinander verbunden sind. Eines befindet sich im VPC-Netzwerk vertex-networking-vpc. Das andere befindet sich im VPC-Netzwerk onprem-dataservice-vpc. Jedes Gateway enthält einen Cloud Router und ein VPN-Tunnelpaar.

HA VPN-Gateways erstellen

Erstellen Sie in Cloud Shell das HA VPN-Gateway für das VPC-Netzwerk vertex-networking-vpc:

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

Erstellen Sie das HA VPN-Gateway für das VPC-Netzwerk onprem-dataservice-vpc:

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

Wechseln Sie in der Google Cloud Console auf der Seite VPN zum Tab Cloud VPN-Gateways.

Zu VPN
Prüfen Sie, ob die beiden Gateways (vertex-networking-vpn-gw1 und onprem-vpn-gw1) erstellt wurden und ob jedes Gateway zwei Schnittstellen-IP-Adressen hat.

Cloud Router und Cloud NAT-Gateways erstellen

In jedem der beiden VPC-Netzwerke erstellen Sie zwei Cloud Router: einen für die Verwendung mit Cloud NAT und einen für die Verwaltung von BGP-Sitzungen für das HA VPN.

Erstellen Sie in Cloud Shell einen Cloud Router für das VPC-Netzwerk vertex-networking-vpc, das für das VPN verwendet wird:

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

Erstellen Sie einen Cloud Router für das VPC-Netzwerk onprem-dataservice-vpc, das für das VPN verwendet werden soll:

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

Erstellen Sie einen Cloud Router für das VPC-Netzwerk vertex-networking-vpc, das für Cloud NAT verwendet wird:

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

Konfigurieren Sie ein Cloud NAT-Gateway auf dem regionalen Cloud Router:

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

Erstellen Sie einen Cloud Router für das VPC-Netzwerk onprem-dataservice-vpc, das für Cloud NAT verwendet wird:

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

Konfigurieren Sie ein Cloud NAT-Gateway auf dem regionalen Cloud Router:

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

Wechseln Sie in der Google Cloud Console zur Seite Cloud Routers.

Zu "Cloud Router"
Prüfen Sie in der Liste Cloud Router, ob die folgenden Router erstellt wurden:
- cloud-router-us-central1-onprem-nat
- cloud-router-us-central1-vertex-nat
- onprem-dataservice-vpc-router1
- vertex-networking-vpc-router1
Möglicherweise müssen Sie den Browsertab der Google Cloud Console aktualisieren, um die neuen Werte zu sehen.
Klicken Sie in der Liste der Cloud Router auf cloud-router-us-central1-vertex-nat.
Prüfen Sie auf der Seite Routerdetails, ob das Cloud NAT-Gateway cloud-nat-us-central1 erstellt wurde.
Klicken Sie auf den Zurückpfeil, um zur Seite Cloud Router zurückzukehren.
Klicken Sie in der Liste der Cloud Router auf cloud-router-us-central1-onprem-nat.
Prüfen Sie auf der Seite Routerdetails, ob das Cloud NAT-Gateway cloud-nat-us-central1-on-prem erstellt wurde.

VPN-Tunnel erstellen

Erstellen Sie in der Cloud Shell im Netzwerk vertex-networking-vpc einen VPN-Tunnel mit dem Namen 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

Erstellen Sie im Netzwerk vertex-networking-vpc einen VPN-Tunnel mit dem Namen 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

Erstellen Sie im Netzwerk onprem-dataservice-vpc einen VPN-Tunnel mit dem Namen 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

Erstellen Sie im Netzwerk onprem-dataservice-vpc einen VPN-Tunnel mit dem Namen 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

Rufen Sie in der Google Cloud Console die Seite VPN auf.

Zu VPN
Prüfen Sie in der Liste der VPN-Tunnel, ob die vier VPN-Tunnel erstellt wurden.

BGP-Sitzungen erstellen

Cloud Router verwendet das Border Gateway Protocol (BGP), um Routen zwischen Ihrem VPC-Netzwerk (in diesem Fall vertex-networking-vpc) und Ihrem lokalen Netzwerk (dargestellt durch onprem-dataservice-vpc) auszutauschen. Auf dem Cloud Router konfigurieren Sie eine Schnittstelle und einen BGP-Peer für Ihren lokalen Router. Die Konfigurationen für Schnittstelle und BGP-Peer bilden zusammen eine BGP-Sitzung. In diesem Abschnitt erstellen Sie zwei BGP-Sitzungen für vertex-networking-vpc und zwei für onprem-dataservice-vpc.

Nachdem Sie die Schnittstellen und BGP-Peers zwischen Ihren Routern konfiguriert haben, beginnen sie automatisch mit dem Austausch von Routen.

BGP-Sitzungen für `vertex-networking-vpc` erstellen

Erstellen Sie in Cloud Shell im Netzwerk vertex-networking-vpc eine BGP-Schnittstelle für 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

Erstellen Sie im Netzwerk vertex-networking-vpc einen BGP-Peer für 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

Erstellen Sie im Netzwerk vertex-networking-vpc eine BGP-Schnittstelle für 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

Erstellen Sie im Netzwerk vertex-networking-vpc einen BGP-Peer für 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

BGP-Sitzungen für `onprem-dataservice-vpc` erstellen

Erstellen Sie im Netzwerk onprem-dataservice-vpc eine BGP-Schnittstelle für 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

Erstellen Sie im Netzwerk onprem-dataservice-vpc einen BGP-Peer für 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

Erstellen Sie im Netzwerk onprem-dataservice-vpc eine BGP-Schnittstelle für 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

Erstellen Sie im Netzwerk onprem-dataservice-vpc einen BGP-Peer für 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

BGP-Sitzungserstellung prüfen

Rufen Sie in der Google Cloud Console die Seite VPN auf.

Zu VPN
Prüfen Sie in der Liste der VPN-Tunnel, ob sich der Wert in der Spalte BGP-Sitzungsstatus für jeden Tunnel von BGP-Sitzung konfigurieren in BGP eingerichtet gändert. Möglicherweise müssen Sie den Browsertab der Google Cloud Console aktualisieren, um die neuen Werte zu sehen.

Erkannte Routen `onprem-dataservice-vpc` validieren

Rufen Sie in der Google Cloud Console die Seite VPC-Netzwerke auf.

Zur Seite VPC-Netzwerke
Klicken Sie in der Liste der VPC-Netzwerke auf onprem-dataservice-vpc.
Klicken Sie auf den Tab Routen.
Wählen Sie in der Liste Region die Option us-central1 (Iowa) aus und klicken Sie auf Ansehen.
Prüfen Sie in der Spalte Ziel-IP-Adressbereich, ob der Subnetz-IP-Bereich pipeline-networking-subnet1 (10.0.0.0/24) zweimal angezeigt wird.

Möglicherweise müssen Sie den Browsertab der Google Cloud Console aktualisieren, um beide Einträge zu sehen.

Erkannte Routen `vertex-networking-vpc` validieren

Klicken Sie auf den Zurückpfeil, um zur Seite VPC-Netzwerke zurückzukehren.
Klicken Sie in der Liste der VPC-Netzwerke auf vertex-networking-vpc.
Klicken Sie auf den Tab Routen.
Wählen Sie in der Liste Region die Option us-central1 (Iowa) aus und klicken Sie auf Ansehen.
Prüfen Sie in der Spalte Ziel-IP-Adressbereich, ob der IP-Bereich des Subnetzes onprem-dataservice-vpc-subnet1 (172.16.10.0/24) zweimal angezeigt wird.

Private Service Connect-Endpunkt für Google APIs erstellen

In diesem Abschnitt erstellen Sie einen Private Service Connect-Endpunkt für Google APIs, mit dem Sie von Ihrem lokalen Netzwerk aus auf die Vertex AI Pipelines REST API zugreifen.

Reservieren Sie in Cloud Shell eine Nutzerendpunkt-IP-Adresse, die für den Zugriff auf Google APIs verwendet wird:

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

Erstellen Sie eine Weiterleitungsregel, um den Endpunkt mit Google APIs und Google-Diensten zu verbinden.

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

Benutzerdefinierte Route Advertisements für `vertex-networking-vpc` erstellen

In diesem Abschnitt erstellen Sie Folgendes:Benutzerdefiniertes Route Advertisement fürvertex-networking-vpc-router1 (Der Cloud Router für vertex-networking-vpc ), um die IP-Adresse des PSC-Endpunkts gegenüber deronprem-dataservice-vpc VPC-Netzwerk zu bewerben

Wechseln Sie in der Google Cloud Console zur Seite Cloud Routers.

Zu "Cloud Router"
Klicken Sie in der Liste der Cloud Router auf vertex-networking-vpc-router1.
Klicken Sie auf der Seite Routerdetails auf Bearbeiten.
Wählen Sie im Abschnitt Beworbene Routen für Routen die Option Benutzerdefinierte Routen erstellen.
Wählen Sie das Kästchen Alle für den Cloud Router sichtbaren Subnetze bewerben aus. Damit können Sie weiterhin die Subnetze bewerben, die für den Cloud Router zur Verfügung stehen. Wenn Sie diese Option aktivieren, entspricht dies dem Verhalten von Cloud Router im standardmäßigen Advertisement-Modus.
Klicken Sie auf Benutzerdefinierte Route hinzufügen.
Wählen Sie für Quelle die Option Benutzerdefinierter IP-Bereich aus.
Geben Sie als IP-Adressbereich die folgende IP-Adresse ein:
```
192.168.0.1
```

Geben Sie unter Beschreibung den folgenden Text ein:

Custom route to advertise Private Service Connect endpoint IP address

Klicken Sie auf Fertig und anschließend auf Speichern.

Prüfen, ob `onprem-dataservice-vpc` die beworbenen Routen erlernt hat

Rufen Sie in der Google Cloud Console die Seite Routen auf.

Zur Seite „Routes“
Führen Sie auf dem Tab Aktive Routen folgende Schritte aus:
1. Wählen Sie für Netzwerk die Option onprem-dataservice-vpc aus.
2. Wählen Sie bei Region die Option us-central1 (Iowa) aus.
3. Klicken Sie auf Ansehen.
4. Prüfen Sie in der Liste der Routen, ob zwei Einträge vorhanden sind, deren Namen mit onprem-dataservice-vpc-router1-bgp-vertex-networking-vpc-tunnel0 und zwei, deren Namen mit onprem-dataservice-vpc-router1-bgp-vertex-networking-vpc-tunnel1 beginnen.
  
  Wenn diese Einträge nicht sofort angezeigt werden, warten Sie einige Minuten und aktualisieren Sie dann den Browsertab der Google Cloud Console.
5. Prüfen Sie, ob zwei der Einträge einen Ziel-IP-Bereich von 192.168.0.1/32 und zwei einen Ziel-IP-Bereich von 10.0.0.0/24 haben.

VM-Instanz in `onprem-dataservice-vpc` erstellen

In diesem Abschnitt erstellen Sie eine VM-Instanz, die einen lokalen Datendiensthost simuliert. Gemäß den Best Practices für Compute Engine und IAM verwendet diese VM ein nutzerverwaltetes Dienstkonto anstelle des Compute Engine-Standarddienstkontos.

Vom Nutzer verwaltetes Dienstkonto für die VM-Instanz erstellen

Führen Sie in der Cloud Shell die folgenden Befehle aus und ersetzen Sie dabei PROJECT_ID durch Ihre Projekt-ID:
```
projectid=PROJECT_ID
gcloud config set project ${projectid}
```

Erstellen Sie ein Dienstkonto mit dem Namen onprem-user-managed-sa:

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

Weisen Sie dem Dienstkonto die IAM-Rolle Vertex AI User (roles/aiplatform.user) zu:

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

Weisen Sie die Rolle Vertex AI-Betrachter (roles/aiplatform.viewer) zu:

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

Weisen Sie die Rolle Filestore-Bearbeiter (roles/file.editor) zu:

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

Weisen Sie die Rolle Dienstkonto Administrator (roles/iam.serviceAccountAdmin) zu:

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

Weisen Sie die Rolle Dienstkontonutzer (roles/iam.serviceAccountUser) zu.

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

Weisen Sie die Rolle Artifact Registry-Leser (roles/artifactregistry.reader) zu:

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

Weisen Sie die Rolle Storage-Objekt-Administrator (roles/storage.objectAdmin) zu.

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

Weisen Sie die Rolle Logging-Administrator (roles/logging.admin) zu:

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

`on-prem-dataservice-host` VM-Instanz erstellen

Die von Ihnen erstellte VM-Instanz hat keine externe IP-Adresse und lässt keinen direkten Zugriff über das Internet zu. Zum Aktivieren des Administratorzugriffs auf die VM verwenden Sie die TCP-Weiterleitung von Identity-Aware Proxy (IAP).

Erstellen Sie in Cloud Shell die VM-Instanz 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"

Erstellen Sie eine Firewallregel, damit IAP eine Verbindung zu Ihrer VM-Instanz herstellen kann:

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

zu Aktualisieren die Datei `/etc/hosts`, sodass sie auf den PSC-Endpunkt verweist.

In diesem Schritt fügen Sie der Datei /etc/hosts eine Zeile hinzu, die bewirkt, dass an den öffentlichen Dienstendpunkt (us-central1-aiplatform.googleapis.com) gesendete Anfragen an den PSC-Endpunkt (192.168.0.1) weitergeleitet werden.

Melden Sie sich in Cloud Shell mit IAP bei der VM-Instanz on-prem-dataservice-host an:

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

Verwenden Sie auf der VM-Instanz on-prem-dataservice-host einen Texteditor wie vim oder nano, um die Datei /etc/hosts zu öffnen, z. B.:
```
sudo vim /etc/hosts
```

Fügen Sie der Datei die folgende Zeile hinzu:

192.168.0.1 us-central1-aiplatform.googleapis.com

Diese Zeile weist dem vollständig qualifizierten Domainnamen für die Vertex AI Google API (us-central1-aiplatform.googleapis.com) die IP-Adresse des PSC-Endpunkts (192.168.0.1) zu.

Die bearbeitete Datei sollte folgendermaßen aussehen:

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

Speichern Sie die Datei so:
- Wenn Sie vim verwenden, drücken Sie die Taste Esc und geben Sie dann :wq ein, um die Datei zu speichern und zu beenden.
- Wenn Sie nano verwenden, geben Sie Control+O ein und drücken Sie Enter, um die Datei zu speichern. Geben Sie dann zum Beenden Control+X ein.
Pingen Sie den Vertex AI API-Endpunkt so an:
```
ping us-central1-aiplatform.googleapis.com
```
Der Befehl ping sollte Folgendes zurückgeben: 192.168.0.1 ist die IP-Adresse des PSC-Endpunkts:
```
PING us-central1-aiplatform.googleapis.com (192.168.0.1) 56(84) bytes of data.
```
Geben Sie Control+C ein, um ping zu beenden.
Geben Sie exit ein, um die on-prem-dataservice-host-VM-Instanz zu beenden und zum Cloud Shell-Prompt zurückzukehren.

Netzwerk für eine Filestore-Instanz konfigurieren

In diesem Abschnitt aktivieren Sie den Zugriff auf private Dienste für Ihr VPC-Netzwerk, um eine Filestore-Instanz zu erstellen und als NFS-Freigabe (Network File System) bereitzustellen. Informationen zu den Schritten in diesem und im nächsten Abschnitt finden Sie unter NFS-Freigabe für benutzerdefiniertes Training bereitstellen und VPC-Netzwerk-Peering einrichten.

Zugriff auf private Dienste in einem VPC-Netzwerk aktivieren

In diesem Abschnitt erstellen Sie eine Dienstnetzwerkverbindung und ermöglichen damit privaten Dienstzugriff auf das onprem-dataservice-vpc-VPC-Netzwerk über das VPC-Netzwerk-Peering.

Legen Sie in Cloud Shell mit gcloud compute addresses create einen reservierten IP-Adressbereich fest:

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

Stellen Sie mithilfe von gcloud services vpc-peerings connect eine Peering-Verbindung zwischen dem onprem-dataservice-vpc-VPC-Netzwerk und dem Google-Dienstnetzwerk her:

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

Aktualisieren Sie das VPC-Netzwerk-Peering, um den Import und Export benutzerdefinierter gelernter Routen zu aktivieren:

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

Rufen Sie in der Google Cloud Console die Seite VPC-Netzwerk-Peering auf.

Zum VPC-Netzwerk-Peering
Prüfen Sie in der Liste der VPC-Peerings, ob es einen Eintrag für das Peering zwischen servicenetworking.googleapis.com und dem VPC-Netzwerk onprem-dataservice-vpc gibt.

Benutzerdefinierte Route Advertisements für `filestore-subnet` erstellen

Wechseln Sie in der Google Cloud Console zur Seite Cloud Routers.

Zu "Cloud Router"
Klicken Sie in der Liste der Cloud Router auf onprem-dataservice-vpc-router1.
Klicken Sie auf der Seite Routerdetails auf Bearbeiten.
Wählen Sie im Abschnitt Beworbene Routen für Routen die Option Benutzerdefinierte Routen erstellen.
Wählen Sie das Kästchen Alle für den Cloud Router sichtbaren Subnetze bewerben aus. Damit können Sie weiterhin die Subnetze bewerben, die für den Cloud Router zur Verfügung stehen. Wenn Sie diese Option aktivieren, entspricht dies dem Verhalten von Cloud Router im standardmäßigen Advertisement-Modus.
Klicken Sie auf Benutzerdefinierte Route hinzufügen.
Wählen Sie für Quelle die Option Benutzerdefinierter IP-Bereich aus.
Geben Sie als IP-Adressbereich die folgende IP-Adressbereich ein:
```
10.243.208.0/24
```
Geben Sie unter Beschreibung den folgenden Text ein:
```
Filestore reserved IP address range
```
Klicken Sie auf Fertig und anschließend auf Speichern.

Filestore-Instanz im `onprem-dataservice-vpc`-Netzwerk erstellen

Nachdem Sie den Zugriff auf private Dienste für Ihr VPC-Netzwerk aktiviert haben, erstellen Sie eine Filestore-Instanz und stellen Sie die Instanz als NFS-Freigabe für Ihren benutzerdefinierten Trainingsjob bereit. Dadurch können Ihre Trainings-Jobs auf Remotedateien zugreifen, als ob sie lokal wären, was einen hohen Durchsatz und eine niedrige Latenz ermöglicht.

Erstellen Sie die Filestore-Instanz.

Rufen Sie in der Google Cloud Console die Seite Filestore-Instanzen auf.

Zur Seite „Filestore-Instanzen“
Klicken Sie auf Instanz erstellen und konfigurieren Sie die Instanz wie folgt.
- Legen Sie für Instanz-ID Folgendes fest:
```
image-data-instance
```
- Wählen Sie als Instanztyp die Option Basis aus.
- Legen Sie Speichertyp auf HDD fest.
- Setzen Sie Kapazität zuweisen auf 1 TiB.
- Legen Sie für Region den Wert us-central1 und für Zone den Wert us-central1-a fest.
- Legen Sie VPC-Netzwerk auf onprem-dataservice-vpc fest.
- Legen Sie für Zugewiesener IP-Bereich die Option Vorhandenen zugewiesenen IP-Bereich verwenden fest und wählen Sie filestore-subnet aus.
- Legen Sie für Dateifreigabe-Name Folgendes fest:
```
vol1
```
- Legen Sie unter Zugriffssteuerungen die Option Allen Clients im VPC-Netzwerk Zugriff gewähren fest.
Klicken Sie auf Erstellen.
Notieren Sie sich die IP-Adresse Ihrer neuen Filestore-Instanz. Möglicherweise müssen Sie den Browsertab der Google Cloud Console aktualisieren, um die neue Instanz zu sehen.

Filestore-Dateifreigabe bereitstellen

Führen Sie in der Cloud Shell die folgenden Befehle aus und ersetzen Sie dabei PROJECT_ID durch Ihre Projekt-ID:
```
projectid=PROJECT_ID
gcloud config set project ${projectid}
```

Melden Sie sich bei der VM-Instanz on-prem-dataservice-host an:

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

Installieren Sie das NFS-Paket auf der VM-Instanz:

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

Erstellen Sie ein Bereitstellungsverzeichnis für die Filestore-Dateifreigabe:
```
sudo mkdir -p /mnt/nfs
```
Hinweis :Der Ordnername des Bereitstellungspunkts in /mnt/ muss nfs sein. Das liegt daran, dass die NFS-Dateifreigabe im benutzerdefinierten Trainingsjob unter /mnt/nfs/ bereitgestellt wird.
Stellen Sie die Dateifreigabe bereit. Ersetzen Sie dazu FILESTORE_INSTANCE_IP durch die IP-Adresse Ihrer Filestore-Instanz:
```
sudo mount FILESTORE_INSTANCE_IP:/vol1 /mnt/nfs
```
Wenn die Verbindung überschreitet, müssen Sie die richtige IP-Adresse der Filestore-Instanz angeben.

Prüfen Sie mit dem folgenden Befehl, ob die NFS-Bereitstellung erfolgreich war:

df -h

Prüfen Sie, ob die Dateifreigabe /mnt/nfs im Ergebnis angezeigt wird:

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

Ändern Sie die Berechtigungen, um den Zugriff auf die Dateifreigabe zu ermöglichen:
```
sudo chmod go+rw /mnt/nfs
```
Hinweis :In einer Produktionsumgebung empfehlen wir, detailliertere Berechtigungen festzulegen. Weitere Informationen finden Sie unter Zugriff auf eine Dateifreigabe konfigurieren.

Dataset in die Dateifreigabe herunterladen

Laden Sie den Datset in der VM-Instanz on-prem-dataservice-host in die Dateifreigabe herunter:
```
gcloud storage cp gs://cloud-samples-data/vertex-ai/dataset-management/datasets/fungi_dataset /mnt/nfs/ --recursive
```
Der Download dauert einige Minuten.
Prüfen Sie mit dem folgenden Befehl, ob das Dataset erfolgreich kopiert wurde:
```
sudo du -sh /mnt/nfs
```
Folgende Ausgabe wird erwartet:
```
104M    /mnt/nfs
```
Geben Sie exit ein, um die on-prem-dataservice-host-VM-Instanz zu beenden und zum Cloud Shell-Prompt zurückzukehren.

Staging-Bucket für Ihre Pipeline erstellen

Vertex AI Pipelines speichert die Artefakte Ihrer Pipeline, die Cloud Storage verwenden. Bevor Sie die Pipeline ausführen, müssen Sie einen Cloud Storage-Bucket für die Ausführung von Staging-Pipelines erstellen.

Erstellen Sie in Cloud Shell einen Cloud Storage-Bucket.

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

Nutzerverwaltetes Dienstkonto für Vertex AI Workbench erstellen

Erstellen Sie in Cloud Shell ein Dienstkonto:

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

Weisen Sie dem Dienstkonto die IAM-Rolle Vertex AI User (roles/aiplatform.user) zu:

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

Weisen Sie die Rolle Artifact Registry-Administrator (artifactregistry.admin) zu:

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

Weisen Sie die Rolle Storage Admin (storage.admin) zu:

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

Python-Trainingsanwendung erstellen

In diesem Abschnitt erstellen Sie eine Vertex AI Workbench-Instanz und verwenden diese, um ein benutzerdefiniertes Python-Trainingsanwendungspaket zu erstellen.

Vertex AI Workbench-Instanz erstellen

Rufen Sie in der Google Cloud Console auf der Seite Vertex AI Workbench den Tab Instanzen auf.

Zu Vertex AI Workbench
Klicken Sie auf Neu erstellen und wählen Sie Erweiterte Optionen aus.

Die Seite Neue Instanz wird geöffnet.
Geben Sie auf der Seite Neue Instanz im Abschnitt Details die folgenden Informationen für Ihre neue Instanz ein und klicken Sie dann auf Weiter:
- Name: Geben Sie Folgendes ein und ersetzen Sie dabei PROJECT_ID durch die Projekt-ID:
```
pipeline-tutorial-PROJECT_ID
```
- Region: Wählen Sie us-central1 aus.
- Zone: Wählen Sie us-central1-a aus.
- Entfernen Sie das Häkchen aus dem Kästchen Serverlose interaktive Dataproc-Sitzungen aktivieren.
Klicken Sie im Bereich Umgebung auf Weiter.
Geben Sie im Abschnitt Maschinentyp Folgendes ein und klicken Sie dann auf Weiter:
- Maschinentyp: Wählen Sie N1 und dann n1-standard-4 aus dem Menü Maschinentyp aus.
- Shielded VM: Klicken Sie die folgenden Kästchen an:
  - Secure Boot
  - Virtual Trusted Platform Module (vTPM)
  - Integritätsmonitoring
Achten Sie darauf, dass im Abschnitt Laufwerke die Option Von Google verwalteter Verschlüsselungsschlüssel ausgewählt ist. Klicken Sie dann auf Weiter:
Geben Sie im Abschnitt Netzwerk Folgendes ein und klicken Sie dann auf Weiter:
- Netzwerk: Wählen Sie Netzwerk in diesem Projekt aus und führen Sie die folgenden Schritte aus:
  1. Wählen Sie im Feld Netzwerk die Option vertex-networking-vpc aus.
  2. Wählen Sie im Feld Subnetzwerk die Option pipeline-networking-subnet1 aus.
  3. Entfernen Sie das Häkchen aus dem Kästchen Externe IP-Adresse zuweisen. Wenn Sie keine externe IP-Adresse zuweisen, kann die Instanz keine unerwünschten Nachrichten über das Internet oder andere VPC-Netzwerke mehr empfangen.
  4. Klicken Sie auf das Kästchen Proxyzugriff zulassen.
Geben Sie im Abschnitt IAM und Sicherheit Folgendes ein und klicken Sie dann auf Weiter:
- IAM und Sicherheit: Führen Sie die folgenden Schritte aus, um einem einzelnen Nutzer Zugriff auf die JupyterLab-Oberfläche der Instanz zu gewähren:
  1. Wählen Sie Dienstkonto aus.
  2. Entfernen Sie das Häkchen aus dem Kästchen Compute Engine-Standarddienstkonto verwenden. Dieser Schritt ist wichtig, da dem Compute Engine-Standarddienstkonto (und damit dem soeben angegebenen einzelnen Nutzer) die Rolle "Editor" (roles/editor) für Ihr Projekt haben könnte.
  3. Geben Sie im Feld E-Mail-Adresse des Dienstkontos Folgendes ein und ersetzen Sie PROJECT_ID durch die Projekt-ID:
```
workbench-sa@PROJECT_ID.iam.gserviceaccount.com
```
    (Dies ist die E-Mail-Adresse des benutzerdefinierten Dienstkontos, die Sie zuvor erstellt haben.) Dieses Dienstkonto hat eingeschränkte Berechtigungen.
    
    Weitere Informationen zum Gewähren des Zugriffs finden Sie unter Zugriff auf die JupyterLab-Oberfläche einer Vertex AI Workbench-Instanz verwalten.
- Sicherheitsoptionen: Entfernen Sie das Häkchen aus dem folgenden Kästchen:
  - Root-Zugriff auf die Instanz
  Klicken Sie das folgende Kästchen an:
  - nbconvert: Mit nbconvert können Nutzer eine Notebookdatei als anderen Dateityp exportieren und herunterladen, z. B. HTML, PDF oder LaTeX. Diese Einstellung ist für einige Notebooks im GitHub-Repository Google Cloud Generative AI erforderlich.
  Entfernen Sie das Häkchen aus dem folgenden Kästchen:
  - Download von Dateien
  Klicken Sie auf das folgende Kästchen, sofern Sie sich nicht in einer Produktionsumgebung befinden:
  - Terminalzugriff: Dies ermöglicht den Terminalzugriff auf Ihre Instanz über die JupyterLab-Benutzeroberfläche.
Heben Sie im Bereich Systemzustand die Auswahl der Option Automatisches Umgebungsupgrade auf und geben Sie Folgendes an:
- Klicken Sie unter Berichterstellung die folgenden Kästchen an:
  - Bericht zum Systemzustand aktivieren
  - Benutzerdefinierte Messwerte an Cloud Monitoring melden
  - Cloud Monitoring installieren
  - DNS-Status für erforderliche Google-Domains melden
Klicken Sie auf Erstellen und warten Sie einige Minuten, bis die Vertex AI Workbench-Instanz erstellt ist.

Trainingsanwendung in der Vertex AI Workbench-Instanz ausführen

Rufen Sie in der Google Cloud Console auf der Seite Vertex AI Workbench den Tab Instanzen auf.

Zu Vertex AI Workbench
Klicken Sie neben dem Namen der Vertex AI Workbench-Instanz (pipeline-tutorial-PROJECT_ID, wobei PROJECT_ID die Projekt-ID ist) auf JupyterLab öffnen.

Ihre Vertex AI Workbench-Instanz öffnet JupyterLab.
Wählen Sie Datei > Neu > Terminal aus.
Definieren Sie im JupyterLab-Terminal (nicht in Cloud Shell) eine Umgebungsvariable für Ihr Projekt. Ersetzen Sie PROJECT_ID durch Ihre Projekt-ID:
```
projectid=PROJECT_ID
```
Erstellen Sie die übergeordneten Verzeichnisse für die Trainingsanwendung (noch im JupyterLab-Terminal):
```
mkdir fungi_training_package
mkdir fungi_training_package/trainer
```
Doppelklicken Sie im Dateibrowser auf den Ordner fungi_training_package und dann auf den Ordner trainer.
Klicken Sie im Dateibrowser mit der rechten Maustaste auf die leere Dateiliste unter der Überschrift Name und wählen Sie Neue Datei aus.
Klicken Sie mit der rechten Maustaste auf die neue Datei und wählen Sie Datei umbenennen aus.
Benennen Sie die Datei von untitled.txt in task.py um.
Doppelklicken Sie auf die Datei task.py, um sie zu öffnen.

Kopieren Sie den folgenden Code 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)

Wählen Sie Datei > Python-Datei speichern aus.
Erstellen Sie im JupyterLab-Terminal in jedem Unterverzeichnis eine Datei __init__.py, um sie zu einem Paket hinzuzufügen:
```
touch fungi_training_package/__init__.py
touch fungi_training_package/trainer/__init__.py
```
Doppelklicken Sie im Dateibrowser auf den neuen Ordner fungi_training_package.
Wählen Sie Datei > Neu > Python-Datei aus.
Klicken Sie mit der rechten Maustaste auf die neue Datei und wählen Sie Datei umbenennen aus.
Benennen Sie die Datei von untitled.py in setup.py um.
Doppelklicken Sie auf die Dateisetup.py, um sie zu öffnen.

Kopieren Sie den folgenden Code 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.'
)

Wählen Sie Datei > Python-Datei speichern aus.
Öffnen Sie in Ihrem Terminal das Verzeichnis fungi_training_package:
```
cd fungi_training_package
```
Verwenden Sie den Befehl sdist, um die Quellverteilung der Trainingsanwendung zu erstellen.
```
python setup.py sdist --formats=gztar
```
Wechseln Sie zum übergeordneten Verzeichnis:
```
cd ..
```
Prüfen Sie, ob Sie sich im richtigen Verzeichnis befinden:
```
pwd
```
Sie erhalten folgende Ausgabe:
```
/home/jupyter
```

Kopieren Sie das Python-Paket in den Staging-Bucket:

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

Prüfen Sie, ob der Staging-Bucket das Paket enthält:

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

Die Ausgabe sieht so aus:

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

Dienstnetzwerkverbindung für Vertex AI Pipelines erstellen

In diesem Abschnitt erstellen Sie eine Dienstnetzwerkverbindung, mit der Erstellerdienste etabliert werden, die über VPC-Netzwerk-Peering mit dem VPC-Netzwerk vertex-networking-vpc verbunden sind. Weitere Informationen finden Sie unter VPC-Netzwerk-Peering.

Führen Sie in der Cloud Shell die folgenden Befehle aus und ersetzen Sie dabei PROJECT_ID durch Ihre Projekt-ID:
```
projectid=PROJECT_ID
gcloud config set project ${projectid}
```

Legen Sie mit gcloud compute addresses create einen reservierten IP-Adressbereich fest:

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

Stellen Sie mithilfe von gcloud services vpc-peerings connect eine Peering-Verbindung zwischen dem vertex-networking-vpc-VPC-Netzwerk und dem Google-Dienstnetzwerk her:

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

Aktualisieren Sie die VPC-Peering-Verbindung, um den Import und Export benutzerdefinierter gelernter Routen zu aktivieren:

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

Pipeline-Subnetz über den `pipeline-networking`-Cloud Router bewerben

Wechseln Sie in der Google Cloud Console zur Seite Cloud Router.

Zu Cloud Routers
Klicken Sie in der Liste der Cloud Router auf vertex-networking-vpc-router1.
Klicken Sie auf der Seite Routerdetails auf Bearbeiten.
Klicken Sie auf Benutzerdefinierte Route hinzufügen.
Wählen Sie für Quelle die Option Benutzerdefinierter IP-Bereich aus.
Geben Sie als IP-Adressbereich die folgende IP-Adressbereich ein:
```
192.168.10.0/24
```
Geben Sie unter Beschreibung den folgenden Text ein:
```
Vertex AI Pipelines reserved subnet
```
Klicken Sie auf Fertig und anschließend auf Speichern.

Pipelinevorlage erstellen und in Artifact Registry hochladen

In diesem Abschnitt erstellen und laden Sie eine Pipelinevorlage für Kubeflow Pipelines (KFP) hoch. Diese Vorlage enthält eine Workflowdefinition, die mehrmals von einem einzelnen Nutzer oder von mehreren Nutzern wiederverwendet werden kann.

Pipeline definieren und kompilieren

Doppelklicken Sie in JupyterLab im Dateibrowser auf den obersten Ordner.
Wählen Sie File > New > Notebook aus.
Wählen Sie im Menü Kernel auswählen die Option Python 3 (ipykernel) aus und klicken Sie auf Auswählen.
Führen Sie in einer neuen Notebookzelle den folgenden Befehl aus, um sicherzustellen, dass Sie die neueste Version von pip verwenden:
```
!python -m pip install --upgrade pip
```
Führen Sie den folgenden Befehl aus, um das Google Cloud Pipeline Components SDK aus dem Python Package Index (PyPI) zu installieren:
```
!pip install --upgrade google-cloud-pipeline-components
```
Wenn die Installation abgeschlossen ist, wählen Sie Kernel > Restart kernel, um den Kernel neu zu starten und dafür zu sorgen, dass die Bibliothek für den Import verfügbar ist.

Führen Sie den folgenden Code in einer neuen Notebook-Zelle aus, um die Pipeline zu definieren:

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

Führen Sie den folgenden Code in einer neuen Notebookzelle aus, um die Pipelinedefinition zu kompilieren:

from kfp import compiler 
PIPELINE_FILE = "pipeline_config.yaml"
compiler.Compiler().compile(
    pipeline_func=custom_image_classification_pipeline,
    package_path=PIPELINE_FILE,
)

Im Dateibrowser wird in der Dateiliste eine Datei namens pipeline_config.yaml angezeigt.

Artifact Registry-Repository erstellen

Führen Sie den folgenden Code in einer neuen Notebookzelle aus, um ein Artefakt-Repository vom Typ KFP zu erstellen:

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

Pipelinevorlage in Artifact Registry hochladen

In diesem Abschnitt konfigurieren Sie einen Registry-Client des Kubeflow Pipelines SDK und laden Ihre kompilierte Pipelinevorlage aus Ihrem JupyterLab-Notebook in Artifact Registry hoch.

Führen Sie in Ihrem JupyterLab-Notebook den folgenden Code aus, um die Pipeline-Vorlage hochzuladen. Ersetzen Sie dabei PROJECT_ID durch Ihre Projekt-ID:

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

Rufen Sie in der Google Cloud Console die Seite Vertex AI Pipelines-Vorlagen auf, um zu prüfen, ob Ihre Vorlage hochgeladen wurde.

Zu Pipelines
Klicken Sie zum Öffnen des Bereichs Repository auswählen auf Repository auswählen.
Klicken Sie in der Repository-Liste auf das von Ihnen erstellte Repository (fungi-repo) und dann auf Auswählen.
Prüfen Sie, ob Ihre Pipeline (custom-image-classification-pipeline) in der Liste aufgeführt ist.

Pipelineausführung lokal auslösen

In diesem Abschnitt verwenden Sie cURL, um einen Pipelineausführung über Ihre lokale Anwendung auszulösen, nachdem Sie die Pipeline-Vorlage und das Trainingspaket erstellt haben.

Pipelineparameter angeben

Führen Sie in Ihrem JupyterLab-Notebook den folgenden Befehl aus, um den Namen der Pipeline-Vorlage zu prüfen:
```
print (TEMPLATE_NAME)
```
Der zurückgegebene Name der Vorlage lautet:
```
custom-image-classification-pipeline
```
Führen Sie den folgenden Befehl aus, um die Version der Pipeline-Vorlage abzurufen:
```
print (VERSION_NAME)
```
Der zurückgegebene Name der Pipeline-Vorlageversion sieht so aus:
```
sha256:41eea21e0d890460b6e6333c8070d7d23d314afd9c7314c165efd41cddff86c7
```
Notieren Sie sich den gesamten String mit dem Versionsnamen.
Führen Sie in der Cloud Shell die folgenden Befehle aus und ersetzen Sie dabei PROJECT_ID durch Ihre Projekt-ID:
```
projectid=PROJECT_ID
gcloud config set project ${projectid}
```