Private Service Connect für den Zugriff auf Vertex AI-Onlinevorhersagen lokal verwenden

---

Lokale Hosts können einen Vertex AI-Onlinevorhersageendpunkt entweder über das öffentliche Internet oder privat über eine hybride Netzwerkarchitektur erreichen, die Private Service Connect (PSC) über Cloud VPN oder Cloud Interconnect verwendet. Beide Optionen bieten SSL/TLS-Verschlüsselung. Die private Option bietet jedoch eine deutlich bessere Leistung und wird daher für kritische Anwendungen empfohlen.

In dieser Anleitung verwenden Sie ein Hochverfügbarkeits-VPN (HA VPN), um auf einen Onlinevorhersage-Endpunkt sowohl öffentlich über Cloud NAT als auch privat zwischen zwei Virtual Private Cloud-Netzwerken zuzugreifen, die als Basis für private Konnektivität in Multi-Cloud- und lokalen Umgebungen dienen können.

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.

Hinweis: Der von Ihnen erstellte Vertex AI-Onlinevorhersageendpunkt ist ein öffentlicher Endpunkt. In einer Produktionsumgebung würden Sie VPC Service Controls verwenden, um sichere Perimeter zu erstellen, um den Zugriff auf Vertex AI und andere Google APIs auf dem Endpunkt der Onlinevorhersage über das öffentliche Internet zuzulassen oder zu verweigern. In dieser Anleitung wird die Verwendung von VPC Service Controls mit Vertex AI nicht behandelt.

Ziele

• Erstellen Sie zwei VPC-Netzwerke (Virtual Private Cloud), wie im vorherigen Diagramm dargestellt:
  • Das eine (on-prem-vpc) steht für ein lokales Netzwerk.
  • Das andere (aiml-vpc) dient zum Erstellen und Bereitstellen eines Vertex AI-Onlinevorhersagemodells.
• Stellen Sie HA VPN-Gateways, Cloud VPN-Tunnel und Cloud Router bereit, um aiml-vpc und on-prem-vpc zu verbinden.
• Erstellen Sie ein Vertex AI-Onlinevorhersagemodell und stellen Sie es bereit.
• Erstellen Sie einen PSC-Endpunkt (Private Service Connect), um private Onlinevorhersageanfragen an das bereitgestellte Modell weiterzuleiten.
• Aktivieren Sie den benutzerdefinierten Advertising-Modus von Cloud Router in aiml-vpc, um Routen für den Private Service Connect-Endpunkt gegenüber on-prem-vpc anzukündigen.
• Erstellen Sie in on-prem-vpc zwei Compute Engine-VM-Instanzen, die Clientanwendungen darstellen:
  • Ein (nat-client) sendet Onlinevorhersageanfragen über das öffentliche Internet (über Cloud NAT). Diese Zugriffsmethode wird durch einen roten Pfeil und die Zahl 1 im Diagramm angezeigt.
  • Das andere (private-client) sendet Vorhersageanfragen privat über HA VPN. Diese Zugriffsmethode wird durch einen grünen Pfeil und die Zahl 2 gekennzeichnet.

Kosten

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

• Artifact Registry
• Cloud NAT
• Cloud Storage
• Cloud VPN
• Compute Engine
• Vertex AI
• Virtual Private 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

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

   Go to project selector

2. Select or create a Google Cloud project.

3. Make sure that billing is enabled for your Google Cloud project.

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

6. Grant roles to your user account. Run the following command once for each of the following IAM roles: roles/appengine.appViewer, roles/artifactregistry.admin, roles/compute.instanceAdmin.v1, roles/compute.networkAdmin, roles/compute.securityAdmin, roles/dns.admin, roles/iap.admin, roles/iap.tunnelResourceAccessor, roles/notebooks.admin, roles/oauthconfig.editor, roles/resourcemanager.projectIamAdmin, roles/servicemanagement.quotaAdmin, roles/iam.serviceAccountAdmin, roles/iam.serviceAccountUser, roles/servicedirectory.editor, roles/storage.admin, roles/aiplatform.user

   gcloud projects add-iam-policy-binding PROJECT_ID --member="USER_IDENTIFIER" --role=ROLE

   • Replace PROJECT_ID with your project ID.

   • Replace USER_IDENTIFIER with the identifier for your user account. For example, user:[e-mail].

   • Replace ROLE with each individual role.

7. Enable the DNS, Artifact Registry, IAM, Compute Engine, Notebooks, and Vertex AI APIs:

   gcloud services enable dns.googleapis.com artifactregistry.googleapis.com iam.googleapis.com compute.googleapis.com notebooks.googleapis.com aiplatform.googleapis.com

VPC-Netzwerke erstellen

In diesem Abschnitt erstellen Sie zwei VPC-Netzwerke: eines zum Erstellen eines Onlinevorhersagemodells und das Bereitstellen auf einem Endpunkt, das andere für den privaten Zugriff auf diesen Endpunkt. 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.

VPC-Netzwerk für den Endpunkt der Onlinevorhersage (aiml-vpc) erstellen

1. VPC-Netzwerk erstellen:

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

2. Erstellen Sie ein Subnetz mit dem Namen workbench-subnet und den primären IPv4-Bereich 172.16.10.0/28:

   gcloud compute networks subnets create workbench-subnet \
       --project=$projectid \
       --range=172.16.10.0/28 \
       --network=aiml-vpc \
       --region=us-central1 \
       --enable-private-ip-google-access
   

3. Erstellen Sie einen regionalen Cloud Router mit dem Namen cloud-router-us-central1-aiml-nat:

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

4. Fügen Sie dem Cloud Router ein Cloud NAT-Gateway hinzu:

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

„Lokales“ VPC-Netzwerk (on-prem-vpc) erstellen

1. VPC-Netzwerk erstellen:

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

2. Erstellen Sie ein Subnetz mit dem Namen nat-subnet und den primären IPv4-Bereich 192.168.10.0/28:

   gcloud compute networks subnets create nat-subnet \
       --project=$projectid \
       --range=192.168.10.0/28 \
       --network=on-prem-vpc \
       --region=us-central1
   

3. Erstellen Sie ein Subnetz mit dem Namen private-ip-subnet und den primären IPv4-Bereich 192.168.20.0/28:

   gcloud compute networks subnets create private-ip-subnet \
       --project=$projectid \
       --range=192.168.20.0/28 \
       --network=on-prem-vpc \
       --region=us-central1
   

4. Erstellen Sie einen regionalen Cloud Router mit dem Namen cloud-router-us-central1-on-prem-nat:

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

5. Fügen Sie dem Cloud Router ein Cloud NAT-Gateway hinzu:

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

PSC-Endpunkt (Private Service Connect) erstellen

In diesem Abschnitt erstellen Sie den PSC-Endpunkt (Private Service Connect), mit dem die VM-Instanzen im on-prem-vpc-Netzwerk über die Vertex AI API auf den Onlinevorhersage-Endpunkt zugreifen. Der Private Service Connect-Endpunkt (PSC) ist eine interne IP-Adresse im on-prem-vpc-Netzwerk, auf die Clients in diesem Netzwerk direkt zugreifen können. Dieser Endpunkt wird durch die Bereitstellung einer Weiterleitungsregel erstellt, die den Netzwerk-Traffic, der mit der IP-Adresse des PSC-Endpunkts übereinstimmt, an ein Bundle von Google APIs weiterleitet. Die IP-Adresse des PSC-Endpunkts (100.100.10.10) wird in einem späteren Schritt vom Cloud Router aiml-cr-us-central1 als benutzerdefinierte beworbene Route zum Netzwerk on-prem-vpc beworben.

1. Reserviere IP-Adressen für den PSC-Endpunkt:

   gcloud compute addresses create psc-ip \
       --global \
       --purpose=PRIVATE_SERVICE_CONNECT \
       --addresses=100.100.10.10 \
       --network=aiml-vpc
   

2. Erstellen Sie den PSC-Endpunkt:

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

3. Liste der konfigurierten PSC-Endpunkte aufrufen und prüfen, ob der pscvertex-Endpunkt erstellt wurde:

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

4. Rufen Sie die Details des konfigurierten PSC-Endpunkts ab und prüfen Sie, ob die IP-Adresse 100.100.10.10 ist:

   gcloud compute forwarding-rules describe pscvertex \
       --global
   

Hybridkonnektivität konfigurieren

In diesem Abschnitt erstellen Sie zwei (HA VPN)-Gateways, die miteinander verbunden sind. Jedes Gateway enthält einen Cloud Router und ein VPN-Tunnelpaar.

1. Erstellen Sie das HA VPN-Gateway für das VPC-Netzwerk aiml-vpc:

   gcloud compute vpn-gateways create aiml-vpn-gw \
       --network=aiml-vpc \
       --region=us-central1
   

2. Erstellen Sie das HA VPN-Gateway für das VPC-Netzwerk on-prem-vpc:

   gcloud compute vpn-gateways create on-prem-vpn-gw \
       --network=on-prem-vpc \
       --region=us-central1
   

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

   Zu VPN

4. Klicken Sie auf der Seite VPN auf den Tab VPN.

5. Prüfen Sie in der Liste der VPN-Gateways, ob es zwei Gateways gibt und ob jedes zwei IP-Adressen hat.

6. Erstellen Sie in Cloud Shell einen Cloud Router für das aiml-vpc-Virtual Private Cloud-Netzwerk:

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

7. Erstellen Sie einen Cloud Router für das Virtual Private Cloud-Netzwerk on-prem-vpc:

   gcloud compute routers create on-prem-cr-us-central1 \
       --region=us-central1 \
       --network=on-prem-vpc \
       --asn=65002
   

VPN-Tunnel für aiml-vpc erstellen

1. Erstellen Sie einen VPN-Tunnel mit dem Namen aiml-vpc-tunnel0:

   gcloud compute vpn-tunnels create aiml-vpc-tunnel0 \
       --peer-gcp-gateway on-prem-vpn-gw \
       --region us-central1 \
       --ike-version 2 \
       --shared-secret [ZzTLxKL8fmRykwNDfCvEFIjmlYLhMucH] \
       --router aiml-cr-us-central1 \
       --vpn-gateway aiml-vpn-gw \
       --interface 0
   

2. Erstellen Sie einen VPN-Tunnel mit dem Namen aiml-vpc-tunnel1:

   gcloud compute vpn-tunnels create aiml-vpc-tunnel1 \
       --peer-gcp-gateway on-prem-vpn-gw \
       --region us-central1 \
       --ike-version 2 \
       --shared-secret [bcyPaboPl8fSkXRmvONGJzWTrc6tRqY5] \
       --router aiml-cr-us-central1 \
       --vpn-gateway aiml-vpn-gw \
       --interface 1
   

VPN-Tunnel für on-prem-vpc erstellen

1. Erstellen Sie einen VPN-Tunnel mit dem Namen on-prem-vpc-tunnel0:

   gcloud compute vpn-tunnels create on-prem-tunnel0 \
       --peer-gcp-gateway aiml-vpn-gw \
       --region us-central1 \
       --ike-version 2 \
       --shared-secret [ZzTLxKL8fmRykwNDfCvEFIjmlYLhMucH] \
       --router on-prem-cr-us-central1 \
       --vpn-gateway on-prem-vpn-gw \
       --interface 0
   

2. Erstellen Sie einen VPN-Tunnel mit dem Namen on-prem-vpc-tunnel1:

   gcloud compute vpn-tunnels create on-prem-tunnel1 \
       --peer-gcp-gateway aiml-vpn-gw \
       --region us-central1 \
       --ike-version 2 \
       --shared-secret [bcyPaboPl8fSkXRmvONGJzWTrc6tRqY5] \
       --router on-prem-cr-us-central1 \
       --vpn-gateway on-prem-vpn-gw \
       --interface 1
   

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

   Zu VPN

4. Klicken Sie auf der Seite VPN auf den Tab VPN.

5. Prüfen Sie in der Liste der VPN-Tunnel, ob vier VPN-Tunnel eingerichtet wurden.

BGP-Sitzungen erstellen

Cloud Router verwendet das Border Gateway Protocol (BGP), um Routen zwischen Ihrem VPC-Netzwerk (in diesem Fall aiml-vpc) und Ihrem lokalen Netzwerk (dargestellt durch on-prem-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 aiml-vpc und zwei für on-prem-vpc.

BGP-Sitzungen für aiml-vpc erstellen

1. Erstellen Sie in Cloud Shell die erste BGP-Schnittstelle:

   gcloud compute routers add-interface aiml-cr-us-central1 \
       --interface-name if-tunnel0-to-onprem \
       --ip-address 169.254.1.1 \
       --mask-length 30 \
       --vpn-tunnel aiml-vpc-tunnel0 \
       --region us-central1
   

2. Erstellen Sie den ersten BGP-Peer:

   gcloud compute routers add-bgp-peer aiml-cr-us-central1 \
       --peer-name bgp-on-premises-tunnel0 \
       --interface if-tunnel1-to-onprem \
       --peer-ip-address 169.254.1.2 \
       --peer-asn 65002 \
       --region us-central1
   

3. Erstellen Sie die zweite BGP-Schnittstelle:

   gcloud compute routers add-interface aiml-cr-us-central1 \
       --interface-name if-tunnel1-to-onprem \
       --ip-address 169.254.2.1 \
       --mask-length 30 \
       --vpn-tunnel aiml-vpc-tunnel1 \
       --region us-central1
   

4. Erstellen Sie den zweiten BGP-Peer:

   gcloud compute routers add-bgp-peer aiml-cr-us-central1 \
       --peer-name bgp-on-premises-tunnel1 \
       --interface if-tunnel2-to-onprem \
       --peer-ip-address 169.254.2.2 \
       --peer-asn 65002 \
       --region us-central1
   

BGP-Sitzungen für on-prem-vpc erstellen

1. Erstellen Sie die erste BGP-Schnittstelle:

   gcloud compute routers add-interface on-prem-cr-us-central1 \
       --interface-name if-tunnel0-to-aiml-vpc \
       --ip-address 169.254.1.2 \
       --mask-length 30 \
       --vpn-tunnel on-prem-tunnel0 \
       --region us-central1
   

2. Erstellen Sie den ersten BGP-Peer:

   gcloud compute routers add-bgp-peer on-prem-cr-us-central1 \
       --peer-name bgp-aiml-vpc-tunnel0 \
       --interface if-tunnel1-to-aiml-vpc \
       --peer-ip-address 169.254.1.1 \
       --peer-asn 65001 \
       --region us-central1
   

3. Erstellen Sie die zweite BGP-Schnittstelle:

   gcloud compute routers add-interface on-prem-cr-us-central1 \
       --interface-name if-tunnel1-to-aiml-vpc \
       --ip-address 169.254.2.2 \
       --mask-length 30 \
       --vpn-tunnel on-prem-tunnel1 \
       --region us-central1
   

4. Erstellen Sie den zweiten BGP-Peer:

   gcloud compute routers add-bgp-peer on-prem-cr-us-central1 \
       --peer-name bgp-aiml-vpc-tunnel1 \
       --interface if-tunnel2-to-aiml-vpc \
       --peer-ip-address 169.254.2.1 \
       --peer-asn 65001 \
       --region us-central1
   

Hinweis: Im folgenden Abschnitt wird davon ausgegangen, dass der Cloud Router standardmäßig Subnetzrouten zwischen den VPCs über HA VPN bewirbt. Später in dieser Anleitung ändern Sie die beworbenen Routen, um nur die IP-Adresse des PSC-Endpunkts aus dem aiml-vpc-Netzwerk und die private-ip-subnet aus dem on-prem-vpc-Netzwerk anzubieten.

BGP-Sitzungserstellung prüfen

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

   Zu VPN

2. Klicken Sie auf der Seite VPN auf den Tab VPN.

3. In der Liste der VPN-Tunnel sollten Sie nun sehen, dass sich der Wert in der Spalte BGP-Sitzungsstatus für jeden der vier Tunnel aus BGP-Sitzung konfigurieren in BGP eingerichtet geändert hat. Möglicherweise müssen Sie den Browsertab der Google Cloud Console aktualisieren, um die neuen Werte zu sehen.

Prüfen Sie, ob aiml-vpc Subnetzrouten über HA VPN erlernt hat.

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

   Zur Seite VPC-Netzwerke

2. Klicken Sie in der Liste der VPC-Netzwerke auf aiml-vpc.

3. Klicken Sie auf den Tab Routen.

4. Wählen Sie in der Liste Region die Option us-central1 (Iowa) aus und klicken Sie auf Ansehen.

5. Prüfen Sie in der Spalte Ziel-IP-Adressbereich, ob das VPC-Netzwerk aiml-vpc Routen aus dem nat-subnet-Subnetz (192.168.10.0/28) und dem private-ip-subnet-Subnetz (192.168.20.0/28) des VPC-Netzwerks on-prem-vpc erkannt hat.

Prüfen Sie, ob on-prem-vpc Subnetzrouten über HA VPN erlernt hat.

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

   Zur Seite VPC-Netzwerke

2. Klicken Sie in der Liste der VPC-Netzwerke auf on-prem-vpc.

3. Klicken Sie auf den Tab Routen.

4. Wählen Sie in der Liste Region die Option us-central1 (Iowa) aus und klicken Sie auf Ansehen.

5. Prüfen Sie in der Spalte Ziel-IP-Adressbereich, ob das VPC-Netzwerk on-prem-vpc Routen aus dem Subnetz workbench-subnet (172.16.10.0/28) der aiml-vpc-VPC erkannt hat.

Benutzerdefinierte beworbene Route für aiml-vpc erstellen

Die IP-Adresse des Private Service Connect-Endpunkts wird vom Cloud Router aiml-cr-us-central1 nicht automatisch beworben, da das Subnetz nicht im VPC-Netzwerk konfiguriert ist.

Daher müssen Sie eine benutzerdefinierte beworbene Route vom Cloud Router aiml-cr-us-central für die IP-Adresse 100.100.10.10 des Endpunkts erstellen, die in der lokalen Umgebung über BGP an on-prem-vpc beworben wird.

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

   Zu "Cloud Router"

2. Klicken Sie in der Liste der Cloud Router auf aiml-cr-us-central1.

3. Klicken Sie auf der Seite Routerdetails auf Bearbeiten.

4. Wählen Sie im Abschnitt Beworbene Routen für Routen die Option Benutzerdefinierte Routen erstellen.

5. Klicken Sie auf Benutzerdefinierte Route hinzufügen.

6. Wählen Sie für Quelle die Option Benutzerdefinierter IP-Bereich aus.

7. Geben Sie 100.100.10.10 als IP-Adressbereich ein.

8. Geben Sie unter Beschreibung Private Service Connect Endpoint IP ein.

9. Klicken Sie auf Fertig und anschließend auf Speichern.

Prüfen Sie, ob on-prem-vpc die IP-Adresse des PSC-Endpunkts über HA VPN erlernt hat.

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

   Zur Seite VPC-Netzwerke

2. Klicken Sie in der Liste der VPC-Netzwerke auf on-prem-vpc.

3. Klicken Sie auf den Tab Routen.

4. Wählen Sie in der Liste Region die Option us-central1 (Iowa) aus und klicken Sie auf Ansehen.

5. Prüfen Sie in der Spalte Ziel-IP-Adressbereich, ob das VPC-Netzwerk on-prem-vpc die IP-Adresse des PSC-Endpunkts (100.100.10.10) ermittelt hat.

Benutzerdefinierte beworbene Route für on-prem-vpc erstellen

Der on-prem-vpc-Cloud Router bewirbt standardmäßig alle Subnetze, aber nur das private-ip-subnet-Subnetz ist erforderlich.

Aktualisieren Sie im folgenden Abschnitt das Route Advertisement vom Cloud Router on-prem-cr-us-central1.

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

   Zu "Cloud Router"

2. Klicken Sie in der Liste der Cloud Router auf on-prem-cr-us-central1.

3. Klicken Sie auf der Seite Routerdetails auf Bearbeiten.

4. Wählen Sie im Abschnitt Beworbene Routen für Routen die Option Benutzerdefinierte Routen erstellen.

5. Wenn das Kästchen Alle für den Cloud Router sichtbaren Subnetze bewerben ausgewählt ist, heben Sie die Auswahl auf.

6. Klicken Sie auf Benutzerdefinierte Route hinzufügen.

7. Wählen Sie für Quelle die Option Benutzerdefinierter IP-Bereich aus.

8. Geben Sie 192.168.20.0/28 als IP-Adressbereich ein.

9. Geben Sie unter Beschreibung Private Service Connect Endpoint IP subnet (private-ip-subnet) ein.

10. Klicken Sie auf Fertig und anschließend auf Speichern.

Prüfen, ob aiml-vpc die Route private-ip-subnet vom on-prem-vpc erlernt hat

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

   Zur Seite VPC-Netzwerke

2. Klicken Sie in der Liste der VPC-Netzwerke auf aiml-vpc.

3. Klicken Sie auf den Tab Routen.

4. Wählen Sie in der Liste Region die Option us-central1 (Iowa) aus und klicken Sie auf Ansehen.

5. Prüfen Sie in der Spalte Ziel-IP-Adressbereich, ob das VPC-Netzwerk aiml-vpc die Route private-ip-subnet (192.168.20.0/28) erkannt hat.

VM-Testinstanzen erstellen

Ein vom Nutzer verwaltetes Dienstkonto erstellen

Wenn Sie über Anwendungen verfügen, die Aufrufe an Google Cloud APIs senden müssen, empfiehlt Google, dass Sie ein nutzerverwaltetes Dienstkonto an die VM anhängen, auf der die Anwendung oder die Arbeitslast ausgeführt wird. Dementsprechend erstellen Sie in diesem Abschnitt ein nutzerverwaltetes Dienstkonto, das auf die VM-Instanzen angewendet wird, die Sie später in dieser Anleitung erstellen.

1. Erstellen Sie in der Cloud Shell das Dienstkonto:

   gcloud iam service-accounts create gce-vertex-sa \
       --description="service account for vertex" \
       --display-name="gce-vertex-sa"
   

2. Weisen Sie dem Dienstkonto die IAM-Rolle Compute Instance Admin (v1) (roles/compute.instanceAdmin.v1) zu:

   gcloud projects add-iam-policy-binding $projectid \
       --member="serviceAccount:gce-vertex-sa@$projectid.iam.gserviceaccount.com" \
       --role="roles/compute.instanceAdmin.v1"
   

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

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

VM-Testinstanzen erstellen

In diesem Schritt erstellen Sie Test-VM-Instanzen, um verschiedene Methoden zum Aufrufen von Vertex AI APIs zu validieren, insbesondere:

• Die nat-client-Instanz verwendet Cloud NAT, um Vertex AI aufzulösen und über das öffentliche Internet auf den Endpunkt der Onlinevorhersage zuzugreifen.
• Die Instanz private-client verwendet die Private Service Connect-IP-Adresse 100.100.10.10, um über HA VPN auf den Onlinevorhersage-Endpunkt zuzugreifen.

Damit Identity-Aware Proxy (IAP) eine Verbindung zu Ihren VM-Instanzen herstellen kann, erstellen Sie eine Firewallregel, die:

• für alle VM-Instanzen gilt, die über IAP zugänglich sein sollen.
• TCP-Traffic über Port 22 aus dem IP-Bereich 35.235.240.0/20 zulässt. Dieser Bereich enthält alle IP-Adressen, die IAP für die TCP-Weiterleitung verwendet.

1. Erstellen Sie die VM-Instanz nat-client:

   gcloud compute instances create nat-client \
       --zone=us-central1-a \
       --image-family=debian-11 \
       --image-project=debian-cloud \
       --subnet=nat-subnet \
       --service-account=gce-vertex-sa@$projectid.iam.gserviceaccount.com \
       --scopes=https://www.googleapis.com/auth/cloud-platform \
       --no-address \
       --metadata startup-script="#! /bin/bash
           sudo apt-get update
           sudo apt-get install tcpdump dnsutils -y"
   

2. Erstellen Sie die VM-Instanz private-client:

   gcloud compute instances create private-client \
       --zone=us-central1-a \
       --image-family=debian-11 \
       --image-project=debian-cloud \
       --subnet=private-ip-subnet \
       --service-account=gce-vertex-sa@$projectid.iam.gserviceaccount.com \
       --scopes=https://www.googleapis.com/auth/cloud-platform \
       --no-address \
       --metadata startup-script="#! /bin/bash
           sudo apt-get update
           sudo apt-get install tcpdump dnsutils -y"
   

3. Erstellen Sie die IAP-Firewallregel:

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

Vertex AI Workbench-Instanz erstellen

Nutzerverwaltetes Dienstkonto für Vertex AI Workbench erstellen

Wenn Sie eine Vertex AI Workbench-Instanz erstellen, empfiehlt Google dringend, ein nutzerverwaltetes Dienstkonto anzugeben, anstatt das Compute Engine-Standarddienstkonto zu verwenden. Wenn Ihre Organisation die Einschränkung der Organisationsrichtlinie iam.automaticIamGrantsForDefaultServiceAccounts nicht erzwingt, wird dem Compute Engine-Standarddienstkonto (und damit jedem, den Sie als Instanznutzer angeben) die Rolle „Bearbeiter“ (roles/editor) für Ihr Google Cloud-Projekt zugewiesen. Wie Sie dieses Verhalten deaktivieren, erfahren Sie unter Standarddienstberechtigungen für Standarddienstkonten deaktivieren.

1. Erstellen Sie in der Cloud Shell ein Dienstkonto mit dem Namen workbench-sa:

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

2. Weisen Sie dem Dienstkonto die IAM-Rolle Storage Admin (roles/storage.admin) zu:

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

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

4. Weisen Sie dem Dienstkonto die IAM-Rolle Artifact Registry Administrator zu:

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

Vertex AI Workbench-Instanz erstellen

1. Erstellen Sie in Cloud Shell eine Vertex AI Workbench-Instanz und geben Sie das Dienstkonto workbench-sa an:

   gcloud workbench instances create workbench-tutorial \
     --vm-image-project=deeplearning-platform-release \
     --vm-image-family=common-cpu-notebooks \
     --machine-type=n1-standard-4 \
     --location=us-central1-a \
     --subnet-region=us-central1 \
     --shielded-secure-boot=True \
     --subnet=workbench-subnet \
     --disable-public-ip \
     --service-account-email=workbench-sa@$projectid.iam.gserviceaccount.com
   

Online-Vorhersagemodell erstellen und bereitstellen

Umgebung vorbereiten

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

   Zu Vertex AI Workbench

2. Klicken Sie neben dem Namen der Vertex AI Workbench-Instanz (workbench-tutorial) auf JupyterLab öffnen.

   Ihre Vertex AI Workbench-Instanz öffnet JupyterLab.

   Im weiteren Verlauf dieses Abschnitts arbeiten Sie bis einschließlich der Modellbereitstellung in Jupyterlab, nicht in der Google Cloud Console oder Cloud Shell.

3. Wählen Sie Datei > Neu > Terminal aus.

4. Definieren Sie im JupyterLab-Terminal (nicht in Cloud Shell) eine Umgebungsvariable für Ihr Projekt. Ersetzen Sie PROJECT_ID durch Ihre Projekt-ID:

   PROJECT_ID=PROJECT_ID
   

5. Erstellen Sie darin ein neues Verzeichnis mit dem Namen cpr-codelab und cd befindet sich noch in diesem Verzeichnis, das sich noch im JupyterLab-Terminal befindet:

   mkdir cpr-codelab
   cd cpr-codelab
   

6. Doppelklicken Sie im  Dateibrowser auf den neuen Ordner cpr-codelab.

   Wenn dieser Ordner nicht im Dateibrowser angezeigt wird, aktualisieren Sie den Browsertab der Google Cloud Console und versuchen Sie es noch einmal.

7. Wählen Sie File > New > Notebook aus.

8. Wählen Sie im Menü Kernel auswählen die Option Python [conda env:base] * (lokal) aus und klicken Sie auf Auswählen.

9. Benennen Sie die neue Notebookdatei so um:

   Klicken Sie im Dateibrowser mit der rechten Maustaste auf das Dateisymbol Untitled.ipynb und geben Sie task.ipynb ein.

   Die cpr-codelab-Verzeichnisstruktur sollte nun so aussehen:

   + cpr-codelab/
      + task.ipynb
   

   In den folgenden Schritten erstellen Sie Ihr Modell im Jupyterlab-Notebook. Dazu erstellen Sie neue Notebook-Zellen, fügen in diese Code ein und führen die Zellen aus.

10. Installieren Sie die Abhängigkeiten so:

    1. Wenn Sie Ihr neues Notebook öffnen, wird eine Standard-Codezelle angezeigt, in die Sie Code eingeben können. Sie sieht so aus: [ ]:, gefolgt von einem Textfeld. In das Textfeld fügen Sie den Code ein.

       Fügen Sie den folgenden Code in die Zelle ein und klicken Sie auf  Ausgewählte Zellen ausführen und fortfahren, um eine requirements.txt-Datei zu erstellen, die als Eingabe für den folgenden Schritt verwendet wird:

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

    2. Fügen Sie in diesem und jedem der folgenden Schritte eine Codezelle hinzu, indem Sie auf  Zelle unten einfügen klicken, den Code in die Zelle einfügen und dann auf  Ausgewählte Zellen ausführen und fortfahren klicken.

       Verwenden Sie Pip, um Abhängigkeiten in der Notebooks-Instanz zu installieren:

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

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

    4. Fügen Sie den folgenden Code in eine neue Notebookzelle ein, um die Verzeichnisse zum Speichern des Modells und der Preprocessing-Artefakte zu erstellen:

       USER_SRC_DIR = "src_dir"
       !mkdir $USER_SRC_DIR
       !mkdir model_artifacts
       # copy the requirements to the source dir
       !cp requirements.txt $USER_SRC_DIR/requirements.txt
       

    Im  Dateibrowser sollte Ihre Verzeichnisstruktur cpr-codelab jetzt so aussehen:

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

Modell trainieren

Fügen Sie dem task.ipynb-Notebook weitere Codezellen hinzu, fügen Sie den folgenden Code in jede neue Zelle ein und führen Sie ihn aus:

1. Bibliotheken importieren:

   import seaborn as sns
   import numpy as np
   import pandas as pd
   
   from sklearn import preprocessing
   from sklearn.ensemble import RandomForestRegressor
   from sklearn.pipeline import make_pipeline
   from sklearn.compose import make_column_transformer
   
   import joblib
   import logging
   
   # set logging to see the docker container logs
   logging.basicConfig(level=logging.INFO)
   

2. Definieren Sie die folgenden Variablen und ersetzen Sie dabei PROJECT_ID durch Ihre Projekt-ID:

   REGION = "us-central1"
   MODEL_ARTIFACT_DIR = "sklearn-model-artifacts"
   REPOSITORY = "diamonds"
   IMAGE = "sklearn-image"
   MODEL_DISPLAY_NAME = "diamonds-cpr"
   PROJECT_ID = "PROJECT_ID"
   BUCKET_NAME = "gs://PROJECT_ID-cpr-bucket"
   

3. Erstellen Sie einen Cloud Storage-Bucket:

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

4. Laden Sie die Daten aus der seaborn-Bibliothek und erstellen Sie dann zwei Datenframes, einen mit den Features und einen mit dem Label:

   data = sns.load_dataset('diamonds', cache=True, data_home=None)
   
   label = 'price'
   
   y_train = data['price']
   x_train = data.drop(columns=['price'])
   

5. Sehen Sie sich die Trainingsdaten an und achten Sie darauf, dass jede Zeile eine Raute darstellt.

   x_train.head()
   

6. Sehen Sie sich die Labels an, also die entsprechenden Preise.

   y_train.head()
   

7. Definieren Sie eine sklearn-Spaltentransformation zu einer Hot-Codierung der kategorialen Features und skalieren Sie die numerischen Features:

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

8. Definieren Sie das Random Forest-Modell:

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

9. Erstellen Sie eine sklearn-Pipeline. Diese Pipeline übernimmt Eingabedaten, codiert und skaliert sie und übergibt sie an das Modell.

   my_pipeline = make_pipeline(column_transform, regr)
   

10. Modell trainieren

    my_pipeline.fit(x_train, y_train)
    

11. Rufen Sie die Vorhersagemethode für das Modell auf und übergeben Sie dabei ein Testbeispiel.

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

    Möglicherweise werden Warnungen wie "X does not have valid feature names, but" angezeigt, die Sie ignorieren können.

12. Speichern Sie die Pipeline im Verzeichnis model_artifacts und kopieren Sie sie in Ihren Cloud Storage-Bucket:

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

Vorverarbeitungsartefakt speichern

1. Erstellen Sie ein Vorverarbeitungsartefakt. Dieses Artefakt wird beim Start des Modellservers in den benutzerdefinierten Container geladen. Ihr Vorverarbeitungsartefakt kann fast jedes Format haben (z. B. eine Pickle-Datei). In diesem Fall schreiben Sie jedoch ein Wörterbuch in eine JSON-Datei:

   clarity_dict={"Flawless": "FL",
      "Internally Flawless": "IF",
      "Very Very Slightly Included": "VVS1",
      "Very Slightly Included": "VS2",
      "Slightly Included": "S12",
      "Included": "I3"}
   

Benutzerdefinierten Bereitstellungscontainer mit dem CPR-Modellserver erstellen

1. Das Feature clarity lag in unseren Trainingsdaten immer in der abgekürzten Form vor (d. h. „FL“ anstelle von „Flawless“). Beim Ausliefern möchten wir prüfen, ob die Daten für diese Funktion auch abgekürzt sind. Das liegt daran, dass unser Modell weiß, wie man einen „FL“, aber nicht „Flawless“ codieren muss. Diese benutzerdefinierte Vorverarbeitungslogik wird später geschrieben. Speichern Sie diese Suchtabelle vorerst in einer JSON-Datei und schreiben Sie sie dann in Ihren Cloud Storage-Bucket:

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

   Im  Dateibrowser sollte Ihre Verzeichnisstruktur jetzt so aussehen:

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

2. Fügen Sie den folgenden Code in Ihr Notebook ein und führen Sie ihn aus, um eine abgeleitete Klasse von SklearnPredictor zu erstellen und in eine Python-Datei in src_dir/ zu schreiben. Beachten Sie, dass wir in diesem Beispiel nur die Lade-, Vorverarbeitungs- und Nachbearbeitungsmethoden anpassen, nicht die Vorhersagemethode.

   %%writefile $USER_SRC_DIR/predictor.py
   
   import joblib
   import numpy as np
   import json
   
   from google.cloud import storage
   from google.cloud.aiplatform.prediction.sklearn.predictor import SklearnPredictor
   
   class CprPredictor(SklearnPredictor):
   
    def __init__(self):
        return
   
    def load(self, artifacts_uri: str) -> None:
        """Loads the sklearn pipeline and preprocessing artifact."""
   
        super().load(artifacts_uri)
   
        # open preprocessing artifact
        with open("preprocessor.json", "rb") as f:
            self._preprocessor = json.load(f)
   
    def preprocess(self, prediction_input: np.ndarray) -> np.ndarray:
        """Performs preprocessing by checking if clarity feature is in abbreviated form."""
   
        inputs = super().preprocess(prediction_input)
   
        for sample in inputs:
            if sample[3] not in self._preprocessor.values():
                sample[3] = self._preprocessor[sample[3]]
        return inputs
   
    def postprocess(self, prediction_results: np.ndarray) -> dict:
        """Performs postprocessing by rounding predictions and converting to str."""
   
        return {"predictions": [f"${value}" for value in np.round(prediction_results)]}
   

3. Verwenden Sie das Vertex AI SDK für Python, um das Image mit benutzerdefinierten Vorhersageroutinen zu erstellen. Das Dockerfile wird generiert und ein Image wird für Sie erstellt.

   from google.cloud import aiplatform
   
   aiplatform.init(project=PROJECT_ID, location=REGION)
   
   import os
   
   from google.cloud.aiplatform.prediction import LocalModel
   
   from src_dir.predictor import CprPredictor  # Should be path of variable $USER_SRC_DIR
   
   local_model = LocalModel.build_cpr_model(
      USER_SRC_DIR,
      f"{REGION}-docker.pkg.dev/{PROJECT_ID}/{REPOSITORY}/{IMAGE}",
      predictor=CprPredictor,
      requirements_path=os.path.join(USER_SRC_DIR, "requirements.txt"),
   )
   

4. Schreiben Sie eine Testdatei mit zwei Beispielen für die Vorhersage. Eine der Instanzen hat den abgekürzten Klarnamen, aber die andere muss zuerst konvertiert werden.

   import json
   
   sample = {"instances": [
      [0.23, 'Ideal', 'E', 'VS2', 61.5, 55.0, 3.95, 3.98, 2.43],
      [0.29, 'Premium', 'J', 'Internally Flawless', 52.5, 49.0, 4.00, 2.13, 3.11]]}
   
   with open('instances.json', 'w') as fp:
      json.dump(sample, fp)
   

5. Testen Sie den Container lokal, indem Sie ein lokales Modell bereitstellen.

   with local_model.deploy_to_local_endpoint(
      artifact_uri = 'model_artifacts/', # local path to artifacts
   ) as local_endpoint:
      predict_response = local_endpoint.predict(
         request_file='instances.json',
         headers={"Content-Type": "application/json"},
      )
   
      health_check_response = local_endpoint.run_health_check()
   

6. Sie können die Vorhersageergebnisse mit folgenden Tools aufrufen:

   predict_response.content
   

   Die Ausgabe sieht so aus:

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

Modell für den Endpunkt der Onlinevorhersage bereitstellen

Nachdem Sie den Container lokal getestet haben, ist es an der Zeit, das Image in Artifact Registry zu pushen und das Modell in Vertex AI Model Registry hochzuladen.

1. Konfigurieren Sie Docker für den Zugriff auf Artifact Registry.

   !gcloud artifacts repositories create {REPOSITORY} \
       --repository-format=docker \
       --location=us-central1 \
       --description="Docker repository"
   
   !gcloud auth configure-docker {REGION}-docker.pkg.dev --quiet
   

2. Übertragen Sie das Image per Push.

   local_model.push_image()
   

3. Laden Sie das Modell hoch.

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

4. Modell bereitstellen:

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

   Warten Sie, bis das Modell bereitgestellt wurde, bevor Sie mit dem nächsten Schritt fortfahren. Die Bereitstellung dauert etwa 10 bis 15 Minuten.

5. Testen Sie das bereitgestellte Modell durch Abrufen einer Vorhersage:

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

   Die Ausgabe sieht so aus:

   Prediction(predictions=['$479.0'], deployed_model_id='3171115779319922688', metadata=None, model_version_id='1', model_resource_name='projects/721032480027/locations/us-central1/models/8554949231515795456', explanations=None)
   

Öffentlichen Internetzugriff auf Vertex AI APIs prüfen

In diesem Abschnitt melden Sie sich in einem Cloud Shell-Sitzungstab bei der VM-Instanz nat-client an und verwenden einen anderen Sitzungstab, um die Konnektivität zu Vertex AI APIs zu prüfen, indem Sie die Befehle dig und tcpdump für die Domain us-central1-aiplatform.googleapis.com ausführen.

Tipp: Wenn Sie die vier Cloud Shell-Sitzungstabs verfolgen möchten, die im Rest dieser Anleitung verwendet werden, können Sie Cloud Shell-Terminaleinstellungen vornehmen, um die Titel des Tabs anzupassen.

1. Führen Sie in Cloud Shell (Tab 1) die folgenden Befehle aus und ersetzen Sie dabei PROJECT_ID durch Ihre Projekt-ID:

   projectid=PROJECT_ID
   gcloud config set project ${projectid}
   

2. Melden Sie sich mit IAP bei der VM-Instanz nat-client an:

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

3. Führen Sie den Befehl dig aus:

   dig us-central1-aiplatform.googleapis.com
   

4. Führen Sie auf der VM nat-client (Tab 1) den folgenden Befehl aus, um die DNS-Auflösung zu validieren, wenn Sie eine Onlinevorhersageanfrage an den Endpunkt senden.

   sudo tcpdump -i any port 53 -n
   

5. Öffnen Sie eine neue Cloud Shell-Sitzung (Tab 2), indem Sie in Cloud Shell auf Neuen Tab öffnen klicken.

6. Führen Sie in der neuen Cloud Shell-Sitzung (Tab 2) die folgenden Befehle aus und ersetzen Sie dabei PROJECT_ID durch Ihre Projekt-ID:

   projectid=PROJECT_ID
   gcloud config set project ${projectid}
   

7. Melden Sie sich bei der VM-Instanz nat-client an:

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

8. Verwenden Sie auf der nat-client-VM (Tab Zwei) einen Texteditor wie vim oder nano, um eine instances.json-Datei zu erstellen. Sie müssen sudo voranstellen, um die Berechtigung zum Schreiben in die Datei zu erhalten. Beispiel:

   sudo vim instances.json
   

9. Fügen Sie der Datei den folgenden Datenstring hinzu:

   {"instances": [
      [0.23, 'Ideal', 'E', 'VS2', 61.5, 55.0, 3.95, 3.98, 2.43],
      [0.29, 'Premium', 'J', 'Internally Flawless', 52.5, 49.0, 4.00, 2.13, 3.11]]}
   

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

11. Suchen Sie die Endpunkt-ID der Onlinevorhersage für den PSC-Endpunkt:

    1. Rufen Sie in der Google Cloud Console im Abschnitt „Vertex AI“ den Tab Endpunkte auf der Seite Onlinevorhersage auf.

       Endpunkte aufrufen

    2. Suchen Sie die Zeile des erstellten Endpunkts mit dem Namen diamonds-cpr_endpoint.

    3. Suchen Sie in der Spalte ID nach der 19-stelligen Endpunkt-ID und kopieren Sie sie.

12. Führen Sie in Cloud Shell auf der VM nat-client (Tab 2) die folgenden Befehle aus und ersetzen Sie dabei PROJECT_ID durch Ihre Projekt-ID und ENDPOINT_ID durch die PSC-Endpunkt-ID:

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

13. Führen Sie auf der VM nat-client (Tab 2) den folgenden Befehl aus, um eine Onlinevorhersageanfrage zu senden:

    curl -X POST -H "Authorization: Bearer $(gcloud auth print-access-token)" -H "Content-Type: application/json" https://us-central1-aiplatform.googleapis.com/v1/projects/${projectid}/locations/us-central1/endpoints/${ENDPOINT_ID}:predict -d @instances.json
    

Nachdem Sie die Vorhersage ausgeführt haben, sehen Sie, dass die tcpdump-Ergebnisse (Tab 1) zeigen, dass die VM-Instanz nat-client (192.168.10.2) eine Cloud DNS-Abfrage an den lokalen DNS-Server (169.254.169.254) für die Vertex AI API-Domain (us-central1-aiplatform.googleapis.com) durchführt. Die DNS-Abfrage gibt öffentliche virtuelle IP-Adressen (VIPs) für Vertex AI APIs zurück.

Privaten Zugriff auf Vertex AI APIs prüfen

In diesem Abschnitt melden Sie sich mit Identity-Aware Proxy in einer neuen Cloud Shell-Sitzung (Tab 3) auf der VM-Instanz private-client an. Anschließend prüfen Sie die Konnektivität zu Vertex AI APIs, indem Sie den Befehl dig für die Vertex AI-Domain (us-central1-aiplatform.googleapis.com) ausführen.

1. Öffnen Sie eine neue Cloud Shell-Sitzung (Tab 3), indem Sie in Cloud Shell auf Neuen Tab öffnen klicken. Das ist Tab Drei.

2. Führen Sie in der neuen Cloud Shell-Sitzung (Tab 3) die folgenden Befehle aus und ersetzen Sie dabei PROJECT_ID durch Ihre Projekt-ID:

   projectid=PROJECT_ID
   gcloud config set project ${projectid}
   

3. Melden Sie sich mit IAP bei der VM-Instanz private-client an:

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

4. Führen Sie den Befehl dig aus:

   dig us-central1-aiplatform.googleapis.com
   

5. Verwenden Sie auf der VM-Instanz private-client (Tab 3) einen Texteditor wie vim oder nano, um die folgende Zeile zur Datei /etc/hosts hinzuzufügen:

   100.100.10.10 us-central1-aiplatform.googleapis.com
   

   Diese Zeile weist die IP-Adresse des PSC-Endpunkts (100.100.10.10) dem voll qualifizierten Domainnamen für die Vertex AI Google API (us-central1-aiplatform.googleapis.com) zu. Die bearbeitete Datei sollte so aussehen:

   127.0.0.1       localhost
   ::1             localhost ip6-localhost ip6-loopback
   ff02::1         ip6-allnodes
   ff02::2         ip6-allrouters
   
   100.100.10.10 us-central1-aiplatform.googleapis.com # Added by you
   192.168.20.2 private-client.c.$projectid.internal private-client  # Added by Google
   169.254.169.254 metadata.google.internal  # Added by Google
   

6. Pingen Sie auf der VM private-client (Tab 3) den Vertex AI-Endpunkt und Control+C an, um den Vorgang zu beenden, wenn die Ausgabe angezeigt wird:

   ping us-central1-aiplatform.googleapis.com
   

   Der Befehl ping gibt die folgende Ausgabe mit der IP-Adresse des PSC-Endpunkts zurück:

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

7. Verwenden Sie auf der VM private-client (Tab 3) tcpdump, um den folgenden Befehl auszuführen, um die DNS-Auflösung und den IP-Datenpfad zu validieren, wenn Sie eine Onlinevorhersageanfrage an den Endpunkt senden:

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

8. Öffnen Sie eine neue Cloud Shell-Sitzung (Tab 4), indem Sie in Cloud Shell auf Neuen Tab öffnen klicken.

9. Führen Sie in der neuen Cloud Shell-Sitzung (Tab 4) die folgenden Befehle aus und ersetzen Sie dabei PROJECT_ID durch Ihre Projekt-ID:

   projectid=PROJECT_ID
   gcloud config set project ${projectid}
   

10. Melden Sie sich in Tab 4 bei der Instanz private-client an:

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

11. Erstellen Sie auf der VM private-client (Tab 4) mit einem Texteditor wie vim oder nano eine instances.json-Datei mit dem folgenden Datenstring:

    {"instances": [
       [0.23, 'Ideal', 'E', 'VS2', 61.5, 55.0, 3.95, 3.98, 2.43],
       [0.29, 'Premium', 'J', 'Internally Flawless', 52.5, 49.0, 4.00, 2.13, 3.11]]}
    

12. Führen Sie auf der VM private-client (Tab 4) die folgenden Befehle aus und ersetzen Sie PROJECT_ID durch Ihren Projektnamen und ENDPOINT_ID durch die PSC-Endpunkt-ID:

    projectid=PROJECT_ID
    echo $projectid
    ENDPOINT_ID=ENDPOINT_ID
    

13. Führen Sie auf der VM private-client (Tab 4) den folgenden Befehl aus, um eine Anfrage für eine Onlinevorhersage zu senden:

    curl -v -X POST -H "Authorization: Bearer $(gcloud auth print-access-token)" -H "Content-Type: application/json" https://us-central1-aiplatform.googleapis.com/v1/projects/${projectid}/locations/us-central1/endpoints/${ENDPOINT_ID}:predict -d @instances.json
    

14. Prüfen Sie auf der VM private-client in Cloud Shell (Tab 3), ob die IP-Adresse des PSC-Endpunkts (100.100.10.10) für den Zugriff auf Vertex AI APIs verwendet wurde.

    Im Terminal private-client tcpdump des Cloud Shell-Tabs 3 können Sie sehen, dass kein DNS-Lookup nach us-central1-aiplatform.googleapis.com erforderlich ist, da die Zeile, die Sie zur Datei /etc/hosts hinzugefügt haben, Vorrang hat und die PSC-IP-Adresse 100.100.10.10 im Datenpfad verwendet wird.

Bereinigen

Damit Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, löschen Sie entweder das Projekt, das die Ressourcen enthält, oder behalten Sie das Projekt und löschen Sie die einzelnen Ressourcen.

Sie können die einzelnen Ressourcen im Projekt so löschen:

1. Löschen Sie die Vertex AI Workbench-Instanz so:

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

      Zu Vertex AI Workbench

   2. Wählen Sie die Vertex AI Workbench-Instanz workbench-tutorial aus und klicken Sie auf Löschen.

2. Löschen Sie das Container-Image so:

   1. Rufen Sie in der Google Cloud Console die Seite Artifact Registry auf.

      Zu Artifact Registry

   2. Wählen Sie den Docker-Container diamonds aus und klicken Sie auf Löschen.

3. Löschen Sie den Storage-Bucket so:

   1. Wechseln Sie in der Google Cloud Console zum Cloud Storage-Browser.

      Cloud Storage aufrufen

   2. Wählen Sie Ihren Storage-Bucket aus und klicken Sie auf Löschen.

4. Heben Sie die Bereitstellung des Modells am Endpunkt so auf:

   1. Rufen Sie in der Google Cloud Console im Abschnitt Vertex AI die Seite Endpunkte auf.

      Endpunkte aufrufen

   2. Klicken Sie auf diamonds-cpr_endpoint, um die Seite „Endpunktdetails“ aufzurufen.

   3. Klicken Sie in der Zeile für das Modell auf diamonds-cprBereitstellung des Modells aufheben.

   4. Klicken Sie im Dialogfeld Bereitstellung des Endpunkts aufheben auf Bereitstellung aufheben.

5. Löschen Sie das Modell so:

   1. Rufen Sie in der Google Cloud Console im Abschnitt Vertex AI die Seite Model Registry auf.

      Zu Model Registry

   2. Wählen Sie das diamonds-cpr-Modell aus.

   3. Klicken Sie zum Löschen des Modells auf Aktionen und dann auf Modell löschen.

6. So löschen Sie den Endpunkt für Onlinevorhersagen:

   1. Rufen Sie in der Google Cloud Console im Abschnitt Vertex AI die Seite Onlinevorhersage auf.

      Zur Onlinevorhersage

   2. Wählen Sie den Endpunkt diamonds-cpr_endpoint aus.

   3. Klicken Sie zum Löschen des Endpunkts auf Aktionen und dann auf Endpunkt löschen.

7. Löschen Sie in der Cloud Shell die verbleibenden Ressourcen. Führen Sie dazu die folgenden Befehle aus.

   Zu Cloud Shell

   projectid=PROJECT_ID
   gcloud config set project ${projectid}
   

   gcloud compute forwarding-rules delete pscvertex \
       --global \
       --quiet
   

   gcloud compute addresses delete psc-ip \
       --global \
       --quiet
   

   gcloud compute networks subnets delete workbench-subnet \
       --region=us-central1 \
       --quiet
   

   gcloud compute vpn-tunnels delete aiml-vpc-tunnel0 aiml-vpc-tunnel1 on-prem-tunnel0 on-prem-tunnel1 \
       --region=us-central1 \
       --quiet
   

   gcloud compute vpn-gateways delete aiml-vpn-gw on-prem-vpn-gw \
       --region=us-central1 \
       --quiet
   

   gcloud compute routers nats delete cloud-nat-us-central1 \
       --router=cloud-router-us-central1-aiml-nat \
       --region=us-central1 \
       --quiet
   

   gcloud compute routers delete aiml-cr-us-central1 cloud-router-us-central1-aiml-nat \
       --region=us-central1 \
       --quiet
   

   gcloud compute routers delete cloud-router-us-central1-on-prem-nat on-prem-cr-us-central1 \
       --region=us-central1 \
       --quiet
   

   gcloud compute instances delete nat-client private-client \
       --zone=us-central1-a \
       --quiet
   

   gcloud compute firewall-rules delete ssh-iap-on-prem-vpc \
       --quiet
   

   gcloud compute networks subnets delete nat-subnet  private-ip-subnet \
       --region=us-central1 \
       --quiet
   

   gcloud compute networks delete on-prem-vpc \
       --quiet
   

   gcloud compute networks delete aiml-vpc \
       --quiet
   

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

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

Nächste Schritte

• Netzwerkoptionen für den Zugriff auf Vertex AI-Endpunkte und -Dienste
• Erhalten Sie weitere Informationen dazu, wie Private Service Connect funktioniert und warum es erhebliche Leistungsvorteile bietet.
• Weitere Informationen zur Verwendung von VPC Service Controls zur Erstellung sicherer Perimeter, um den Zugriff auf Vertex AI und andere Google APIs auf Ihrem Online-Vorhersageendpunkt zuzulassen oder zu verweigern.
• Weitere Informationen darüber, wie und warum Sie eine DNS-Weiterleitungszone verwenden können, anstatt die /etc/hosts-Datei in großem Maßstab und in Produktionsumgebungen zu aktualisieren.