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 Nutzer-VPC-Netzwerk 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, 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.

Aufgaben

Vertex AI Pipelines, die in einem von Google verwalteten Mandantenprojekt bereitgestellt werden, nutzen den PSC-Netzwerkanhang, um eine Instanz mit mehreren NICs zwischen dem Produzenten- und dem Nutzernetzwerk zu erstellen. Da der PSC-Netzwerk-Anhang mit mehreren NICs aus dem Nutzer-Netzwerk bereitgestellt wird, kann Vertex AI Pipelines Routen erreichen, die im Nutzer-Netzwerk verfügbar sind.

In dieser Anleitung erstellen Sie eine umfassende PSC-Schnittstellenarchitektur (Private Service Connect) für Vertex AI Pipelines, in der Cloud Firewall-Regeln verwendet werden, um die Verbindung vom Producer zu den Testinstanzen des Consumers zuzulassen oder zu verweigern, wie in Abbildung 1 dargestellt.

Abbildung 1

12714b6f0f8fa411.png

Sie erstellen einen einzelnen psc-network-attachment in der Consumer-VPC, was zu den folgenden Anwendungsfällen führt:

  1. Erstellen Sie im consumer-vpc eine Firewallregel für eingehenden Traffic, die das Vertex AI Pipelines-Subnetz (192.168.10.0/28) für test-svc-1 zulässt. Bestätigen Sie, dass der PING vom Pipeline-Job an test-svc-1 mit TCPDUMP erfolgreich generiert wurde.
  2. Erstellen Sie eine Firewallregel für eingehenden Traffic in der Consumer-VPC, die das Vertex AI Pipelines-Subnetz (192.168.10.0/28) für test-svc-2 ablehnt. Bestätigen Sie den PING-Fehler anhand der Firewall-Logs, die vom Log-Explorer generiert wurden.

Lerninhalte

  • Netzwerkanhang erstellen
  • So kann Vertex AI Pipelines eine Netzwerkverbindung verwenden, um eine PSC-Schnittstelle zu erstellen
  • Kommunikation vom Ersteller zum Nutzer herstellen
  • Zugriff von Vertex AI Pipelines auf die Consumer-VM „test-svc-1“ zulassen
  • Zugriff von Vertex AI Pipelines auf die Consumer-VM „test-svc-2“ mit Cloud Firewall verweigern

Voraussetzungen

2. Hinweis

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

Projekt für das Tutorial 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 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 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

Cloud NAT (Network Address Translation) wird im Tutorial für das Herunterladen von Notebook-Softwarepaketen verwendet, da die Notebook-Instanz keine externe IP-Adresse hat. Cloud NAT bietet NAT-Funktionen für ausgehenden Traffic. Das bedeutet, dass Internet-Hosts keine Kommunikation mit einem vom Nutzer 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 Cloud Shell das von Vertex AI Pipelines verwendete Network Attachment-Subnetz.

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. Consumer-VM-Instanzen erstellen

Erstellen Sie in Cloud Shell die Consumer-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 Consumer-VM-Instanz „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 „describe“-Befehl für die 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 verknüpfen ein einzelnes Subnetz mit einem Netzwerkanhang und der Ersteller (Vertex AI Pipelines) weist der Private Service Connect-Schnittstelle IP-Adressen zu.

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

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 URI des PSC-Netzwerk-Anhangs, der vom Dienstersteller beim Erstellen der Private Service Connect-Schnittstelle verwendet wird.

Im folgenden Beispiel lautet der URI für die PSC-Netzwerkverbindung so:

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 wird beschrieben, wie Sie ein Jupyter-Notebook erstellen. Mit 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 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"

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)')-compute@developer.gserviceaccount.com \
    --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, 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=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-Konnektivität zu test-svc-1

Öffnen Sie einen neuen Tab in Cloud Shell 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 Verbindungen 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 von test-svc-1 als Ziel angegeben wird.

Aktualisieren Sie in Cloud Shell den Zielbereich, sodass 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 bei der Instanz „test-svc-1“ an.

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

Führen Sie im 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 für die PSC-Netzwerkverbindung, das zum Erstellen der PSC-Schnittstelle verwendet wird. Dazu verwendet Vertex AI Pipelines einen Dienst-Agent (siehe unten), der die Berechtigung Netzwerkadministrator benötigt.

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

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 Dienstkonto des Dienst-Agents 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:service-795057945528@gcp-sa-aiplatform.iam.gserviceaccount.com" --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>-compute@developer.gserviceaccount.com" \
    --role="roles/aiplatform.user"

Beispiel:

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

11. Vertex AI Pipelines-Job bereitstellen

Im folgenden Abschnitt erstellen Sie ein Notebook, um einen erfolgreichen PING an die Instanz „consumer-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 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.
  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
  1. 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"
  1. Definieren Sie einen global eindeutigen Bucket-Namen als Variable in einer neuen Notebook-Zelle.
BUCKET_URI = f"gs://<your-bucket-name>"

Beispiel:

BUCKET_URI = f"gs://psc-vertex-bucket"
  1. Erstellen Sie den Bucket in einer neuen Notebookzelle.
! gsutil mb -l {REGION} -p {PROJECT_ID} {BUCKET_URI}

Im folgenden Abschnitt legen Sie das Compute Engine-Standarddienstkonto fest, das zum Ausführen des Pipelinejobs verwendet werden soll, und erteilen 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}-compute@developer.gserviceaccount.com"

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

Zur Bestätigung der erfolgreichen Ausführung werden Ihr Dienstkonto und Ihre Projektnummer ausgedruckt.

  1. Gewähren Sie in einer neuen Notebook-Zelle Ihrem Dienstkonto die Berechtigung zum Lesen und Schreiben von Pipelineartefakten in dem 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}
  1. Definieren Sie die Pipelineparameter in einer neuen Notebook-Zelle. Der NETWORK_ATTACHMENT_NAME ist der PSC-Netzwerk-Anhang 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}"
  1. Initialisieren Sie das Vertex AI SDK in einer neuen Notebook-Zelle.
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')
  1. Definieren Sie die Testkomponente in einer neuen Notebook-Zelle.
@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
            """
        ],
    )
  1. 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
  1. Führen Sie die Hilfsfunktion 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")
  1. Führen Sie die Hilfsfunktion in einer neuen Notebookzelle 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
  1. Kompilieren Sie die Pipeline in einer neuen Notebookzelle.
from kfp import compiler
compiler.Compiler().compile(pipeline_func=pipeline, package_path='pipeline.yaml')
  1. Aktualisieren Sie in einer neuen Notebook-Zelle TARGET_IP_ADDRESS mit der IP-Adresse, die Sie im vorherigen Schritt für test-svc-1 erhalten haben, und beobachten Sie den Status des Pipelinejobs.
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 zum Ausführen von Schritt 17 verwendet wird, den Übergang des Pipelinejobstatus 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 Vertex AI Pipeline und test-svc-1 zu validieren, sehen Sie sich die zuvor generierte tcpdump-Sitzung an, die im Betriebssystem von test-svc-1 ausgeführt wurde und Protokolle mit bidirektionalem Traffic enthält.

Im tcpdump-Beispiel hat Vertex AI Pipelines die IP-Adresse 192.168.10.3 aus dem Subnetz 192.168.10.0/28 bezogen. 192.168.20.2 ist die IP-Adresse von test-svc-1. Die IP-Adressen können in Ihrer Umgebung 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 eingehenden Traffic, um Traffic aus dem Vertex AI Pipelines-Subnetz (192.168.10.0/28) für test-svc-2 zu verweigern. Anschließend aktualisieren Sie das Notebook, um die IP-Adresse von test-svc-2 zu berücksichtigen, und führen schließlich die Pipeline-Jobs aus.

In der Notebook-Zelle wird der Pipeline-Jobstatus „Error – Pipeline Failed“ (Fehler – Pipeline fehlgeschlagen) angezeigt. Außerdem enthalten die Firewall-Logs Informationen zur fehlgeschlagenen Verbindung.

Firewallregel zum Ablehnen von eingehendem Traffic erstellen

Wenn Sie die Konnektivität von Vertex AI Pipelines zu test-svc-2 ablehnen 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, sodass 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 über Notebook-Zelle ausführen

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

TARGET_IP_ADDRESS = &<quot;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 Pipelinejob abgeschlossen ist.

14. Fehler bei der Validierung der Verbindung zu test-svc-2

Beachten Sie in der Zelle, die zum Ausführen des Pipelines-Jobs verwendet wird, den Statusübergang von PIPELINE_STATE_PENDING zu PIPELINE_STATE_FAILED. Dies weist auf einen fehlgeschlagenen Ping von Vertex AI Pipelines und eine fehlgeschlagene Antwort von test-svc-2 hin.

Mit Log Explorer können Sie Firewall-Logging-Einträge ansehen, die der Ingress Deny-Regel entsprechen, die aus dem Vertex AI Pipelines-Subnetz (192.168.10.0/28) und der IP-Adresse von test-svc-2 besteht.

Wählen Sie „Abfrage anzeigen“ aus und fügen Sie den folgenden Filter ein. Klicken Sie dann auf „Abfrage ausführen“.

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

20e072f26d9a113b.png

5fb3d2de0a85e3c6.png

Wählen Sie einen Logeintrag aus und maximieren Sie dann die verschachtelten Felder, um Informationselemente mit der IP-Adresse von Vertex AI Pipelines und test-svc-2 aufzurufen, die die abgelehnte Firewallregel für eingehenden Traffic bestätigen.

903aaf2c10d07460.png

15. Bereinigen

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

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 sowie die Verbindung zwischen Nutzer und Ersteller erfolgreich konfiguriert und validiert, indem Sie Firewallregeln zum Zulassen und Ablehnen von eingehendem Traffic implementiert haben.

Sie haben die Nutzerinfrastruktur erstellt und einen Netzwerkanhang hinzugefügt, mit dem der Vertex AI Pipelines-Dienst eine PSC-Schnittstellen-VM erstellen kann, um die Kommunikation zwischen Nutzer und Ersteller zu ermöglichen. Sie haben gelernt, wie Sie Firewallregeln im VPC-Netzwerk des Nutzers erstellen, mit denen Verbindungen zu den Instanzen im Netzwerk des Nutzers zugelassen und abgelehnt werden.

Cosmopup findet Tutorials toll!!

c911c127bffdee57.jpeg

Nächste Schritte

Weitere Informationen und Videos

Referenzdokumente