Private Service Connect-Schnittstelle für 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 Nutzernetzwerk initiieren kann. Ersteller- und Nutzernetzwerke können sich in verschiedenen Projekten und Organisationen befinden.

Eine Verbindung zwischen einem Netzwerkanhang und einer Private Service Connect-Schnittstelle ähnelt der Verbindung zwischen einem Private Service Connect-Endpunkt und einem Dienstanhang. Es gibt dabei aber zwei wichtige Unterschiede:

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

Aufgaben

Vertex AI Pipelines, die in einem von Google verwalteten Mandantenprojekt bereitgestellt werden, nutzen den PSC-Netzwerkanhang, um eine Multi-NIC-Instanz zwischen dem Produzenten- und dem Nutzernetzwerk zu erstellen. Da der PSC-Netzwerkansatz mit einem Multi-NIC aus dem Nutzernetzwerk bereitgestellt wird, können Vertex AI-Pipelines Routen erreichen, die über das Nutzernetzwerk verfügbar sind.

In dieser Anleitung erstellen Sie eine umfassende PSC-Interface-Architektur (Private Service Connect) für Vertex AI Pipelines, die Cloud-Firewallregeln verwendet, um die Verbindung vom Produzenten zu den Testinstanzen des Verbrauchers zuzulassen oder zu verweigern, wie in Abbildung 1 dargestellt.

Abbildung 1

Sie erstellen einen einzelnen psc-network-attachment im Nutzer-VPC. Dies hat folgende Anwendungsfälle zur Folge:

1. Erstellen Sie eine Ingress-Firewallregel in der Consumer-VPC, die dem Vertex AI Pipeline-Subnetz (192.168.10.0/28) Zugriff auf test-svc-1 gewährt. Erfolgreichen PING bestätigen, der vom Pipeline-Job an test-svc-1 mit TCPDUMP generiert wurde
2. Erstellen Sie in der Consumer-VPC eine Ingress-Firewallregel, die dem Vertex AI Pipeline-Subnetz (192.168.10.0/28) den Zugriff auf test-svc-2 verweigert. Bestätigen Sie den PING-Fehler anhand der Firewall-Logs, die vom Log-Explorer generiert wurden.

Hinweis:In dieser Anleitung werden Konfigurations- und Validierungsschritte für die dargestellte Topologie beschrieben. Passen Sie das Verfahren nach Bedarf an die Anforderungen Ihrer Organisation an.

Aufgaben in diesem Lab

• Netzwerkanhang erstellen
• So können Sie mit Vertex AI Pipelines eine PSC-Schnittstelle mithilfe eines Netzwerk-Anhangs erstellen
• Kommunikation zwischen Produzent und Verbraucher herstellen
• Zugriff von Vertex AI Pipelines auf die VM „test-svc-1“ zulassen
• Zugriff von Vertex AI Pipelines auf die Nutzer-VM „test-svc-2“ mithilfe der Cloud-Firewall verweigern

Voraussetzungen

• Google Cloud-Projekt
• IAM-Berechtigungen
• Compute-Instanzadministrator (roles/compute.instanceAdmin)
• Compute-Netzwerkadministrator (roles/compute.networkAdmin)
• Compute-Sicherheitsadministrator (roles/compute.securityAdmin)
• Nutzer IAP-gesicherter Tunnel (roles/iap.tunnelResourceAccessor)
• Logging-Administrator (roles/logging.admin)
• Notebooks-Administrator (roles/notebooks.admin)
• Projekt-IAM-Administrator (roles/resourcemanager.projectIamAdmin)
• Kontingentadministrator (roles/servicemanagement.quotaAdmin)
• Dienstkontoadministrator (roles/iam.serviceAccountAdmin)
• Dienstkontonutzer (roles/iam.serviceAccountUser)
• Vertex AI-Administrator (roles/aiplatform.admin)

2. Hinweis

Hinweis:Netzwerkanhänge können nur gelöscht werden, wenn der Produzent (Vertex AI) die zugewiesenen Ressourcen löscht. Wenn Sie das Löschen starten möchten, müssen Sie sich an den Vertex AI-Support wenden.

In dieser Anleitung werden $-Variablen verwendet, um die Implementierung der gcloud-Konfiguration in Cloud Shell zu unterstützen.

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

Projekt für die Anleitung aktualisieren

Führen Sie in Cloud Shell folgende Schritte aus:

gcloud services enable notebooks.googleapis.com
gcloud services enable aiplatform.googleapis.com
gcloud services enable compute.googleapis.com
gcloud services enable cloudresourcemanager.googleapis.com

3. Einrichtung für Verbraucher

Nutzer-VPC erstellen

Führen Sie in Cloud Shell folgende Schritte aus:

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

Nutzersubnetze erstellen

Führen Sie in Cloud Shell folgende Schritte aus:

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

Führen Sie in Cloud Shell folgende Schritte aus:

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

Führen Sie in Cloud Shell folgende Schritte aus:

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

Cloud Router- und NAT-Konfiguration

In der Anleitung wird Cloud NAT (Network Address Translation) für den Download von Notebook-Softwarepaketen verwendet, da die Notebook-Instanz keine externe IP-Adresse hat. Cloud NAT bietet ausgehende NAT-Funktionen. Das bedeutet, dass Internethosts keine Kommunikation mit einem von Nutzern verwalteten Notebook initiieren dürfen, was die Sicherheit erhöht.

Erstellen Sie in Cloud Shell den regionalen Cloud Router.

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

Erstellen Sie in Cloud Shell das regionale Cloud NAT-Gateway.

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

Subnetz für den Private Service Connect-Netzwerkanhang erstellen

Erstellen Sie in der Cloud Shell das von Vertex AI Pipelines verwendete Subnetz für die Netzwerkverknüpfung.

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

4. Identity-Aware Proxy (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. VM-Instanzen für Nutzer erstellen

Erstellen Sie in Cloud Shell die VM-Instanz „test-svc-1“.

gcloud compute instances create test-svc-1 \
    --project=$projectid \
    --machine-type=e2-micro \
    --image-family debian-11 \
    --no-address \
    --image-project debian-cloud \
    --zone us-central1-a \
    --subnet=test-subnet-1 \
    --shielded-secure-boot

Erstellen Sie in Cloud Shell die VM-Instanz des Verbrauchers „test-svc-2“.

gcloud compute instances create test-svc-2 \
    --project=$projectid \
    --machine-type=e2-micro \
    --image-family debian-11 \
    --no-address \
    --image-project debian-cloud \
    --zone us-central1-a \
    --subnet=test-subnet-2 \
    --shielded-secure-boot

Rufen Sie die IP-Adressen der Instanzen ab und speichern Sie sie:

Führen Sie in Cloud Shell einen Befehl zum Beschreiben der Test-VM-Instanzen aus.

gcloud compute instances describe test-svc-1 --zone=us-central1-a | grep  networkIP:

gcloud compute instances describe test-svc-2 --zone=us-central1-a | grep  networkIP:

Beispiel:

user@cloudshell(psc-vertex)$ gcloud compute instances describe test-svc-1 --zone=us-central1-a | grep  networkIP:

gcloud compute instances describe test-svc-2 --zone=us-central1-a | grep  networkIP:
  networkIP: 192.168.20.2
  networkIP: 192.168.30.2

6. Private Service Connect-Netzwerkanhang

Netzwerkanhänge sind regionale Ressourcen, die die Nutzerseite einer Private Service Connect-Schnittstelle darstellen. Sie ordnen einem Netzwerkanhang ein einzelnes Subnetz zu und der Ersteller (Vertex AI Pipelines) weist der Private Service Connect-Schnittstelle IP-Adressen zu.

Netzwerkanhang erstellen

Erstellen Sie in Cloud Shell den Netzwerkanhang.

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

Netzwerkanhänge auflisten

Listen Sie in Cloud Shell die Netzwerkverbindung auf.

gcloud compute network-attachments list

Netzwerkanhänge beschreiben

Beschreiben Sie in Cloud Shell den Netzwerkanschluss.

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

Notieren Sie sich den URI des PSC-Netzwerk-Anhangs, der vom Ersteller beim Erstellen der Private Service Connect-Schnittstelle verwendet wird.

Im folgenden Beispiel lautet der URI der PSC-Netzwerkanhänge:

projects/psc-vertex/regions/us-central1/networkAttachments/psc-network-attachment

user@cloudshell$ gcloud compute network-attachments describe psc-network-attachment --region=us-central1
connectionPreference: ACCEPT_MANUAL
creationTimestamp: '2025-01-21T12:25:25.385-08:00'
fingerprint: m9bHc9qnosY=
id: '56224423547354202'
kind: compute#networkAttachment
name: psc-network-attachment
network: https://www.googleapis.com/compute/v1/projects/psc-vertex/global/networks/consumer-vpc
region: https://www.googleapis.com/compute/v1/projects/psc-vertex/regions/us-central1
selfLink: https://www.googleapis.com/compute/v1/projects/psc-vertex/regions/us-central1/networkAttachments/psc-network-attachment
subnetworks:
- https://www.googleapis.com/compute/v1/projects/psc-vertex/regions/us-central1/subnetworks/intf-subnet

7. Vertex AI Workbench einrichten

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

Nutzerverwaltetes Dienstkonto erstellen

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

In dieser Anleitung werden dem Dienstkonto die folgenden Rollen zugewiesen:

• Storage-Administrator
• Vertex AI-Nutzer
• Artifact Registry-Administrator

Erstellen Sie in Cloud Shell das Dienstkonto.

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

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

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

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

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

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

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

Erlauben Sie in Cloud Shell dem Notebook-Dienstkonto, das Compute Engine-Standarddienstkonto zum Instanziieren des Pipeline-Jobs zu verwenden.

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

Vertex AI Workbench-Instanz erstellen

Erstellen Sie im folgenden Abschnitt eine Vertex AI Workbench-Instanz, die das zuvor erstellte Dienstkonto „notebook-sa“ enthält.

Erstellen Sie in Cloud Shell die Instanz des privaten Clients.

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

8. Vertex AI Pipelines für die Verbindung zu test-svc-1

Öffnen Sie einen neuen Cloud Shell-Tab und aktualisieren Sie die Projekteinstellungen.

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

Wenn Sie eine Verbindung von Vertex AI-Pipelines zu „test-svc-1“ zulassen möchten, erstellen Sie eine Firewallregel für eingehenden Traffic, in der die PSC-Netzwerkverbindung als Quelle (192.168.10.0/28) und die IP-Adresse „test-svc-1“ als Ziel angegeben ist.

Aktualisieren Sie in Cloud Shell den Zielbereich so, dass er mit der IP-Adresse von „test-svc-1“ übereinstimmt.

gcloud compute --project=$projectid firewall-rules create allow-icmp-vertex-pipelines-to-test-svc1-vm --direction=INGRESS --priority=1000 --network=consumer-vpc --action=ALLOW  --source-ranges=192.168.10.0/28 --destination-ranges=<your-test-svc-1-vm-ip> --rules=icmp

Beispiel:

gcloud compute --project=$projectid firewall-rules create allow-icmp-vertex-pipelines-to-test-svc1-vm --direction=INGRESS --priority=1000 --network=consumer-vpc --action=ALLOW  --source-ranges=192.168.10.0/28 --destination-ranges=192.168.20.2 --rules=icmp

Melden Sie sich in Cloud Shell mit IAP in der Instanz „test-svc-1“ an.

gcloud compute ssh test-svc-1 --project=$projectid --zone=us-central1-a --tunnel-through-iap

Führen Sie unter dem Betriebssystem „tcpdump“ aus, um ICMP-Traffic zu erfassen. Diese Betriebssystemsitzung wird verwendet, um die Kommunikation zwischen Vertex AI Pipeline und der VM zu validieren.

sudo tcpdump -i any icmp -nn

9. Aktualisierung des Vertex AI-Dienst-Agents

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

Hinweis:Bevor Sie die Berechtigungen für den Dienst-Agenten aktualisieren, rufen Sie in der Cloud Console Vertex AI auf, um sicherzustellen, dass die Vertex AI API aktiviert ist.

service-$[e-mail]

Rufen Sie in Cloud Shell Ihre Projektnummer ab.

gcloud projects describe $projectid | grep projectNumber

Beispiel:

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

Aktualisieren Sie in Cloud Shell das Konto des Servicemitarbeiters mit der Rolle „compute.networkAdmin“.

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

Beispiel:

gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:[e-mail]" --role="roles/compute.networkAdmin"

10. 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:<your-projectnumber>[e-mail]" \
    --role="roles/aiplatform.user"

Beispiel:

gcloud projects add-iam-policy-binding $projectid \
  --member="serviceAccount:[e-mail]" \
    --role="roles/aiplatform.user"

11. Vertex AI Pipelines-Job bereitstellen

Im folgenden Abschnitt erstellen Sie ein Notebook, um einen erfolgreichen PING an die Instanz „test-svc-1“ auszuführen.

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 Ihrer 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.
5. Führen Sie in einer neuen Notebookzelle den folgenden Befehl aus, um sicherzustellen, dass Sie die neueste Version von pip verwenden:

! pip3 install --upgrade --quiet google-cloud-aiplatform \
  kfp \
  google-cloud-pipeline-components

6. Projektvariablen in der neuen Notebookzelle festlegen

PROJECT_ID = "<your-projectid>" 
REGION = "<your-region>"  
NETWORK_ATTACHMENT_NAME = "psc-network-attachment"

Beispiel:

PROJECT_ID = "psc-vertex" 
REGION = "us-central1"  
NETWORK_ATTACHMENT_NAME = "psc-network-attachment"

7. Einen global eindeutigen Bucket-Namen als Variable in einer neuen Notebookzelle definieren

BUCKET_URI = f"gs://<your-bucket-name>"

Beispiel:

BUCKET_URI = f"gs://psc-vertex-bucket"

8. Erstellen Sie in einer neuen Notebookzelle den Bucket.

! gsutil mb -l {REGION} -p {PROJECT_ID} {BUCKET_URI}

Im folgenden Abschnitt legen Sie das Standarddienstkonto für die Compute Engine fest, das zum Ausführen des Pipeline-Jobs verwendet werden soll, und gewähren ihm die richtigen Berechtigungen.

shell_output = ! gcloud projects describe $PROJECT_ID
PROJECT_NUMBER = shell_output[-1].split(":")[1].strip().replace("'", "")
SERVICE_ACCOUNT = f"{PROJECT_NUMBER}[e-mail]"

print(f"Project Number: {PROJECT_NUMBER}")
print(f"Service Account: {SERVICE_ACCOUNT}")

Als Bestätigung für die erfolgreiche Ausführung werden Ihr Dienstkonto und Ihre Projektnummer gedruckt.

9. Gewähren Sie Ihrem Dienstkonto in einer neuen Notizzellen die Berechtigung zum Lesen und Schreiben von Pipelineartefakten im im vorherigen Schritt erstellten Bucket.

! gsutil iam ch serviceAccount:{SERVICE_ACCOUNT}:roles/storage.objectCreator {BUCKET_URI}

! gsutil iam ch serviceAccount:{SERVICE_ACCOUNT}:roles/storage.objectViewer {BUCKET_URI}

10. Definieren Sie in einer neuen Notebook-Zelle die Pipelineparameter. Hinweis: NETWORK_ATTACHMENT_NAME ist der Netzwerk-Anhang des PSC und muss daher übereinstimmen.

PIPELINE_ROOT = f"{BUCKET_URI}/pipeline_root/psc_test"
NETWORK_ATTACHMENT_URI = f"projects/{PROJECT_NUMBER}/regions/{REGION}/networkAttachments/{NETWORK_ATTACHMENT_NAME}"

11. Vertex AI SDK in einer neuen Notebookzelle initialisieren

from kfp import dsl
from google.cloud import aiplatform, aiplatform_v1beta1
import time
from google.cloud.aiplatform_v1.types import pipeline_state
import yaml
from datetime import datetime
import logging
aiplatform.init(project=PROJECT_ID, location=REGION, staging_bucket=BUCKET_URI)

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

12. Definieren Sie in einer neuen Notebook-Zelle die Testkomponente.

@dsl.container_component
def ping_check(network_address: str):
    """Pings a network address

    Args:
        network_address: The IP address to ping
    """

    return dsl.ContainerSpec(
        image="ubuntu:22.04",
        command=["sh", "-c"],
        args=[
            f"""
            
            # Use sed for regex replacement, cleaner than bash parameter expansion for this
            cleaned_address=$(echo "{network_address}" | sed 's/[^0-9.]//g')
            apt-get update && apt-get install inetutils-traceroute inetutils-ping -y
            
            echo "Will ping $cleaned_address"
            if ! ping -c 3 $cleaned_address; then
                echo "Ping failed"
                traceroute -w 1 -m 7 $cleaned_address
                exit 1
            fi
            """
        ],
    )

13. Definieren Sie die Pipeline in einer neuen Notebookzelle.

@dsl.pipeline(name="check-connectivity")
def pipeline(ip_address: str):
    """Pings an IP address. Facilitated by a Private Service Connect Interface

    Args:
        ip_address: The IP address to ping
    """
    ping_check(network_address=ip_address).set_caching_options(False)
    return

14. Führen Sie die Dienstprogrammfunktion in einer neuen Notebookzelle aus und warten Sie, bis die Pipeline abgeschlossen ist.

def wait_for_pipeline(
    project_id: str,
    region: str,
    pipeline_job_resource_name: str,
    timeout: int = 20 * 60,  # Default timeout of 20 minutes (in seconds)
) -> bool:
    """
    Waits for a Vertex AI pipeline to finish, with a timeout.

    Args:
        project_id (str): The Google Cloud project ID.
        region (str): The region where the pipeline is running.
        pipeline_job_resource_name (str): The resource name of the pipeline job.
        timeout (int): The maximum time to wait for the pipeline to finish, in seconds.
                       Defaults to 20 minutes (1200 seconds).

    Returns:
        bool: True if the pipeline succeeded, False otherwise.

    Raises:
        TimeoutError: If the pipeline does not finish within the specified timeout.
    """

    # Initialize the AIPlatform client
    aiplatform.init(project=project_id, location=region)

    # Get the pipeline job
    pipeline_job = aiplatform.PipelineJob.get(resource_name=pipeline_job_resource_name)
    logging.info(
        f"Vertex AI Console Link: https://console.cloud.google.com/vertex-ai/pipelines/locations/{region}/runs/{pipeline_job.resource_name.split('/')[-1]}?project={project_id}"
    )

    start_time = time.time()
    while True:
        status = pipeline_job.state
        logging.info(f"Pipeline Job status: {status.name}")

        if status in [
            pipeline_state.PipelineState.PIPELINE_STATE_SUCCEEDED,
            pipeline_state.PipelineState.PIPELINE_STATE_FAILED,
            pipeline_state.PipelineState.PIPELINE_STATE_CANCELLED,
        ]:
            break  # Exit the loop if the job is finished

        if time.time() - start_time > timeout:
            logging.error(f"Pipeline timed out after {timeout} seconds.")
            raise TimeoutError(f"Pipeline timed out after {timeout} seconds.")
        
        # Wait for a short time before checking again
        time.sleep(10)  # Adjust the wait time as needed

    # Do something based on the final status
    if status == pipeline_state.PipelineState.PIPELINE_STATE_SUCCEEDED:
        logging.info("Pipeline succeeded")
        return True
    elif status == pipeline_state.PipelineState.PIPELINE_STATE_CANCELLED:
        logging.error("Pipeline cancelled")
        raise Exception("Pipeline cancelled")
    elif status == pipeline_state.PipelineState.PIPELINE_STATE_FAILED:
        logging.error("Pipeline failed")
        raise Exception("Pipeline failed")

15. Führen Sie in einer neuen Notebookzelle die Dienstprogrammfunktion aus, um die Pipeline auszuführen.

def run_job_with_psc_interface_config(
    project_id: str,
    region: str,
    pipeline_root: str,
    network_attachment_name: str,
    ip_address: str,
    local_pipeline_file: str = "pipeline.yaml",
):
    """
    Compiles, submits, and monitors a Vertex AI pipeline.
    """

    parameter_values = {"ip_address": ip_address}
    pipeline_root = f"{pipeline_root}/{datetime.now().strftime('%Y%m%d%H%M%S')}"
    logging.info("Compiling pipeline")

    try:
        with open(local_pipeline_file, "r") as stream:
            pipeline_spec = yaml.safe_load(stream)
            logging.info(f"Pipeline Spec: {pipeline_spec}")
    except yaml.YAMLError as exc:
        logging.error(f"Error loading pipeline yaml file: {exc}")
        raise
    
    logging.info(f"Will use pipeline root: {pipeline_root}")
    # Initialize the Vertex SDK using PROJECT_ID and LOCATION
    aiplatform.init(project=project_id, location=region)

    # Create the API endpoint
    client_options = {"api_endpoint": f"{region}-aiplatform.googleapis.com"}

    # Initialize the PipelineServiceClient
    client = aiplatform_v1beta1.PipelineServiceClient(client_options=client_options)

    # Construct the request
    request = aiplatform_v1beta1.CreatePipelineJobRequest(
        parent=f"projects/{project_id}/locations/{region}",
        pipeline_job=aiplatform_v1beta1.PipelineJob(
            display_name="pipeline-with-psc-interface-config",
            pipeline_spec=pipeline_spec,
            runtime_config=aiplatform_v1beta1.PipelineJob.RuntimeConfig(
                gcs_output_directory=pipeline_root, parameter_values=parameter_values
            ),
            psc_interface_config=aiplatform_v1beta1.PscInterfaceConfig(
                network_attachment=network_attachment_name
            ),
        ),
    )

    # Make the API call
    response = client.create_pipeline_job(request=request)

    # Print the response
    logging.info(f"Pipeline job created: {response.name}")

    return response.name

16. Pipeline in einer neuen Notebookzelle kompilieren

from kfp import compiler
compiler.Compiler().compile(pipeline_func=pipeline, package_path='pipeline.yaml')

17. Aktualisieren Sie in einer neuen Notebookzelle TARGET_IP_ADDRESS mit der IP-Adresse, die Sie im vorherigen Schritt für test-svc-1 ermittelt haben, und beobachten Sie den Status des Pipeline-Jobs.

TARGET_IP_ADDRESS = "<your-test-svc-1-ip>"
try:
    job_name = run_job_with_psc_interface_config(
        project_id=PROJECT_ID,
        region=REGION,
        pipeline_root=PIPELINE_ROOT,
        network_attachment_name=NETWORK_ATTACHMENT_URI,
        ip_address=TARGET_IP_ADDRESS,
    )
    wait_for_pipeline(
        project_id=PROJECT_ID,
        region=REGION,
        pipeline_job_resource_name=job_name,
    )
except Exception as e:
    logging.error(f"An error occurred: {e}")

Beispiel:

TARGET_IP_ADDRESS = "192.168.20.2"
try:
    job_name = run_job_with_psc_interface_config(
        project_id=PROJECT_ID,
        region=REGION,
        pipeline_root=PIPELINE_ROOT,
        network_attachment_name=NETWORK_ATTACHMENT_URI,
        ip_address=TARGET_IP_ADDRESS,
    )
    wait_for_pipeline(
        project_id=PROJECT_ID,
        region=REGION,
        pipeline_job_resource_name=job_name,
    )
except Exception as e:
    logging.error(f"An error occurred: {e}")

Nach Ausführung von Schritt 17 dauert es etwa 8 Minuten, bis die Pipeline abgeschlossen ist.

12. Konnektivität zu test-svc-1 prüfen

Beobachten Sie in der Zelle, die für die Ausführung von Schritt 17 verwendet wurde, den Übergang des Pipelinejob-Status von PIPELINE_STATE_PENDING zu PIPELINE_STATE_RUNNING und schließlich zu PIPELINE_STATE_SUCCEEDED. Dies weist auf einen erfolgreichen Ping von Vertex AI Pipelines und eine Antwort von test-svc-1 hin.

Um den ICMP-Traffic zwischen der Vertex AI-Pipeline und test-svc-1 zu validieren, rufen Sie die zuvor generierte tcpdump-Sitzung auf, die im Betriebssystem von test-svc-1 ausgeführt wurde und Protokolle mit bidirektionalem Traffic enthält.

Im Beispiel mit tcpdump hat Vertex AI Pipelines die IP-Adresse 192.168.10.3 aus dem Subnetz 192.168.10.0/28 abgerufen. 192.168.20.2 ist die IP-Adresse von „test-svc-1“. Hinweis: In Ihrer Umgebung können die IP-Adressen abweichen.

user@test-svc-1:~$ sudo tcpdump -i any icmp -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
18:57:54.737490 ens4  In  IP 192.168.10.3 > 192.168.20.2: ICMP echo request, id 257, seq 0, length 64
18:57:54.737523 ens4  Out IP 192.168.20.2 > 192.168.10.3: ICMP echo reply, id 257, seq 0, length 64

13. Vertex AI Pipelines-KI-Verbindung zu test-svc-2

Im folgenden Abschnitt erstellen Sie eine Firewallregel für den Eingang, um Traffic vom Vertex AI Pipelines-Subnetz (192.168.10.0/28) an test-svc-2 zu verweigern. Anschließend aktualisieren Sie das Notebook, um die IP-Adresse von test-svc-2 widerzuspiegeln, und führen dann die Ausführung der Pipelines-Jobs aus.

In der Notebook-Zelle wird im Pipeline-Job-Status „Error – Pipeline Failed“ (Fehler – Pipeline fehlgeschlagen) angezeigt. Außerdem liefern Firewall-Protokolle Informationen zur fehlgeschlagenen Verbindung.

Firewallregel für eingehenden Traffic erstellen

Wenn Sie die Verbindung von Vertex AI-Pipelines zu „test-svc-2“ verweigern möchten, erstellen Sie eine Firewallregel für eingehenden Traffic, in der die PSC-Netzwerkverbindung als Quelle (192.168.10.0/28) und die IP-Adresse von „test-svc-2“ als Ziel angegeben ist.

Aktualisieren Sie in Cloud Shell den Zielbereich so, dass er mit der IP-Adresse von „test-svc-2“ übereinstimmt.

gcloud compute --project=$projectid firewall-rules create deny-icmp-vertex-pipelines-to-test-svc2-vm --direction=INGRESS --priority=1000 --network=consumer-vpc --action=DENY  --source-ranges=192.168.10.0/28 --rules=ALL --destination-ranges=<your-test-svc-2-vm-ip> --rules=icmp --enable-logging

Beispiel:

gcloud compute --project=$projectid firewall-rules create deny-icmp-vertex-pipelines-to-test-svc2-vm --direction=INGRESS --priority=1000 --network=consumer-vpc --action=DENY  --source-ranges=192.168.10.0/28 --rules=ALL --destination-ranges=192.168.30.2 --enable-logging

Pipelinejob aus Notebookzelle ausführen

Aktualisieren Sie in einer neuen Notebookzelle TARGET_IP_ADDRESS mit der IP-Adresse, die Sie im vorherigen Schritt für test-svc-2 ermittelt haben, und beobachten Sie den Jobstatus der Pipelines.

TARGET_IP_ADDRESS = "<your-test-svc-2-ip>"
try:
    job_name = run_job_with_psc_interface_config(
        project_id=PROJECT_ID,
        region=REGION,
        pipeline_root=PIPELINE_ROOT,
        network_attachment_name=NETWORK_ATTACHMENT_URI,
        ip_address=TARGET_IP_ADDRESS,
    )
    wait_for_pipeline(
        project_id=PROJECT_ID,
        region=REGION,
        pipeline_job_resource_name=job_name,
    )
except Exception as e:
    logging.error(f"An error occurred: {e}")

Beispiel:

TARGET_IP_ADDRESS = "192.168.30.2"
try:
    job_name = run_job_with_psc_interface_config(
        project_id=PROJECT_ID,
        region=REGION,
        pipeline_root=PIPELINE_ROOT,
        network_attachment_name=NETWORK_ATTACHMENT_URI,
        ip_address=TARGET_IP_ADDRESS,
    )
    wait_for_pipeline(
        project_id=PROJECT_ID,
        region=REGION,
        pipeline_job_resource_name=job_name,
    )
except Exception as e:
    logging.error(f"An error occurred: {e}")

Nach der Ausführung dauert es etwa 8 Minuten, bis der Pipeline-Job abgeschlossen ist.

14. Fehlgeschlagene Verbindung zu test-svc-2 prüfen

In der Zelle, in der der Pipelines-Job ausgeführt wurde, sehen Sie den Statusübergang von PIPELINE_STATE_PENDING zu PIPELINE_STATE_FAILED, was auf einen fehlgeschlagenen Ping von Vertex AI Pipelines und eine Antwort von test-svc-2 hinweist.

Mit dem Log Explorer können Sie Firewall-Protokolleinträge aufrufen, die der Ingress-Deaktivierungsregel entsprechen, die aus dem Vertex AI Pipelines-Subnetz (192.168.10.0/28) und der IP-Adresse „test-svc-2“ besteht.

Wählen Sie „Abfrage anzeigen“ aus und fügen Sie den Filter unten ein: „Letzte 15 Minuten“ gefolgt von „Abfrage ausführen“.

jsonPayload.rule_details.reference:("network:consumer-vpc/firewall:deny-icmp-vertex-pipelines-to-test-svc2-vm")

Hinweis:Wenn keine Protokolle generiert werden, aktualisieren Sie den Webbrowser und führen Sie dann „Abfrage ausführen“ mit dem angegebenen Filter und Zeitintervall aus.

Wählen Sie einen Logeintrag aus und maximieren Sie dann die verschachtelten Felder, um Informationen zu sehen, die aus der Vertex AI Pipelines- und der Test-svc-2-IP-Adresse bestehen, die die abgelehnte Firewallregel für den Eingang bestätigen.

15. Bereinigen

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

gcloud compute instances delete test-svc-1 test-svc-2 --zone=us-central1-a --quiet

gcloud workbench instances delete workbench-tutorial --location=us-central1-a --quiet

gcloud compute firewall-rules delete deny-icmp-vertex-pipelines-to-test-svc2-vm allow-icmp-vertex-pipelines-to-test-svc1-vm ssh-iap-consumer --quiet

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

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

16. Glückwunsch

Sie haben eine Private Service Connect-Schnittstelle und die Nutzer- und Erstellerverbindung erfolgreich konfiguriert und validiert, indem Sie eine Firewall für den eingehenden Traffic implementiert haben.

Sie haben die Nutzerinfrastruktur erstellt und einen Netzwerkanhang hinzugefügt, mit dem der Vertex AI Pipelines-Dienst eine PSC-Interface-VM erstellen konnte, um die Kommunikation zwischen Nutzer und Ersteller zu ermöglichen. Sie haben gelernt, wie Sie Firewallregeln im VPC-Netzwerk des Nutzers erstellen, die die Verbindung zu den Instanzen im Nutzernetzwerk zulassen und verweigern.

Cosmopup findet Tutorials super!

Was liegt als Nächstes an?

Weitere Lesematerialien und Videos

• Private Service Connect – Übersicht

Referenzdokumente

• Private Service Connect-Oberfläche für eine Pipeline konfigurieren | Vertex AI | Google Cloud
• Private Service Connect-Schnittstelle für Vertex AI-Ressourcen einrichten | Google Cloud