Interfaccia Private Service Connect per le pipeline Vertex AI

1. Introduzione

Un'interfaccia Private Service Connect è una risorsa che consente a una rete Virtual Private Cloud (VPC) producer di avviare connessioni a varie destinazioni in una rete consumer. Le reti producer e consumer possono trovarsi in progetti e organizzazioni diversi.

Una connessione tra un collegamento di rete e un'interfaccia Private Service Connect è simile alla connessione tra un endpoint Private Service Connect e un collegamento al servizio, ma presenta due differenze fondamentali:

Un collegamento di rete consente a una rete producer di avviare connessioni a una rete consumer (uscita del servizio gestito), mentre un endpoint consente a una rete consumer di avviare connessioni a una rete producer (ingresso del servizio gestito).
Una connessione di interfaccia Private Service Connect è transitiva. Ciò significa che una rete producer può comunicare con altre reti connesse alla rete consumer.

Cosa creerai

Vertex AI Pipelines, di cui è stato eseguito il deployment in un progetto tenant gestito da Google, sfrutterà l'allegato di rete PSC per creare un'istanza multi-NIC tra la rete producer e consumer. Poiché il collegamento di rete PSC viene implementato con una scheda di rete multipla dalla rete consumer, Vertex AI Pipelines può raggiungere le route disponibili dalla rete consumer.

In questo tutorial, creerai un'architettura di interfaccia Private Service Connect (PSC) completa per Vertex AI Pipelines che utilizza le regole firewall Cloud per consentire o negare la connettività dal producer alle istanze di test del consumer, come illustrato nella Figura 1.

Figura 1

Creerai un singolo psc-network-attachment nel VPC consumer, il che comporterà i seguenti casi d'uso:

Crea una regola firewall in entrata in consumer-vpc che consenta alla subnet di Vertex AI Pipeline (192.168.10.0/28) di accedere a test-svc-1. Conferma la generazione di PING riuscita dal job della pipeline a test-svc-1 utilizzando TCPDUMP
Crea una regola firewall in entrata in consumer-vpc che nega alla subnet della pipeline Vertex AI (192.168.10.0/28) l'accesso a test-svc-2. Conferma l'errore PING in base ai log del firewall generati da Esplora log.

Cosa imparerai a fare

Come creare un collegamento di rete
In che modo Vertex AI Pipelines può utilizzare un collegamento di rete per creare un'interfaccia PSC
Come stabilire la comunicazione dal produttore al consumatore
Come consentire l'accesso da Vertex AI Pipelines alla VM consumer test-svc-1
Come negare l'accesso da Vertex AI Pipelines alla VM consumer, test-svc-2, utilizzando Cloud Firewall

Che cosa ti serve

Progetto Google Cloud
Autorizzazioni IAM
Compute Instance Admin (roles/compute.instanceAdmin)
Compute Network Admin (roles/compute.networkAdmin)
Compute Security Admin (roles/compute.securityAdmin)
Utente del tunnel con protezione IAP (roles/iap.tunnelResourceAccessor)
Amministratore logging (roles/logging.admin)
Amministratore Notebooks (roles/notebooks.admin)
Amministratore IAM progetto (roles/resourcemanager.projectIamAdmin)
Amministratore quota (roles/servicemanagement.quotaAdmin)
Amministratore service account (roles/iam.serviceAccountAdmin)
Service Account User (roles/iam.serviceAccountUser)
Vertex AI Admin (roles/aiplatform.admin)

2. Prima di iniziare

Questo tutorial utilizza le variabili $per facilitare l'implementazione della configurazione di gcloud in Cloud Shell.

In Cloud Shell, esegui le seguenti operazioni:

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

Aggiornare il progetto per supportare il tutorial

In Cloud Shell, esegui le seguenti operazioni:

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. Configurazione consumatore

Crea il VPC consumer

In Cloud Shell, esegui le seguenti operazioni:

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

Crea le subnet consumer

In Cloud Shell, esegui le seguenti operazioni:

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

In Cloud Shell, esegui le seguenti operazioni:

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

In Cloud Shell, esegui le seguenti operazioni:

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

Configurazione di Cloud Router e NAT

Cloud Network Address Translation (NAT) viene utilizzato nel tutorial per i download dei pacchetti software del notebook, poiché l'istanza del notebook non ha un indirizzo IP esterno. Cloud NAT offre funzionalità NAT in uscita, il che significa che gli host internet non sono autorizzati ad avviare la comunicazione con un notebook gestito dall'utente, rendendolo più sicuro.

In Cloud Shell, crea il router cloud regionale.

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

In Cloud Shell, crea il gateway Cloud NAT regionale.

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

Crea la subnet del collegamento di rete Private Service Connect

In Cloud Shell, crea la subnet Network Attachment utilizzata da Vertex AI Pipelines.

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

4. Abilitare Identity-Aware Proxy (IAP)

Per consentire a IAP di connettersi alle tue istanze VM, crea una regola firewall che:

Si applichi a tutte le istanze VM a cui vuoi accedere tramite IAP.
Consente il traffico in entrata dall'intervallo IP 35.235.240.0/20. Questo intervallo contiene tutti gli indirizzi IP che utilizzati da IAP per l'inoltro TCP.

In Cloud Shell, crea la regola firewall IAP.

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

5. Crea istanze VM consumer

In Cloud Shell, crea l'istanza VM consumer, 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

In Cloud Shell, crea l'istanza VM consumer, 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

Ottieni e archivia gli indirizzi IP delle istanze:

In Cloud Shell, esegui un comando describe sulle istanze VM di test.

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:

Esempio:

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. Collegamento di rete Private Service Connect

I collegamenti di rete sono risorse regionali che rappresentano il lato consumer di un'interfaccia Private Service Connect. Associ una singola subnet a un collegamento di rete e il producer (Vertex AI Pipelines) assegna gli IP all'interfaccia Private Service Connect.

Crea il collegamento di rete

In Cloud Shell, crea il collegamento di rete.

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

Elenca i collegamenti di rete

In Cloud Shell, elenca il collegamento di rete.

gcloud compute network-attachments list

Descrivi i collegamenti di rete

In Cloud Shell, descrivi il collegamento di rete.

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

Prendi nota dell'URI psc-network-attachment che verrà utilizzato dal producer durante la creazione dell'interfaccia Private Service Connect.

Nell'esempio riportato di seguito, l'URI del collegamento di rete PSC è il seguente:

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. Configurazione di Vertex AI Workbench

La sezione seguente ti guida nella creazione di un blocco note Jupyter. Questo notebook verrà utilizzato per eseguire il deployment di un job Pipelines che invia un PING da Vertex AI Pipelines alle istanze di test. Il percorso dati tra Vertex AI Pipelines e la rete consumer contenente le istanze utilizza un'interfaccia di rete Private Service Connect.

Crea un service account gestito dall'utente

Nella sezione seguente creerai un service account che verrà associato all'istanza di Vertex AI Workbench utilizzata nel tutorial.

Nel tutorial, al service account verranno applicati i seguenti ruoli:

In Cloud Shell, crea il service account.

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

In Cloud Shell, aggiorna il service account con il ruolo Storage Admin.

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

In Cloud Shell, aggiorna il service account con il ruolo Utente Vertex AI.

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

In Cloud Shell, aggiorna il service account con il ruolo Amministratore di Artifact Registry.

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

In Cloud Shell, consenti al service account del notebook di utilizzare il service account predefinito di Compute Engine per creare un'istanza del job della pipeline.

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"

Crea un'istanza di Vertex AI Workbench

Nella sezione seguente, crea un'istanza di Vertex AI Workbench che incorpori il service account creato in precedenza, notebook-sa.

In Cloud Shell, crea l'istanza private-client.

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 per testare la connettività di test-svc-1

Apri una nuova scheda di Cloud Shell e aggiorna le impostazioni del progetto.

In Cloud Shell, esegui le seguenti operazioni:

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

Per consentire la connettività da Vertex AI Pipelines a test-svc-1, crea una regola firewall in entrata che specifichi l'allegato di rete PSC come origine (192.168.10.0/28) e l'indirizzo IP di test-svc-1 come destinazione.

In Cloud Shell, aggiorna destination-range in modo che corrisponda all'indirizzo IP di test-svc-1.

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

Esempio:

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

Accedi all'istanza test-svc-1 utilizzando IAP in Cloud Shell.

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

Nel sistema operativo, esegui tcpdump per acquisire il traffico ICMP. Questa sessione del sistema operativo verrà utilizzata per convalidare la comunicazione tra Vertex AI Pipeline e la VM.

sudo tcpdump -i any icmp -nn

9. Aggiornamento di Vertex AI Service Agent

Vertex AI Pipelines agisce per tuo conto per eseguire operazioni come l'ottenimento di un indirizzo IP dalla subnet di collegamento di rete PSC utilizzata per creare l'interfaccia PSC. A questo scopo, Vertex AI Pipelines utilizza un service agent (elencato di seguito) che richiede l'autorizzazione Network Admin.

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

In Cloud Shell, ottieni il numero del progetto.

gcloud projects describe $projectid | grep projectNumber

Esempio:

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

In Cloud Shell, aggiorna l'account service agent con il ruolo compute.networkAdmin.

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

Esempio:

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

10. Aggiornamento del service account predefinito

Abilita l'API Compute Engine e concedi al service account predefinito l'accesso a Vertex AI. Tieni presente che la propagazione della modifica dell'accesso potrebbe richiedere un po' di tempo.

In Cloud Shell, aggiorna il service account predefinito con il ruolo aiplatform.user

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

Esempio:

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

11. Esegui il deployment del job pipeline Vertex AI

Nella sezione seguente, creerai un blocco note per eseguire un PING riuscito all'istanza test-svc-1 del consumatore.

Esegui il job di addestramento nell'istanza di Vertex AI Workbench.

Nella console Google Cloud, vai alla scheda delle istanze nella pagina Vertex AI Workbench.
Accanto al nome dell'istanza di Vertex AI Workbench (workbench-tutorial), fai clic su Apri JupyterLab. L'istanza di Vertex AI Workbench si apre in JupyterLab.
Seleziona File > Nuovo > Notebook.
Seleziona Kernel > Python 3.
In una nuova cella del notebook, esegui questo comando per assicurarti di avere l'ultima versione di pip:

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

Imposta le variabili del progetto nella nuova cella del notebook

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

Esempio:

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

Definisci un nome del bucket univoco a livello globale come variabile in una nuova cella del notebook

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

Esempio:

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

In una nuova cella del notebook, crea il bucket

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

Nella sezione seguente, determinerai il service account Compute Engine predefinito da utilizzare per eseguire il job della pipeline e gli concederai le autorizzazioni corrette.

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}")

Per confermare l'esecuzione corretta, vengono stampati il service account e il numero di progetto

In una nuova cella del blocco note, concedi al service account l'autorizzazione a leggere e scrivere gli artefatti della pipeline nel bucket creato nel passaggio precedente.

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

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

In una nuova cella del notebook, definisci i parametri della pipeline. Tieni presente che NETWORK_ATTACHMENT_NAME è il collegamento di rete PSC, pertanto deve corrispondere.

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

In una nuova cella del notebook, inizializza l'SDK Vertex AI

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')

In una nuova cella del notebook, definisci il componente di test.

@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
            """
        ],
    )

In una nuova cella del notebook, definisci la pipeline

@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

In una nuova cella del blocco note, esegui la funzione di utilità e attendi il completamento della pipeline.

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")

In una nuova cella del notebook, esegui la funzione di utilità per eseguire la pipeline

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

In una nuova cella del notebook, compila la pipeline

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

In una nuova cella del blocco note, aggiorna TARGET_IP_ADDRESS in modo che rifletta l'indirizzo IP ottenuto nel passaggio precedente per test-svc-1 e osserva lo stato del job della pipeline

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}")

Esempio:

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}")

Una volta eseguito il passaggio 17, il completamento della pipeline richiederà circa 8 minuti.

12. Convalida la connettività a test-svc-1

Nella cella utilizzata per eseguire il passaggio 17, osserva la transizione dello stato del job della pipeline da PIPELINE_STATE_PENDING a PIPELINE_STATE_RUNNING e infine a PIPELINE_STATE_SUCCEEDED, che indica un ping riuscito da Vertex AI Pipelines e una risposta da test-svc-1.

Per convalidare il traffico ICMP tra Vertex AI Pipeline e test-svc-1, visualizza la sessione tcpdump generata in precedenza eseguita nel sistema operativo test-svc-1 che fornisce log che indicano il traffico bidirezionale.

Nell'esempio tcpdump, Vertex AI Pipelines ha ottenuto l'indirizzo IP 192.168.10.3 dalla subnet 192.168.10.0/28, mentre 192.168.20.2 è l'indirizzo IP di test-svc-1. Tieni presente che nel tuo ambiente gli indirizzi IP potrebbero essere diversi.

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. Connettività di Vertex AI Pipelines AI a test-svc-2

Nella sezione seguente, creerai una regola firewall in entrata per negare il traffico dalla subnet di Vertex AI Pipelines (192.168.10.0/28) a test-svc-2, quindi aggiornerai il notebook in modo che rifletta l'indirizzo IP di test-svc-2 e infine eseguirai l'esecuzione dei job di pipeline.

Nella cella del notebook, lo stato del job della pipeline indicherà Errore - Pipeline non riuscita. Inoltre, i log del firewall forniranno informazioni sulla connessione non riuscita.

Crea una regola firewall in entrata di tipo Nega

Per negare la connettività da Vertex AI Pipelines a test-svc-2, crea una regola firewall in entrata che specifichi il collegamento di rete PSC come origine (192.168.10.0/28) e l'indirizzo IP di test-svc-2 come destinazione.

In Cloud Shell, aggiorna destination-range in modo che corrisponda all'indirizzo IP di test-svc-2.

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

Esempio:

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

Esegui il job della pipeline dalla cella del notebook

In una nuova cella del blocco note, aggiorna TARGET_IP_ADDRESS in modo che rifletta l'indirizzo IP ottenuto nel passaggio precedente per test-svc-2 e osserva lo stato del job 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}")

Esempio:

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}")

Una volta eseguito, il job della pipeline richiederà circa 8 minuti.

14. Convalida della connettività non riuscita a test-svc-2

Nella cella utilizzata per eseguire il job Pipelines, nota la transizione di stato da PIPELINE_STATE_PENDING a PIPELINE_STATE_FAILED, che indica un ping senza esito positivo da Vertex AI Pipelines e una risposta da test-svc-2.

Utilizzando Esplora log, puoi visualizzare le voci di logging del firewall corrispondenti alla regola Ingress Deny costituita dalla subnet di Vertex AI Pipelines (192.168.10.0/28) e dall'indirizzo IP test-svc-2.

Seleziona Mostra query e inserisci il filtro riportato di seguito, ultimi 15 minuti, quindi Esegui query.

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

Seleziona una voce di log, quindi espandi i campi nidificati per visualizzare gli elementi informativi costituiti dall'indirizzo IP di Vertex AI Pipelines e test-svc-2 che convalida la regola firewall in entrata negata.

15. Esegui la pulizia

Da Cloud Shell, elimina i componenti del tutorial.

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

Congratulazioni, hai configurato e convalidato correttamente un'interfaccia Private Service Connect e la connettività consumer e producer implementando il firewall di autorizzazione e negazione in entrata.

Hai creato l'infrastruttura consumer e hai aggiunto un collegamento di rete che ha consentito al servizio Vertex AI Pipelines di creare una VM di interfaccia PSC per collegare la comunicazione tra consumer e producer. Hai imparato a creare regole firewall nella rete VPC consumer che consentivano e negavano la connettività alle istanze nella rete consumer.

Interfaccia Private Service Connect per le pipeline Vertex AI

1. Introduzione

Cosa creerai

Cosa imparerai a fare

Che cosa ti serve

2. Prima di iniziare

Aggiornare il progetto per supportare il tutorial

3. Configurazione consumatore

Crea il VPC consumer

Crea le subnet consumer

Configurazione di Cloud Router e NAT

Crea la subnet del collegamento di rete Private Service Connect

4. Abilitare Identity-Aware Proxy (IAP)

5. Crea istanze VM consumer

6. Collegamento di rete Private Service Connect

Crea il collegamento di rete

Elenca i collegamenti di rete

Descrivi i collegamenti di rete

7. Configurazione di Vertex AI Workbench

Crea un service account gestito dall'utente

Crea un'istanza di Vertex AI Workbench

8. Vertex AI Pipelines per testare la connettività di test-svc-1

9. Aggiornamento di Vertex AI Service Agent

10. Aggiornamento del service account predefinito

11. Esegui il deployment del job pipeline Vertex AI

12. Convalida la connettività a test-svc-1

13. Connettività di Vertex AI Pipelines AI a test-svc-2

Crea una regola firewall in entrata di tipo Nega

Esegui il job della pipeline dalla cella del notebook

14. Convalida della connettività non riuscita a test-svc-2

15. Esegui la pulizia

16. Complimenti

Passaggi successivi

Ulteriori letture e video

Documentazione di riferimento