Expliziter Proxy für die PSC-Schnittstelle von Vertex AI Pipelines

1. Einführung

Eine Private Service Connect-Schnittstelle ist eine Ressource, mit der das VPC-Netzwerk (Virtual Private Cloud) eines Erstellers Verbindungen zu verschiedenen Zielen in einem Nutzer-VPC-Netzwerk initiieren kann. Ersteller- und Nutzernetzwerke können sich in verschiedenen Projekten und Organisationen befinden.

Wenn ein Netzwerkanhang eine Verbindung von einer Private Service Connect-Schnittstelle akzeptiert, weist Google Cloud der Schnittstelle eine IP-Adresse aus einem vom Netzwerkanhang bestimmten Nutzersubnetz zu. Die Nutzer- und Erstellernetzwerke sind verbunden und können über interne IP-Adressen kommunizieren.

Eine Verbindung zwischen einem Netzwerkanhang und einer Private Service Connect-Schnittstelle ähnelt der Verbindung zwischen einem Private Service Connect-Endpunkt und einem Dienstanhang, weist aber zwei wichtige Unterschiede auf:

  • Mit einem Netzwerkanhang kann ein Erstellernetzwerk Verbindungen zu einem Nutzernetzwerk initiieren (verwalteter ausgehender Dienst), während ein Endpunkt es einem Nutzernetzwerk ermöglicht, Verbindungen zu einem Erstellernetzwerk zu initiieren (verwalteter Dienst).
  • Private Service Connect-Schnittstellenverbindungen sind transitiv. Dies bedeutet, dass ein Erstellernetzwerk mit anderen Netzwerken kommunizieren kann, die mit dem Nutzernetzwerk verbunden sind.

Überlegungen zur Erreichbarkeit von Vertex AI-PSC-Schnittstellen

  • Die PSC-Schnittstelle kann Traffic an VPC- oder On-Premise-Ziele innerhalb des RFC1918-Adressblocks weiterleiten.
  • Für PSC-Schnittstellen, die auf Adressblöcke außerhalb von RFC 1918 ausgerichtet sind, ist ein expliziter Proxy erforderlich, der in der VPC des Nutzers mit einer RFC 1918-Adresse bereitgestellt wird. Innerhalb der Vertex AI-Bereitstellung muss der Proxy zusammen mit einem FQDN des Zielendpunkts definiert werden. Abbildung 1 zeigt den expliziten Proxy, der in den VPCs des Kunden konfiguriert ist, um das Routing zu den folgenden Nicht-RFC-1918-CIDRs zu ermöglichen:

[1] 240.0.0.0/4

[2] 203.0.113.0/2

[3]10.10.20.0/28 – kein Proxy erforderlich, da im RFC1918-Bereich.

  • Wenn Sie Ihre Bereitstellung nur mit einer PSC-Schnittstelle konfigurieren, behält sie ihren Standard-Internetzugriff bei. Dieser ausgehende Traffic wird direkt aus dem sicheren, von Google verwalteten Mandantennetzwerk weitergeleitet.

476f87a96f153b95.png

VPC-SC-Überlegungen zur Vertex AI-PSC-Schnittstelle

  • Wenn Ihr Projekt Teil eines VPC Service Controls-Perimeters ist, wird der standardmäßige Internetzugriff der von Google verwalteten Mandanten durch den Perimeter blockiert, um Daten-Exfiltration zu verhindern.
  • Damit die Bereitstellung in diesem Szenario auf das öffentliche Internet zugreifen kann, müssen Sie explizit einen sicheren Pfad für ausgehenden Traffic konfigurieren, der Traffic über Ihre VPC weiterleitet. Die empfohlene Methode hierfür ist, einen Proxyserver mit einer RFC1918-Adresse innerhalb Ihres VPC-Perimeters einzurichten und ein Cloud NAT-Gateway zu erstellen, damit die Proxy-VM auf das Internet zugreifen kann.

Weitere Informationen finden Sie in den folgenden Ressourcen:

Private Service Connect-Schnittstelle für Vertex AI-Ressourcen einrichten | Google Cloud

Aufgaben

In dieser Anleitung erstellen Sie eine umfassende Vertex AI Pipelines-Bereitstellung mit einer Private Service Connect-Schnittstelle (PSC), um die Verbindung vom Ersteller zur Compute-Instanz des Nutzers zu ermöglichen, wie in Abbildung 1 dargestellt. Dabei werden Endpunkte verwendet, die nicht RFC-1928 entsprechen.

Abbildung 2

782ba8f1f3c3f522.png

Sie erstellen eine einzelne psc-network-attachment in der VPC des Nutzers und nutzen DNS-Peering, um die VMs des Nutzers im Mandantenprojekt aufzulösen, in dem Vertex AI Training gehostet wird. Dies führt zu den folgenden Anwendungsfällen:

  1. Stellen Sie Vertex AI Pipelines bereit und konfigurieren Sie eine Proxy-VM als expliziten Proxy, damit sie einen wget-Befehl für eine VM im Subnetz der Klasse E ausführen kann.

Lerninhalte

  • Netzwerkanhang erstellen
  • So kann ein Produzent einen Netzwerkanhang verwenden, um eine PSC-Schnittstelle zu erstellen
  • Kommunikation vom Produzenten zum Nutzer über DNS-Peering einrichten
  • Kommunikation mit IP-Adressbereichen außerhalb von RFC 1918 über Vertex AI Pipelines herstellen

Voraussetzungen

Google Cloud-Projekt

IAM-Berechtigungen

2. Hinweis

Projekt für das Tutorial aktualisieren

In dieser Anleitung werden $variables verwendet, um die Implementierung der gcloud-Konfiguration in Cloud Shell zu erleichtern.

Führen Sie in Cloud Shell folgende Schritte aus:

gcloud config list project
gcloud config set project [YOUR-PROJECT-NAME]
projectid=YOUR-PROJECT-NAME
echo $projectid

API-Aktivierung

Führen Sie in Cloud Shell folgende Schritte aus:

gcloud services enable "compute.googleapis.com"
gcloud services enable "aiplatform.googleapis.com"
gcloud services enable "dns.googleapis.com"
gcloud services enable "notebooks.googleapis.com"
gcloud services enable "storage.googleapis.com"
gcloud services enable "cloudresourcemanager.googleapis.com"
gcloud services enable "artifactregistry.googleapis.com"
gcloud services enable "cloudbuild.googleapis.com"

3. Einrichtung durch Nutzer

Consumer-VPC erstellen

Führen Sie in Cloud Shell folgende Schritte aus:

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

Nutzer-Subnetze erstellen

Führen Sie in Cloud Shell folgende Schritte aus:

gcloud compute networks subnets create class-e-subnet --project=$projectid --range=240.0.0.0/4 --network=consumer-vpc --region=us-central1

Führen Sie in Cloud Shell folgende Schritte aus:

gcloud compute networks subnets create rfc1918-subnet1 --project=$projectid --range=10.10.10.0/28 --network=consumer-vpc --region=us-central1

Subnetz für den Private Service Connect-Netzwerkanhang erstellen

Führen Sie in Cloud Shell folgende Schritte aus:

gcloud compute networks subnets create intf-subnet --project=$projectid --range=192.168.10.0/28 --network=consumer-vpc --region=us-central1

Cloud Router- und NAT-Konfiguration

In dieser Anleitung wird Cloud NAT verwendet, um der Proxy-VM, die keine öffentliche IP-Adresse hat, Internetzugriff zu ermöglichen. Cloud NAT ermöglicht es VMs mit nur privaten IP-Adressen, eine Verbindung zum Internet herzustellen, sodass sie Aufgaben wie das Installieren von Softwarepaketen ausführen können.

Erstellen Sie den Cloud Router in Cloud Shell.

gcloud compute routers create cloud-router-for-nat --network consumer-vpc --region us-central1

Erstellen Sie das NAT-Gateway in Cloud Shell.

gcloud compute routers nats create cloud-nat-us-central1 --router=cloud-router-for-nat --auto-allocate-nat-external-ips --nat-all-subnet-ip-ranges --region us-central1 --enable-logging --log-filter=ALL

4. IAP aktivieren

Damit IAP eine Verbindung zu Ihren VM-Instanzen herstellen kann, erstellen Sie eine Firewallregel, die:

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

Erstellen Sie in Cloud Shell die IAP-Firewallregel.

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

5. Consumer-VM-Instanzen erstellen

Erstellen Sie in Cloud Shell die Consumer-VM-Instanz „class-e-vm“.

gcloud compute instances create class-e-vm \
    --project=$projectid \
    --machine-type=e2-micro \
    --image-family debian-11 \
    --no-address \
    --shielded-secure-boot \
    --image-project debian-cloud \
    --zone us-central1-a \
    --subnet=class-e-subnet \
    --metadata startup-script="#! /bin/bash
      sudo apt-get update
      sudo apt-get install tcpdump
      sudo apt-get install apache2 -y
      sudo service apache2 restart
      echo 'Class-e server !!' | tee /var/www/html/index.html
      EOF"

Erstellen Sie in Cloud Shell die Consumer-VM-Instanz „proxy-vm“, die als expliziter Proxy für Vertex AI Pipelines dient. Wir verwenden tinyproxy als Anwendung für das Weiterleiten von HTTP-Traffic, obwohl auch HTTPS unterstützt wird.

gcloud compute instances create proxy-vm \
    --project=$projectid \
    --machine-type=e2-micro \
    --image-family debian-11 \
    --no-address \
    --can-ip-forward \
    --shielded-secure-boot \
    --image-project debian-cloud \
    --zone us-central1-a \
    --subnet=rfc1918-subnet1 \
    --metadata startup-script="#! /bin/bash
      sudo apt-get update
      sudo apt-get install tcpdump
      sudo apt-get install tinyproxy -y
      sudo apt-get install apache2 -y
      sudo service apache2 restart
      echo 'proxy server !!' | tee /var/www/html/index.html
      EOF"

6. Private Service Connect-Netzwerkanhang

Netzwerkanhänge sind regionale Ressourcen, die die Nutzerseite einer Private Service Connect-Schnittstelle darstellen. Sie verknüpfen ein einzelnes Subnetz mit einem Netzwerkanhang und der Ersteller weist der Private Service Connect-Schnittstelle IP-Adressen aus diesem Subnetz zu. Das Subnetz muss sich in derselben Region wie der Netzwerkanhang befinden. Netzwerkanhänge müssen sich in derselben Region wie deren Produzentendienst befinden.

Netzwerkanhang erstellen

Erstellen Sie den Netzwerkanhang in Cloud Shell.

gcloud compute network-attachments create psc-network-attachment \
    --region=us-central1 \
    --connection-preference=ACCEPT_AUTOMATIC \
    --subnets=intf-subnet

Netzwerkanhänge auflisten

Listen Sie die Netzwerkverbindung in Cloud Shell auf.

gcloud compute network-attachments list

Netzwerkanhänge beschreiben

Beschreiben Sie den Netzwerkanhang in Cloud Shell.

gcloud compute network-attachments describe psc-network-attachment --region=us-central1

Notieren Sie sich den Namen des PSC-Netzwerkanhangs (psc-network-attachment), der vom Ersteller beim Erstellen der Private Service Connect-Schnittstelle verwendet wird.

So rufen Sie die URL für die PSC-Netzwerkverbindung in der Cloud Console auf:

„Network Services“ → „Private Service Connect“ → „Network Attachment“ → „psc-network-attachment“

e191e54a103d2222.png

7. Private DNS-Zone

Sie erstellen eine Cloud DNS-Zone für demo.com und füllen sie mit A-Einträgen, die auf die IP-Adressen Ihrer VMs verweisen. Später wird DNS-Peering im Vertex AI Pipelines-Job bereitgestellt, wodurch auf die DNS-Einträge des Nutzers zugegriffen werden kann.

Führen Sie in Cloud Shell folgende Schritte aus:

gcloud dns --project=$projectid managed-zones create private-dns-codelab --description="" --dns-name="demo.com." --visibility="private" --networks="https://compute.googleapis.com/compute/v1/projects/$projectid/global/networks/consumer-vpc"

Führen Sie in Cloud Shell einen „describe“-Befehl für die VM-Instanzen aus, um die entsprechenden IP-Adressen abzurufen.

gcloud compute instances describe class-e-vm --zone=us-central1-a | grep  networkIP:

gcloud compute instances describe proxy-vm --zone=us-central1-a | grep  networkIP:

Erstellen Sie in Cloud Shell den Datensatz für die VM „class-e-vm“. Achten Sie darauf, die IP-Adresse entsprechend der Ausgabe Ihrer Umgebung zu aktualisieren.

gcloud dns --project=$projectid record-sets create class-e-vm.demo.com. --zone="private-dns-codelab" --type="A" --ttl="300" --rrdatas="240.0.0.2"

Erstellen Sie in Cloud Shell den Datensatz für die VM „proxy-vm“. Achten Sie darauf, die IP-Adresse entsprechend der Ausgabe Ihrer Umgebung zu aktualisieren.

gcloud dns --project=$projectid record-sets create proxy-vm.demo.com. --zone="private-dns-codelab" --type="A" --ttl="300" --rrdatas="10.10.10.2"

Cloud Firewall-Regel erstellen, um Zugriff über die PSC-Schnittstelle zuzulassen

Erstellen Sie im folgenden Abschnitt eine Firewallregel, die es Traffic, der vom PSC-Netzwerkanhang stammt, ermöglicht, auf RFC1918-Compute-Ressourcen in der VPC des Nutzers zuzugreifen.

Erstellen Sie in Cloud Shell die Firewallregel für eingehenden Traffic, die den Zugriff vom PSC Network Attachment-Subnetz auf die Proxy-VM ermöglicht.

gcloud compute firewall-rules create allow-access-to-proxy \
    --network=consumer-vpc \
    --action=ALLOW \
    --rules=ALL \
    --direction=INGRESS \
    --priority=1000 \
    --source-ranges="192.168.10.0/28" \
    --destination-ranges="10.10.0.0/19" \
    --enable-logging

Erstellen Sie in Cloud Shell die Firewallregel für eingehenden Traffic, die den Zugriff vom Proxy-VM-Subnetz auf das Subnetz der Klasse E zulässt.

gcloud compute firewall-rules create allow-access-to-class-e \
    --network=consumer-vpc \
    --action=ALLOW \
    --rules=ALL \
    --direction=INGRESS \
    --priority=1000 \
    --source-ranges="10.10.10.0/28" \
    --destination-ranges="240.0.0.0/4" \
    --enable-logging

8. Expliziten Proxy aktualisieren

Im folgenden Abschnitt müssen Sie eine SSH-Verbindung zum expliziten Proxy herstellen, die Konfigurationsdatei „tinyproxy.conf“ aktualisieren und dann einen Reset durchführen.

Über Cloud Shell

gcloud compute ssh --zone us-central1-a "proxy-vm" --tunnel-through-iap --project $projectid

Öffnen Sie die Tinyproxy-Konfigurationsdatei und aktualisieren Sie sie mit einem Editor Ihrer Wahl. Unten sehen Sie ein Beispiel mit VIM.

sudo vim /etc/tinyproxy/tinyproxy.conf

# Locate the "Listen" configuration line to restrict listening to only its private IP address of the Proxy-VM, rather than all interfaces. 

Listen 10.10.10.2

# Locate the "Allow" configuration line to allow requests ONLY from the PSC Network Attachment Subnet

Allow 192.168.10.0/24

Save the configs by the following steps:
1. Press the `ESC` key to enter Command Mode.
2. Type `:wq` to save (w) and quit (q).
3. Press `Enter`

Restart the tinyproxy service to apply the changes:
sudo systemctl restart tinyproxy

Validate the tinyproxy service is running:
sudo systemctl status tinyproxy

Perform an exit returning to cloud shell
exit

9. Jupyter-Notebook erstellen

Im folgenden Abschnitt wird beschrieben, wie Sie ein Jupyter-Notebook erstellen. Mit diesem Notebook wird ein Vertex AI Pipelines-Job bereitgestellt, der einen wget-Befehl von Vertex AI Pipelines an die Testinstanzen sendet. Der Datenpfad zwischen Vertex AI Pipelines und dem Verbrauchernetzwerk mit den Instanzen verwendet eine Private Service Connect-Netzwerkschnittstelle.

Vom Nutzer verwaltetes Dienstkonto erstellen

Im folgenden Abschnitt erstellen Sie ein Dienstkonto, das der in der Anleitung verwendeten Vertex AI Workbench-Instanz zugeordnet wird.

Im Rahmen der Anleitung werden dem Dienstkonto die folgenden Rollen zugewiesen:

Erstellen Sie das Dienstkonto in Cloud Shell.

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

Aktualisieren Sie das Dienstkonto in Cloud Shell mit der Rolle „Storage-Administrator“.

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

Aktualisieren Sie das Dienstkonto in Cloud Shell mit der Rolle „Vertex AI User“.

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

Aktualisieren Sie das Dienstkonto in Cloud Shell mit der Rolle „Artifact Registry-Administrator“.

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

Aktualisieren Sie das Dienstkonto in Cloud Shell mit der Rolle „Cloud Build-Bearbeiter“.

gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:notebook-sa@$projectid.iam.gserviceaccount.com" --role="roles/cloudbuild.builds.editor"

Erlauben Sie in Cloud Shell dem Notebook-Dienstkonto, das Compute Engine-Standarddienstkonto zu verwenden.

gcloud iam service-accounts add-iam-policy-binding \
    $(gcloud projects describe $(gcloud config get-value project) --format='value(projectNumber)')-compute@developer.gserviceaccount.com \
    --member="serviceAccount:notebook-sa@$projectid.iam.gserviceaccount.com" \
    --role="roles/iam.serviceAccountUser"

10. Vertex AI Workbench-Instanz erstellen

Erstellen Sie im folgenden Abschnitt eine Vertex AI Workbench-Instanz, in die das zuvor erstellte Dienstkonto „notebook-sa“ eingebunden ist.

Erstellen Sie in Cloud Shell die private-client-Instanz.

gcloud workbench instances create workbench-tutorial --vm-image-project=cloud-notebooks-managed --vm-image-family=workbench-instances --machine-type=n1-standard-4 --location=us-central1-a --subnet-region=us-central1 --subnet=rfc1918-subnet1 --disable-public-ip --shielded-secure-boot=true --shielded-integrity-monitoring=true --shielded-vtpm=true --service-account-email=notebook-sa@$projectid.iam.gserviceaccount.com

11. Aktualisierung des Vertex AI-Dienst-Agents

Vertex AI führt in Ihrem Namen Vorgänge aus, z. B. das Abrufen einer IP-Adresse aus dem PSC Network Attachment-Subnetz, das zum Erstellen der PSC-Schnittstelle verwendet wird. Dazu verwendet Vertex AI einen Dienst-Agent (siehe unten), für den die Berechtigung Netzwerkadministrator erforderlich ist.

service-$projectnumber@gcp-sa-aiplatform.iam.gserviceaccount.com

Rufen Sie in Cloud Shell Ihre Projektnummer ab.

gcloud projects describe $projectid | grep projectNumber

Rufen Sie in Cloud Shell Ihre Projektnummer ab.

gcloud projects describe $projectid | grep projectNumber
projectNumber: '234086459238'

Legen Sie in Cloud Shell Ihre Projektnummer fest.

projectnumber=YOUR-PROJECT-Number

Erstellen Sie in Cloud Shell ein Dienstkonto für AI Platform. Überspringen Sie diesen Schritt, wenn Sie bereits ein Dienstkonto in Ihrem Projekt haben.

gcloud beta services identity create --service=aiplatform.googleapis.com --project=$projectnumber

Aktualisieren Sie in Cloud Shell das Dienstkonto des Dienst-Agents mit der Rolle „compute.networkAdmin“.

gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:service-$projectnumber@gcp-sa-aiplatform.iam.gserviceaccount.com" --role="roles/compute.networkAdmin"

Aktualisieren Sie in Cloud Shell das Dienstkonto des Dienst-Agents mit der Rolle „dns.peer“.

gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:service-$projectnumber@gcp-sa-aiplatform.iam.gserviceaccount.com" --role="roles/dns.peer"

Aktualisierung des Standarddienstkontos

Aktivieren Sie die Compute Engine API und gewähren Sie Ihrem Standarddienstkonto Zugriff auf Vertex AI. Es kann einige Zeit dauern, bis die Zugriffsänderung wirksam wird.

Aktualisieren Sie in Cloud Shell das Standarddienstkonto mit der Rolle „aiplatform.user“.

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

Aktualisieren Sie in Cloud Shell das Standarddienstkonto mit der Rolle „storage.admin“.

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

Aktualisieren Sie in Cloud Shell das Standarddienstkonto mit der Rolle „storage.admin“.

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

12. Tcpdump aktivieren

Um die IP-Verbindung von Vertex AI Pipelines aus zu validieren, können wir TCPDUMP verwenden. So können wir die Kommunikation beobachten, die vom Subnetz der PSC-Netzwerkverbindung (192.168.10.0/28) ausgeht, wenn die GET-Anfrage von Vertex AI Pipelines an die VM „class-e-vm.demo.com“ (240.0.0.0/4) gesendet wird.

Stellen Sie in Cloud Shell über SSH eine Verbindung zur Proxy-VM her.

gcloud compute ssh --zone us-central1-a "proxy-vm" --tunnel-through-iap --project $projectid

Führen Sie auf dem Betriebssystem der Proxy-VM tcpdump-Filterung für das Subnetz der Class E-VM und der PSC-Netzwerkverbindung aus.

sudo tcpdump -i any net 240.0.0.0/4 or 192.168.10.0/28 -nn

Öffnen Sie einen neuen Cloud Shell-Tab, aktualisieren Sie die Projektvariable und stellen Sie eine SSH-Verbindung zur VM der Klasse E her.

gcloud compute ssh --zone us-central1-a "class-e-vm" --tunnel-through-iap --project $projectid

Führen Sie auf dem Betriebssystem der Klasse-e-VM die tcpdump-Filterung für das Proxy-VM-Subnetz aus.

sudo tcpdump -i any net 10.10.10.0/28 -nn

13. Vertex AI Pipelines-Job bereitstellen

Im folgenden Abschnitt erstellen Sie ein Notebook, um einen erfolgreichen wget-Vorgang von Vertex AI Pipelines zum expliziten Proxy auszuführen. So können Sie VMs außerhalb des RFC 1918-Bereichs erreichen, z. B. die class-e-vm. Für den Zugriff von Vertex AI Pipelines auf „rfc1918-vm“ ist kein expliziter Proxy erforderlich, da das Ziel eine RFC 1918-IP-Adresse ist.

Führen Sie den Trainingsjob in der Vertex AI Workbench-Instanz aus.

  1. Rufen Sie in der Google Cloud Console auf der Seite „Vertex AI Workbench“ den Tab „Instanzen“ auf.
  2. Klicken Sie neben dem Namen der Vertex AI Workbench-Instanz (workbench-tutorial) auf „JupyterLab öffnen“. Ihre Vertex AI Workbench-Instanz öffnet JupyterLab.
  3. Wählen Sie „Datei“ > „Neu“ > „Notebook“ aus.
  4. Wählen Sie „Kernel“ > „Python 3“ aus.

Erstellen Sie in Ihrem JupyterLab-Notebook eine neue Zelle und führen Sie den folgenden Code aus.

# Install gcloud
!pip install google-cloud

# Install the pipeline required packages
!pip install --upgrade google-cloud-aiplatform \
                         google-cloud-storage \
                         kfp \
                         google-cloud-pipeline-components

# Import libraries
from time import gmtime, strftime
import json
import requests

Erstellen Sie in Ihrem JupyterLab-Notebook eine neue Zelle, aktualisieren Sie den folgenden Code und führen Sie ihn aus. Achten Sie darauf, PROJECT_ID mit den Details Ihrer Umgebung zu aktualisieren.

import json
import requests
import pprint

PROJECT_ID = 'YOUR-PROJECT-ID' #Enter your project ID
PROJECT_NUMBER=!gcloud projects list --filter="project_id:$PROJECT_ID" --format="value(PROJECT_NUMBER)"
PROJECT_NUMBER=str(PROJECT_NUMBER).strip('[').strip(']').strip("'")
print(PROJECT_NUMBER)

Erstellen Sie in Ihrem JupyterLab-Notebook eine neue Zelle und führen Sie den folgenden Code aus.

# us-central1 is used for the codelab
REGION = "us-central1" #@param {type:"string"}
SERVICE_NAME = "aiplatform" #@param {type:"string"}
SERVICE ="{}.googleapis.com".format(SERVICE_NAME)
ENDPOINT="{}-{}.googleapis.com".format(REGION, SERVICE_NAME)
API_VERSION = "v1" # @param {type: "string"}

LOCATION = REGION

Erstellen Sie in Ihrem JupyterLab-Notebook eine neue Zelle und führen Sie die folgende Konfiguration aus. Beachten Sie dabei die folgenden Punkte:

  • proxy_server = "http://proxy-vm.demo.com:8888" Der FQDN ist der Proxy-VM zugeordnet, die im Nutzer-VPC bereitgestellt wird. Wir verwenden DNS-Peering, um den FQDN in einem späteren Schritt aufzulösen.
%%writefile main.py

import logging
import socket
import sys
import os

def make_api_request(url: str, proxy_vm_ip: str, proxy_vm_port: str):
    """
    Makes a GET request to a non-rfc1918 API and saves the response.

    Args:
        url: The URL of the API to send the request to.
    """
    import requests

    try:
        # response = requests.get(url)
        proxy_server = f"http://proxy-vm.demo.com:8888" # replace with you VM's IP and proxy port.

        proxies = {
          "http": proxy_server,
          "https": proxy_server,
        }

        response = requests.get(url, proxies=proxies)
        logging.info(response.text)

        response.raise_for_status()  # Raise an exception for bad status codes
        logging.info(f"Successfully fetched data from {url}")
    except requests.exceptions.RequestException as e:
        logging.error(f"An error occurred: {e}")
        raise e

if __name__ == '__main__':
  # Configure logging to print clearly to the console
  logging.basicConfig(
      level=logging.INFO,
      format='%(levelname)s: %(message)s',
      stream=sys.stdout
  )
  url_to_test = os.environ['NONRFC_URL']
  proxy_vm_ip = os.environ['PROXY_VM_IP']
  proxy_vm_port = os.environ['PROXY_VM_PORT']

  logging.info(f"url_to_test: {url_to_test}")
  logging.info(f"proxy_vm_ip: {proxy_vm_ip}")
  logging.info(f"proxy_vm_port: {proxy_vm_port}")
  make_api_request(url_to_test, proxy_vm_ip, proxy_vm_port)

Erstellen Sie in Ihrem JupyterLab-Notebook eine neue Zelle und führen Sie den folgenden Code aus.

%%writefile Dockerfile
FROM python:3.9-slim

RUN apt-get update && \
  apt-get install -y iputils-ping && \
  apt-get install -y wget

RUN pip install cloudml-hypertune requests kfp

COPY main.py /main.py

ENTRYPOINT ["python3", "/main.py"]

Erstellen Sie in Ihrem JupyterLab-Notebook eine neue Zelle und führen Sie den folgenden Code aus.

!gcloud artifacts repositories create pipelines-test-repo-psc --repository-format=docker --location=us-central1

Erstellen Sie in Ihrem JupyterLab-Notebook eine neue Zelle und führen Sie den folgenden Code aus.

IMAGE_PROJECT = PROJECT_ID
IMAGE_REPO = 'pipelines-test-repo-psc' 
IMAGE_NAME = 'nonrfc-ip-call'
TAG = 'v1'

IMAGE_URI= f'us-central1-docker.pkg.dev/{IMAGE_PROJECT}/{IMAGE_REPO}/{IMAGE_NAME}:{TAG}'
IMAGE_URI

Erstellen Sie in Ihrem JupyterLab-Notebook eine neue Zelle und führen Sie den folgenden Code aus.

!gcloud auth configure-docker us-docker.pkg.dev --quiet

Erstellen Sie in Ihrem JupyterLab-Notebook eine neue Zelle und führen Sie den folgenden Code aus. Ignorieren Sie den Fehler (gcloud.builds.submit), falls vorhanden.

!gcloud builds submit --tag {IMAGE_URI} --region=us-central1

Erstellen und führen Sie in Ihrem JupyterLab-Notebook die folgende Zelle aus. Beachten Sie dabei die folgenden Punkte:

  • DNS-Peering für VPCs von Nutzern wird mit dnsPeeringConfigs für den Domainnamen demo.com konfiguriert.
  • Der explizite Proxy, der als Variable PROXY_VM_IP definiert ist, ist proxy-vm.demo.com. Die Auflösung erfolgt über DNS-Peering innerhalb der VPC des Nutzers.
  • Port 8888 ist der in Tinyproxy konfigurierte Überwachungsport (Standard).
  • „wget“ für „class-e-vm-demo.com“ wird über DNS-Peering aufgelöst
  • Der Code gibt den „psc-network-attachment“ für Vertex an, sodass das Subnetz des Netzwerkanhangs verwendet werden kann, um zwei PSC-Schnittstelleninstanzen bereitzustellen.
import json
from datetime import datetime


JOB_ID_PREFIX='test_psci-nonRFC' #@param {type:"string"}
JOB_ID = '{}_{}'.format(JOB_ID_PREFIX, datetime.now().strftime("%Y%m%d%H%M%S"))

# PSC-I configs

PRODUCER_PROJECT_ID = PROJECT_ID
DNS_DOMAIN = 'class-e-vm.demo.com' #@param {type:"string"}
NON_RFC_URL = f"http://{DNS_DOMAIN}"

PROXY_VM_IP = "proxy-vm.demo.com" #@param {type:"string"}
PROXY_VM_PORT = "8888" #@param {type:"string"}

CUSTOM_JOB = {
  "display_name": JOB_ID,
  "job_spec": {
      "worker_pool_specs": [
          {
           "machine_spec": {
             "machine_type": "n1-standard-4",
           },
           "replica_count": 1,
           "container_spec": {
             "image_uri": IMAGE_URI,
             "env": [{
               "name": "NONRFC_URL",
               "value": NON_RFC_URL
             },
             {
               "name": "PROXY_VM_IP",
               "value": PROXY_VM_IP
             },
             {
               "name": "PROXY_VM_PORT",
               "value": PROXY_VM_PORT
             }]
           },
         },
      ],
      "enable_web_access": True,
      "psc_interface_config": {
        "network_attachment": "psc-network-attachment",
        "dns_peering_configs": [
          {
            "domain": "demo.com.",
            "target_project": PROJECT_ID,
            "target_network": "consumer-vpc"
          },
        ]
      },
  }
}

print(json.dumps(CUSTOM_JOB, indent=2))

Erstellen Sie in Ihrem JupyterLab-Notebook eine neue Zelle und führen Sie den folgenden Code aus.

import requests
bearer_token = !gcloud auth application-default print-access-token
headers = {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer {}'.format(bearer_token[0]),
}

request_uri = f"https://{REGION}-aiplatform.googleapis.com/{API_VERSION}/projects/{PROJECT_NUMBER}/locations/{REGION}/customJobs/"

print("request_uri: ", request_uri)

Erstellen Sie in Ihrem JupyterLab-Notebook eine neue Zelle und führen Sie den folgenden Code aus.

response_autopush = requests.post(request_uri, json=CUSTOM_JOB, headers=headers)
response = response_autopush
print("response:", response)
if response.reason == 'OK':
  job_name = response.json()['name']
  job_id = job_name.split('/')[-1]
  print("Created Job: ", response.json()['name'])
else:
  print(response.text)

Erstellen Sie in Ihrem JupyterLab-Notebook eine neue Zelle und führen Sie den folgenden Code aus.

# Print KFP SDK version (should be >= 1.6)
! python3 -c "import kfp; print('KFP SDK version: {}'.format(kfp.__version__))"

# Print AI Platform version
! python3 -c "from google.cloud import aiplatform; print('AI Platform version: {}'.format(aiplatform.__version__))"

Erstellen Sie in Ihrem JupyterLab-Notebook eine neue Zelle und führen Sie den folgenden Code aus.

BUCKET_URI = "your-unique-bucket" # Provide a globally unique bucket name

Erstellen Sie in Ihrem JupyterLab-Notebook eine neue Zelle und führen Sie den folgenden Code aus.

!gcloud storage buckets create gs://{BUCKET_URI}

Erstellen Sie in Ihrem JupyterLab-Notebook eine neue Zelle und führen Sie den folgenden Code aus.

# pipeline parameters
CACHE_PIPELINE = False # @param {type: "string"}
_DEFAULT_IMAGE = IMAGE_URI
BUCKET_URI = "gs://{BUCKET_URI}"  # @param {type: "string"}
PIPELINE_ROOT = f"{BUCKET_URI}/pipeline_root/intro"
PIPELINE_DISPLAY_NAME = "pipeline_nonRFCIP" # @param {type: "string"}

Erstellen Sie in Ihrem JupyterLab-Notebook eine neue Zelle und führen Sie den folgenden Code aus.

from re import S
import kfp
from kfp import dsl
from kfp.dsl import container_component, ContainerSpec
from kfp import compiler
from google.cloud import aiplatform


# ==== Component with env variable ====

@container_component
def dns_peering_test_op(dns_domain: str, proxy_vm_ip:str, proxy_vm_port:str):
    return ContainerSpec(
        image=_DEFAULT_IMAGE,
        command=["bash", "-c"],
        args=[
            """
            apt-get update && apt-get install inetutils-traceroute inetutils-ping netcat-openbsd curl -y

            echo "Local IP(s): $(hostname -I)"

            echo "Attempting to trace route to %s"
            traceroute -w 1 -m 7 "%s"

            echo "Sending curl requests to http://%s via proxy %s:%s and recording trace..."
            if curl -L -v --trace-ascii /dev/stdout -x http://%s:%s "http://%s"; then
                echo "Curl request succeeded!"
            else
                echo "Curl request failed!"
                exit 1
            fi
            """ % (dns_domain, dns_domain, dns_domain, proxy_vm_ip, proxy_vm_port, proxy_vm_ip, proxy_vm_port, dns_domain)

        ]
    )

# ==== Pipeline ====
@dsl.pipeline(
    name="dns-peering-test-pipeline",
    description="Test DNS Peering using env variable",
    pipeline_root=PIPELINE_ROOT,
)
def dns_peering_test_pipeline(dns_domain: str, proxy_vm_ip:str, proxy_vm_port:str):
    dns_test_task = dns_peering_test_op(dns_domain=dns_domain, proxy_vm_ip=proxy_vm_ip, proxy_vm_port=proxy_vm_port)
    dns_test_task.set_caching_options(enable_caching=CACHE_PIPELINE)

# ==== Compile pipeline ====
if __name__ == "__main__":
    aiplatform.init(project=PROJECT_ID, location=LOCATION)

    compiler.Compiler().compile(
        pipeline_func=dns_peering_test_pipeline,
        package_path="dns_peering_test_pipeline.yaml",
    )
    print("✅ Pipeline compiled to dns_peering_test_pipeline.yaml")

Erstellen Sie in Ihrem JupyterLab-Notebook eine neue Zelle und führen Sie den folgenden Code aus.

# Define the PipelineJob body; see API Reference https://cloud.google.com/vertex-ai/docs/reference/rest/v1/projects.locations.pipelineJobs/create

import requests, json
import datetime

bearer_token = !gcloud auth application-default print-access-token
headers = {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer {}'.format(bearer_token[0]),
}

request_uri = f"https://{REGION}-aiplatform.googleapis.com/{API_VERSION}/projects/{PROJECT_NUMBER}/locations/{REGION}/pipelineJobs/"

print("request_uri: ", request_uri)

14. PSC-Schnittstellenvalidierung

Sie können die von Vertex AI Pipelines verwendeten Network Attachment-IPs auch so aufrufen:

„Network Services“ → „Private Service Connect“ → „Network Attachment“ → „psc-network-attachment“

Wählen Sie das Mandantenprojekt aus (Projektname endet auf „-tp“).

f47150235fedb8ce.png

Das hervorgehobene Feld gibt die IP-Adresse an, die von Vertex AI Pipelines über die PSC-Netzwerkverbindung verwendet wird.

39e7b251aeb4f191.png

15. Cloud Logging-Validierung

Der Vertex AI Pipelines-Job dauert beim ersten Mal etwa 14 Minuten. Nachfolgende Ausführungen sind viel kürzer. So prüfen Sie, ob das Ergebnis erfolgreich war:

Rufen Sie „Vertex AI“ → „Training“ → „Benutzerdefinierte Jobs“ auf.

Ausgeführten benutzerdefinierten Job auswählen

a9be0395c842aa6f.png

„Logs ansehen“ auswählen

53e30765ba5827f3.png

Sobald Cloud Logging verfügbar ist, wählen Sie „Run Query“ (Abfrage ausführen) aus, um die unten hervorgehobene Auswahl zu generieren, die einen erfolgreichen wget von Vertex AI Pipelines zum class-e-vm bestätigt.

f2c5d9fdf5cc8bed.png

3b3788603bb433ee.png

16. TCPDump-Validierung

Sehen wir uns die TCPDUMP-Ausgabe an, die die Verbindung zu Compute-Instanzen weiter bestätigt:

HTTP GET und 200 OK von proxy-vm beobachten

03:05:34.778574 ens4  Out IP 10.10.10.2.40326 > 240.0.0.2.80: Flags [P.], seq 1:63, ack 1, win 511, options [nop,nop,TS val 1435446009 ecr 2475360885], length 62: HTTP: GET / HTTP/1.0
03:05:34.778946 ens4  In  IP 240.0.0.2.80 > 10.10.10.2.40326: Flags [.], ack 63, win 506, options [nop,nop,TS val 2475360889 ecr 1435446009], length 0
03:05:34.778974 ens4  Out IP 10.10.10.2.40326 > 240.0.0.2.80: Flags [P.], seq 63:185, ack 1, win 511, options [nop,nop,TS val 1435446010 ecr 2475360889], length 122: HTTP
03:05:34.781999 ens4  In  IP 240.0.0.2.80 > 10.10.10.2.40326: Flags [.], ack 185, win 506, options [nop,nop,TS val 2475360892 ecr 1435446010], length 0
03:05:34.906678 ens4  In  IP 240.0.0.2.80 > 10.10.10.2.40326: Flags [P.], seq 1:265, ack 185, win 506, options [nop,nop,TS val 2475361016 ecr 1435446010], length 264: HTTP: HTTP/1.1 200 OK

HTTP GET und 200 OK auf der Klasse-E-VM beobachten

03:05:34.778768 ens4  In  IP 10.10.10.2.40326 > 240.0.0.2.80: Flags [P.], seq 1:63, ack 1, win 511, options [nop,nop,TS val 1435446009 ecr 2475360885], length 62: HTTP: GET / HTTP/1.0
03:05:34.778819 ens4  Out IP 240.0.0.2.80 > 10.10.10.2.40326: Flags [.], ack 63, win 506, options [nop,nop,TS val 2475360889 ecr 1435446009], length 0
03:05:34.781815 ens4  In  IP 10.10.10.2.40326 > 240.0.0.2.80: Flags [P.], seq 63:185, ack 1, win 511, options [nop,nop,TS val 1435446010 ecr 2475360889], length 122: HTTP
03:05:34.781856 ens4  Out IP 240.0.0.2.80 > 10.10.10.2.40326: Flags [.], ack 185, win 506, options [nop,nop,TS val 2475360892 ecr 1435446010], length 0
03:05:34.906503 ens4  Out IP 240.0.0.2.80 > 10.10.10.2.40326: Flags [P.], seq 1:265, ack 185, win 506, options [nop,nop,TS val 2475361016 ecr 1435446010], length 264: HTTP: HTTP/1.1 200 OK

17. Bereinigen

Löschen Sie die Komponenten der Anleitung in Cloud Shell.

gcloud compute instances delete proxy-vm --zone=us-central1-a --quiet

gcloud compute instances delete workbench-tutorial --zone=us-central1-a --quiet

gcloud compute routers delete cloud-router-for-nat --region=us-central1 --quiet

gcloud compute network-attachments delete psc-network-attachment --region=us-central1 --quiet

gcloud compute networks subnets delete intf-subnet rfc1918-subnet1 --region=us-central1 --quiet

gcloud dns record-sets delete class-e-vm.demo.com --zone=private-dns-codelab  --type=A
gcloud dns record-sets delete proxy-vm.demo.com --zone=private-dns-codelab  --type=A

gcloud dns managed-zones delete private-dns-codelab
gcloud compute networks delete consumer-vpc --quiet

18. Glückwunsch

Sie haben eine Private Service Connect-Schnittstelle mit Vertex AI Pipelines konfiguriert und validiert.

Sie haben die Infrastruktur des Nutzers erstellt und einen Netzwerkanhang hinzugefügt, der es dem Produzenten ermöglicht, eine VM mit mehreren NICs zu erstellen, um die Kommunikation zwischen Nutzer und Produzent zu ermöglichen. Sie haben gelernt, wie Sie DNS-Peering erstellen, während Sie einen expliziten Proxy im VPC-Nutzernetzwerk bereitstellen, der die Verbindung zur VM-Instanz der Klasse E ermöglicht, die nicht direkt von Vertex aus geroutet werden kann.

Cosmopup findet Tutorials toll!!

c911c127bffdee57.jpeg

Nächste Schritte

Weitere Informationen und Videos

Referenzdokumente