Vertex AI Pipelines – PSC-Schnittstelle – SWP

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.

d7dc28d6567e6283.pngAbbildung 1

Überlegungen zur Erreichbarkeit von Vertex AI-PSC-Schnittstellen

  • Die PSC-Schnittstelle von Vertex AI kann Traffic an Ziele in einer VPC oder lokal 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-Modus „Secure Web Proxy“ (SWP), der in der Nutzer-VPC 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/24
  3. Für 10.10.20.0/28 ist kein Proxy erforderlich, da der Bereich in den RFC 1918-Bereich fällt.
  4. Ausgehender Internettraffic

Internetverbindung für das von Google verwaltete Mandantennetzwerk:

Vertex AI mit PSC-Schnittstelle ohne VPC-SC

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

Vertex AI-PSC-Schnittstelle mit VPC-SC

  • Wenn Ihr Projekt Teil eines VPC Service Controls-Perimeters ist, wird der standardmäßige Internetzugriff des 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 leitet, die mit Vertex AI verbunden ist. Eine Möglichkeit, dies zu erreichen, ist die Bereitstellung eines Proxyservers im VPC-Netzwerk mit einer RFC 1918-Adresse in Kombination mit einem Cloud NAT-Gateway. Sie können den Traffic auch über den sicheren Web-Proxy an das Internet weiterleiten. Beim Erstellen eines sicheren Web-Proxys wird automatisch ein Cloud NAT-Gateway erstellt.

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 PSC-Schnittstelle (Private Service Connect), um die Verbindung vom Ersteller zur Compute-Instanz des Nutzers zu ermöglichen, wie in Abbildung 1 dargestellt. Dabei wird ein Endpunkt außerhalb von RFC 1918 in class-e-subnet verwendet.

2d095dc2f4de6b4b.pngAbbildung 2

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:

Stellen Sie Vertex AI Pipelines bereit und konfigurieren Sie Secure Web Proxy im expliziten Proxymodus, damit ein wget für eine VM im Subnetz der Klasse E ausgeführt werden kann.

Lerninhalte

  • Netzwerkanhang erstellen
  • So kann ein Produzent einen Netzwerkanhang verwenden, um eine PSC-Schnittstelle zu erstellen
  • DNS-Peering einrichten, um private Domains aufzulösen, die im VPC-Netzwerk des Kunden über die von Google verwalteten VPC-Netzwerke konfiguriert sind
  • Traffic von der Vertex AI PSC-Schnittstelle an Secure Web Proxy weiterleiten
  • 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-ID]
projectid=YOUR-PROJECT-ID
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"
gcloud services enable "networkservices.googleapis.com"
gcloud services enable "networksecurity.googleapis.com"
gcloud services enable "certificatemanager.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 --enable-private-ip-google-access

Nur-Proxy-Subnetz erstellen

gcloud compute networks subnets create proxy-only-uscentral1 \
    --purpose=REGIONAL_MANAGED_PROXY \
    --role=ACTIVE \
    --region=us-central1 \
    --network=consumer-vpc \
    --range=10.10.100.0/26

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 \
--enable-private-ip-google-access

Cloud Router- und NAT-Konfiguration

Google Cloud Secure Web Proxy stellt automatisch ein Cloud NAT-Gateway und einen zugehörigen Cloud Router in der Region bereit und verwaltet sie, in der die Lösung bereitgestellt wird.

4. IAP aktivieren

Damit IAP (Identity-Aware Proxy) 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 \ 
    --private-network-ip=240.0.0.2

6. Sicherer Web-Proxy

Der explizite Modus (oder explizite Proxy-Routing-Modus) von Secure Web Proxy ist eine Bereitstellungsmethode, bei der die Clientarbeitslasten explizit so konfiguriert werden müssen, dass sie die interne IP-Adresse oder den vollqualifizierten Domainnamen und den Port von SWP als Weiterleitungs-Proxy verwenden.

Achten Sie darauf, dass Sie in den folgenden Schritten YOUR-PROJECT-ID durch Ihre Projekt-ID ersetzen.

Web-Proxy erstellen:

Erstellen Sie in Cloud Shell die Datei policy.yaml mit einem Texteditor:

cat > policy.yaml << EOF
description: basic Secure Web Proxy policy
name: projects/$projectid/locations/us-central1/gatewaySecurityPolicies/policy1
EOF

Generieren Sie in Cloud Shell die Secure Web Proxy-Richtlinie:

gcloud network-security gateway-security-policies import policy1 \
    --source=policy.yaml \
    --location=us-central1

Erstellen Sie im folgenden Abschnitt eine Regel, um den Zugriff auf class-e-vm basierend auf dem Host sessionMatcher zuzulassen.

Erstellen Sie in Cloud Shell die Datei rule1.yaml mit einem Texteditor:

cat > rule1.yaml << EOF
name: projects/$projectid/locations/us-central1/gatewaySecurityPolicies/policy1/rules/allow-nonrfc-classe
description: Allow nonrfc class-e
enabled: true
priority: 1
basicProfile: ALLOW
sessionMatcher: host() == 'class-e-vm.demo.com'
EOF

Erstellen Sie im folgenden Abschnitt eine Regel, um dem Jupyter-Notebook Zugriff zu gewähren, damit Apache2 auf der VM "class-e" installiert werden kann.

Erstellen Sie in Cloud Shell die Datei rule2.yaml mit einem Texteditor:

cat > rule2.yaml << EOF
name: projects/$projectid/locations/us-central1/gatewaySecurityPolicies/policy1/rules/allow-apache2
description: Allow Apache2 install on class-e VM
enabled: true
priority: 2
basicProfile: ALLOW
sessionMatcher: inIpRange(source.ip,'240.0.0.2')
EOF

Generieren Sie in Cloud Shell die Sicherheitsrichtlinienregel 1:

gcloud network-security gateway-security-policies rules import allow-nonrfc-classe \
    --source=rule1.yaml \
    --location=us-central1 \
    --gateway-security-policy=policy1

Generieren Sie in Cloud Shell die Sicherheitsrichtlinienregel 2:

gcloud network-security gateway-security-policies rules import allow-apache2 \
    --source=rule2.yaml \
    --location=us-central1 \
    --gateway-security-policy=policy1

Konfigurieren Sie das Secure Web Proxy-Gateway mit den folgenden Einstellungen, um Vertex AI Training zu unterstützen:

  • Listening Port: Verwenden Sie denselben Port, der in den expliziten Proxyeinstellungen des Codes der Vertex AI-Anwendung konfiguriert ist (z.B. 8080).
  • Adresse: Weisen Sie eine private IP-Adresse aus dem RFC 1918-Bereich zu.
  • Routingmodus: Stellen Sie diesen auf EXPLICIT_ROUTING_MODE ein.

Erstellen Sie in Cloud Shell eine gateway.yaml-Datei, um das Secure Web Proxy-Gateway zu definieren:

cat > gateway.yaml << EOF
name: projects/$projectid/locations/us-central1/gateways/swp1
type: SECURE_WEB_GATEWAY
addresses: ["10.10.10.5"]
ports: [8080]
gatewaySecurityPolicy: projects/$projectid/locations/us-central1/gatewaySecurityPolicies/policy1
network: projects/$projectid/global/networks/consumer-vpc
subnetwork: projects/$projectid/regions/us-central1/subnetworks/rfc1918-subnet1
routingMode: EXPLICIT_ROUTING_MODE
EOF

Generieren Sie in Cloud Shell die Secure Web Proxy-Instanz:

gcloud network-services gateways import swp1 \
    --source=gateway.yaml \
    --location=us-central1

Die Bereitstellung eines Secure Web Proxy kann einige Minuten dauern.

e8a4cf23bfc63030.png

7. 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_MANUAL \
    --subnets=intf-subnet

Hinweis:Sie müssen die akzeptierte Projekt-ID in diesem Anhang nicht explizit erwähnen. Wenn Vertex AI konfiguriert ist, wird das von Google verwaltete Mandantenprojekt automatisch hinzugefügt, als ob „Automatisch akzeptieren“ konfiguriert wäre.

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 Dienstersteller 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“

b969cca5242d9c8a.png

8. 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, sodass 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"

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

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 den Secure Web Proxy. Achten Sie darauf, die IP-Adresse entsprechend der Ausgabe Ihrer Umgebung zu aktualisieren.

gcloud dns --project=$projectid record-sets create explicit-swp.demo.com. --zone="private-dns-codelab" --type="A" --ttl="300" --rrdatas="10.10.10.5"

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

Erstellen Sie im folgenden Abschnitt eine Firewallregel, die den Zugriff auf die RFC 1918-Compute-Ressourcen in der VPC des Nutzers für Traffic zulässt, der vom PSC-Netzwerkanhang stammt.

Erstellen Sie in Cloud Shell die Firewallregel für eingehenden Traffic, die den Zugriff vom Nur-Proxy-Subnetz auf das Subnetz der Klasse E zulässt. SWP initiiert die Verbindung mit dem Nur-Proxy-Subnetz als Quelladresse.

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.100.0/28" \
    --destination-ranges="240.0.0.0/4" \
    --enable-logging

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 eine wget von Vertex AI Pipelines an die Testinstanzen sendet. Der Datenpfad zwischen Vertex AI Pipelines und dem Netzwerk des Nutzers, das die Instanzen enthält, verwendet eine Private Service Connect-Schnittstelle.

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:

Melden Sie sich in Cloud Shell an und führen Sie die folgenden Schritte aus:

Erstellen Sie das Dienstkonto.

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

Aktualisieren Sie das Dienstkonto 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 mit der Rolle „AI Platform-Nutzer“.

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

Aktualisieren Sie das Dienstkonto 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 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 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 Clientinstanz.

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

Hinweis: Bevor Sie die Berechtigungen des Dienstkontos aktualisieren, rufen Sie Vertex AI in der Cloud Console auf, um sicherzustellen, dass die Vertex AI API aktiviert ist.

In Cloud Shell:

Rufen Sie Ihre Projektnummer ab.

gcloud projects describe $projectid | grep projectNumber

Legen Sie Ihre Projektnummer fest.

projectnumber=YOUR-PROJECT-NUMBER

Dienstkonto für AI Platform erstellen Ü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 das Dienst-Agent-Konto 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 das Dienst-Agent-Konto 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.

So aktualisieren Sie das Standarddienstkonto mit Cloud Shell:

Standarddienstkonto mit der Rolle aiplatform.user aktualisieren

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

Standarddienstkonto mit der Rolle storage.admin aktualisieren

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

Standarddienstkonto mit der Rolle artifactregistry.admin aktualisieren

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

12. Installieren Sie Apache2 und aktivieren Sie Tcpdump auf „class-e-vm“:

Installieren Sie apache2 über Secure Web Proxy auf der class-e-vm:

Ö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

sudo apt-get -o Acquire::http::Proxy="http://10.10.10.5:8080" update
sudo apt-get -o Acquire::http::Proxy="http://10.10.10.5:8080" install apache2 -y
sudo service apache2 restart
echo 'class-e Server !!' | sudo tee /var/www/html/index.html

Führen Sie die tcpdump-Filterung für das Nur-Proxy-Subnetz aus, das vom sicheren Web-Proxy verwendet wird, um den Traffic an die Ziele weiterzuleiten.

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.100.0/24 -nn

Hinweis:Achten Sie darauf, dass Sie den privaten Google-Zugriff im Subnetz der Workbench-Tutorial-Instanz aktivieren, damit die JupyterLab-Sitzung geöffnet werden kann.

13. Vertex AI Pipelines-Job bereitstellen

Im folgenden Abschnitt erstellen Sie ein Notebook, um einen erfolgreichen wget 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, 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 wichtigen Punkte:

  • proxy_server = "http://explicit-swp.demo.com:8080"
  • Ein FQDN ist mit der Proxy-VM verknüpft, 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 nonRFC-1918 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://explicit-swp.demo.com:8080" # replace it with your Secure Web proxy Ip-address and the 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 Web-Proxy im expliziten Routingmodus ist hier explicit-swp.demo.com. Die Auflösung erfolgt über DNS-Peering in der VPC des Nutzers.
  • Port 8080 ist der in Secure Web Proxy konfigurierte Standard-Listening-Port.
  • wget wird über DNS-Peering in class-e-vm-demo.com 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 = "explicit-swp.demo.com" #@param {type:"string"}
PROXY_VM_PORT = "8080" #@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“).

a2e0b6d6243f26f1.png

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

11e411ea919d3bad.png

15. Cloud Logging-Validierung

Der erste Lauf des Vertex AI Pipelines-Jobs dauert etwa 14 Minuten. Nachfolgende Läufe 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

2f467254aa0c2e3a.png

„Logs ansehen“ auswählen

8d525d3b152bcc61.png

Sobald Cloud Logging verfügbar ist, wählen Sie „Abfrage ausführen“ aus, um die unten hervorgehobene Auswahl zu generieren, die eine erfolgreiche wget von Vertex AI Pipelines zur class-e-vm bestätigt.

a4f9e9167f4ce1ae.png

38972f834aa2bd1d.png

16. tcpdump-Validierung

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

Beobachten Sie ab class-e-vm die HTTP-GET-Anfrage und die Antwort „200 OK“.

XXXXXXXXX@class-e-vm:~$ sudo tcpdump -i any net 10.10.100.0/28 -nn
tcpdump: data link type LINUX_SLL2
tcpdump: verbose output suppressed, use -v[v]... for full protocol decode
listening on any, link-type LINUX_SLL2 (Linux cooked v2), snapshot length 262144 bytes
05:51:14.173641 ens4  In  IP 10.10.100.8.55306 > 240.0.0.2.80: Flags [S], seq 1747181041, win 65535, options [mss 1420,sackOK,TS val 3942828403 ecr 0,nop,wscale 8], length 0
05:51:14.173668 ens4  Out IP 240.0.0.2.80 > 10.10.100.8.55306: Flags [S.], seq 3013226100, ack 1747181042, win 64768, options [mss 1420,sackOK,TS val 1886125065 ecr 3942828403,nop,wscale 7], length 0
05:51:14.174977 ens4  In  IP 10.10.100.8.55306 > 240.0.0.2.80: Flags [.], ack 1, win 1054, options [nop,nop,TS val 3942828405 ecr 1886125065], length 0
05:51:14.175066 ens4  In  IP 10.10.100.8.55306 > 240.0.0.2.80: Flags [P.], seq 1:223, ack 1, win 1054, options [nop,nop,TS val 3942828405 ecr 1886125065], length 222: HTTP: GET / HTTP/1.1
05:51:14.175096 ens4  Out IP 240.0.0.2.80 > 10.10.100.8.55306: Flags [.], ack 223, win 505, options [nop,nop,TS val 1886125066 ecr 3942828405], length 0
05:51:14.239042 ens4  Out IP 240.0.0.2.80 > 10.10.100.8.55306: Flags [P.], seq 1:246, ack 223, win 505, options [nop,nop,TS val 1886125130 ecr 3942828405], length 245: HTTP: HTTP/1.1 200 OK

17. Bereinigen

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

gcloud workbench instances delete workbench-tutorial --project=$projectid --location=us-central1-a

gcloud network-security gateway-security-policies rules delete allow-nonrfc-classe \
    --gateway-security-policy=policy1 \
    --location=us-central1

gcloud network-security gateway-security-policies rules delete allow-apache2 \
    --gateway-security-policy=policy1 \
    --location=us-central1

gcloud network-security gateway-security-policies delete policy1 \
    --location=us-central1
gcloud network-services gateways delete swp1 \
    --location=us-central1

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 explicit-swp.demo.com --zone=private-dns-codelab  --type=A

gcloud dns managed-zones delete private-dns-codelab

gcloud computeinstances delete class-e-vm --project=$projectid --zone=us-central1-a --quiet
gcloud compute networks delete consumer-vpc --quiet

18. Glückwunsch

Sie haben erfolgreich eine Verbindung zwischen der Private Service Connect-Schnittstelle von Vertex AI Pipelines und Nicht-RFC-IP-Bereichen über einen sicheren Webproxy konfiguriert und validiert.

Sie haben die Infrastruktur des Nutzers erstellt und einen Netzwerkanhang hinzugefügt, der es dem Produzenten ermöglicht, eine Multi-NIC-VM 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-Netzwerk des Nutzers bereitstellen, der die Verbindung zur class-e-vm-Instanz ermöglicht, die nicht direkt von Vertex aus geroutet werden kann.

678ba30d64a76795.png

Nächste Schritte

Weitere Informationen und Videos

Referenzdokumente