Mit Private Service Connect von lokalen Umgebungen aus auf Vertex AI zugreifen

VPC-Netzwerke erstellen

In diesem Abschnitt erstellen Sie zwei VPC-Netzwerke: eines zum Erstellen eines Onlinevorhersagemodells und zum 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 einer Onlinevorhersage erstellen (aiml-vpc)

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
   

Private Service Connect-Endpunkt (PSC) erstellen

In diesem Abschnitt erstellen Sie den Endpunkt Service Private Connect (PSC), den die VM-Instanzen im Netzwerk on-prem-vpc für den Zugriff auf den Endpunkt der Onlinevorhersage über die Vertex AI API verwenden. Der PSC-Endpunkt (Private Service Connect) ist eine interne IP-Adresse im Netzwerk on-prem-vpc, 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 von aiml-vpc-cloud-router-vpn als benutzerdefiniertes Router-Advertising für das lokale Netzwerk in einem späteren Schritt beworben.

1. Reservieren Sie 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. Listen Sie die konfigurierten PSC-Endpunkte auf und prüfen Sie, 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 lautet:

   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 Cloud VPN-Gateways.

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

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

   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 Cloud VPN-Tunnel.

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 einrichten

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 einrichten

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
   

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 Cloud VPN-Tunnel.

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 us-central1 (Iowa) in der Liste Region 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 us-central1 (Iowa) in der Liste Region 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.

Benutzerdefiniertes Route Advertisement 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 ein benutzerdefiniertes Route Advertisement vom Cloud Router aiml-cr-us-central für die IP-Adresse 100.100.10.10 des Endpunkts erstellen, das in der lokalen Umgebung über BGP an on-prem-vpc beworben werden soll.

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

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 unter Quelle die Option Benutzerdefinierter IP-Bereich aus.

7. Geben Sie 100.100.10.10 als IP-Adressbereich ein.

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

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

Prüfen, ob on-prem-vpc die PSC-Endpunkt-IP-Adresse über HA VPN erkannt 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 us-central1 (Iowa) in der Liste Region aus und klicken Sie auf Ansehen.

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

Benutzerdefiniertes Route Advertisement für on-prem-vpc erstellen

Der Cloud Router on-prem-vpc bewirbt standardmäßig alle Subnetze, aber nur das Subnetz private-ip-subnet wird benötigt.

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

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 unter Quelle die Option Benutzerdefinierter IP-Bereich aus.

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

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

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

Prüfen Sie, ob aiml-vpc die Route private-ip-subnet von on-prem-vpc gelernt 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 us-central1 (Iowa) in der Liste Region aus und klicken Sie auf Ansehen.

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

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. Entsprechend 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 VM-Testinstanzen, um verschiedene Methoden zu validieren, um Vertex AI APIs zu erreichen:

• Die Instanz nat-client verwendet Cloud NAT, um Vertex AI für den Zugriff auf den Endpunkt von Onlinevorhersagen über das öffentliche Internet aufzulösen.
• Die Instanz private-client verwendet die IP-Adresse 100.100.10.10 von Private Service Connect, 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=http://www.googleapis.com/auth/cloud-platform \
      --no-address \
      --metadata startup-script="#! /bin/bash
         sudo apt-get update
         sudo apt-get install tcpdump dnsutils -y"
   

2. 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=http://www.googleapis.com/auth/cloud-platform \
      --no-address \
      --metadata startup-script="#! /bin/bash
         sudo apt-get update
         sudo apt-get install tcpdump dnsutils -y"
   

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

Nutzerverwaltete Notebookinstanz erstellen

Ein vom Nutzer verwaltetes Dienstkonto erstellen

Wenn Sie eine nutzerverwaltete Notebookinstanz von Vertex AI Workbench erstellen, empfiehlt Google dringend, ein vom Nutzer verwaltetes Dienstkonto anstelle des Compute Engine-Standarddienstkontos anzugeben. Dem Compute Engine-Standarddienstkonto (und damit jedem, den Sie als Instanznutzer angeben) wird die Rolle „Editor“ (roles/editor) für Ihr Google Cloud-Projekt zugewiesen. Sie können dieses Verhalten deaktivieren, indem Sie automatische Rollenzuweisungen für Standarddienstkonten deaktivieren.

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

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

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

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

Nutzerverwaltete Notebookinstanz erstellen

Erstellen Sie eine nutzerverwaltete Notebookinstanz und geben Sie das Dienstkonto user-managed-notebook-sa an.

1. Erstellen Sie die nutzerverwaltete Notebookinstanz:

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

Onlinevorhersagemodell erstellen und bereitstellen

Umgebung vorbereiten

1. Wechseln Sie in der Google Cloud Console auf der Seite Vertex AI Workbench zum Tab Nutzerverwaltete Notebooks.

   Zu "Nutzerverwaltete Notebooks"

2. Klicken Sie neben dem Namen der nutzerverwalteten Notebookinstanz auf JupyterLab öffnen.

   Ihre nutzerverwaltete Notebookinstanz öffnet JupyterLab.

   Im weiteren Verlauf dieses Abschnitts bis zur einschließlich Modellbereitstellung arbeiten Sie 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 der Cloud Shell) eine Umgebungsvariable für Ihr Projekt. Ersetzen Sie PROJECT_ID durch Ihre Projekt-ID:

   PROJECT_ID=PROJECT_ID
   

5. Erstellen Sie ein neues Verzeichnis mit dem Namen cpr-codelab und cd darin (noch im JupyterLab-Terminal):

   mkdir cpr-codelab
   cd cpr-codelab
   

6. Doppelklicken Sie im folder 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 3 aus und klicken Sie auf Auswählen.

9. Benennen Sie die neue Notebook-Datei so um:

   Klicken Sie im Dateibrowser folder 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, indem Sie neue Notebook-Zellen erstellen, Code in diese einfügen und die Zellen ausführen.

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 dieses Textfeld fügen Sie Ihren Code ein.

       Fügen Sie den folgenden Code in die Zelle ein und klicken Sie auf play_arrow 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.0.0
       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 add Zelle unten einfügen klicken, den Code in die Zelle einfügen und dann auf play_arrow Ausgewählte Zellen ausführen und fortfahren klicken.

       Verwenden Sie Pip, um Abhängigkeiten in der Notebookinstanz 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 Vorverarbeitung von Artefakten 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 folder sollte Ihre cpr-codelab-Verzeichnisstruktur jetzt so aussehen:

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

Modell trainieren

Fügen Sie dem Notebook task.ipynb weitere Codezellen hinzu, fügen Sie den folgenden Code ein und führen Sie ihn in jeder neuen Zelle 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:

   !gsutil mb -l us-central1 $BUCKET_NAME
   

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. Dies sind 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(sparse=False), [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 leitet sie an das Modell weiter.

   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 jedoch 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')
    
    !gsutil 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. Das Vorverarbeitungsartefakt kann fast in beliebiger Form vorliegen, z. B. eine Pickle-Datei, aber in diesem Fall schreiben Sie 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“). Zum Zeitpunkt der Bereitstellung möchten wir prüfen, ob die Daten für dieses Feature abgekürzt sind. Das liegt daran, dass unser Modell weiß, wie man einen „FL“, aber nicht „Flawless“ codieren muss. Die benutzerdefinierte Vorverarbeitungslogik schreiben Sie später. Speichern Sie diese Suchtabelle aber zuerst 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)
   
   !gsutil cp model_artifacts/preprocessor.json {BUCKET_NAME}/{MODEL_ARTIFACT_DIR}/
   

   Im folder 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 in Ihrem Notebook den folgenden Code ein, um eine Unterklasse von SklearnPredictor zu erstellen und in eine Python-Datei in src_dir/ zu schreiben. Beachten Sie, dass in diesem Beispiel nur die Lade-, Vorverarbeitungs- und Nachbearbeitungsmethoden und nicht die Vorhersagemethode angepasst werden.

   %%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, die andere muss jedoch 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 folgendem Befehl anzeigen:

   predict_response.content
   

Modell auf dem Endpunkt des Onlinevorhersagemodells bereitstellen

Nachdem Sie den Container lokal getestet haben, können Sie das Image per Push in Artifact Registry übertragen und das Modell in Vertex AI Model Registry hochladen.

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 Ihr Modell bereitgestellt ist, bevor Sie mit dem nächsten Schritt fortfahren. Die Bereitstellung dauert mindestens 10 bis 15 Minuten.

5. Testen Sie das bereitgestellte Modell mithilfe einer Vorhersage:

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

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

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 add 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 2) 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. 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 für die 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 von Ihnen erstellten Endpunkts mit dem Namen diamonds-cpr_endpoint.

    3. Suchen Sie in der Spalte ID die 19-stellige 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" http://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 add Neuen Tab öffnen klicken. Das ist Tab 3.

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 sollte die folgende Ausgabe zurückgeben, die die IP-Adresse des PSC-Endpunkts enthält:

   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 add 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" http://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.