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 di produttori e consumatori 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 di servizio, ma presenta due differenze fondamentali:

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

Cosa creerai

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

In questo tutorial, creerai un'architettura completa dell'interfaccia Private Service Connect (PSC) per le pipeline Vertex AI che utilizza le regole di Cloud Firewall 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 nella VPC consumer, con i seguenti casi d'uso:

1. Crea una regola firewall in entrata nella VPC del consumatore che consenta alla subnet di Vertex AI Pipeline (192.168.10.0/28) di accedere a test-svc-1. Conferma il PING riuscito generato dal job della pipeline a test-svc-1 utilizzando TCPDUMP
2. Crea una regola firewall in entrata nella VPC del consumatore che neghi 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 Log Explorer.

Nota:questo tutorial offre i passaggi di configurazione e convalida in base alla topologia illustrata. Modifica la procedura in base alle esigenze della tua organizzazione.

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
• Amministratore istanze Compute (roles/compute.instanceAdmin)
• Amministratore rete Compute (roles/compute.networkAdmin)
• Amministratore sicurezza Compute (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 account di servizio (roles/iam.serviceAccountAdmin)
• Utente account di servizio (roles/iam.serviceAccountUser)
• Vertex AI Admin (roles/aiplatform.admin)

2. Prima di iniziare

Nota:i componenti aggiuntivi della rete non possono essere eliminati a meno che il produttore (Vertex AI) non elimini le risorse allocate. Per avviare la procedura di eliminazione, devi contattare l'assistenza Vertex AI.

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

In Cloud Shell, svolgi i seguenti passaggi:

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, svolgi i seguenti passaggi:

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 del consumatore

Crea il VPC del consumatore

In Cloud Shell, svolgi i seguenti passaggi:

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

Crea le subnet dei consumatori

In Cloud Shell, svolgi i seguenti passaggi:

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, svolgi i seguenti passaggi:

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, svolgi i seguenti passaggi:

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

Nel tutorial viene utilizzata la Network Address Translation (NAT) di Cloud per i download dei pacchetti software del notebook, poiché l'istanza del notebook non ha un indirizzo IP esterno. Cloud NAT offre funzionalità di 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 sottorete dell'attacco alla rete 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. Attivare Identity-Aware Proxy (IAP)

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

• Si applica 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. Creare istanze VM per i consumatori

In Cloud Shell, crea l'istanza VM del consumatore 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 del consumatore 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 memorizza 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. Associa una singola sottorete 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 illustra la procedura per creare un blocco note Jupyter. Questo blocco note 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 le pipeline Vertex AI e la rete del consumatore contenente le istanze utilizza un'interfaccia di rete Private Service Connect.

Creare un account di servizio gestito dall'utente

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

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

• Amministratore archiviazione
• Vertex AI User
• Artifact Registry Administrator

In Cloud Shell, crea l'account di servizio.

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

In Cloud Shell, aggiorna l'account di servizio 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 l'account di servizio 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 l'account di servizio con il ruolo Amministratore del registry di elementi.

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

In Cloud Shell, consenti all'account di servizio del notebook di utilizzare l'account di servizio predefinito di Compute Engine per creare l'istanza del job della pipeline.

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"

Creare un'istanza di Vertex AI Workbench

Nella sezione seguente, crea un'istanza di Vertex AI Workbench che includa l'account di servizio notebook-sa creato in precedenza.

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

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

In Cloud Shell, svolgi i seguenti passaggi:

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'attacco alla rete PSC come origine (192.168.10.0/28) e l'indirizzo IP test-svc-1 come destinazione.

In Cloud Shell, aggiorna l'intervallo di destinazione in modo che corrisponda all'indirizzo IP 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

Nell'OS, esegui tcpdump per acquisire qualsiasi 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 del collegamento di rete del PSC utilizzato per creare l'interfaccia PSC. A tale scopo, Vertex AI Pipelines utilizza un agente di servizio (elencato di seguito) che richiede l'autorizzazione Amministratore di rete.

Nota: prima di aggiornare le autorizzazioni dell'agente di servizio, vai a Vertex AI nella console Cloud per assicurarti che l'API Vertex AI sia abilitata.

service-$[e-mail]

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 agente di servizio 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:[e-mail]" --role="roles/compute.networkAdmin"

10. Aggiornamento dell'account di servizio predefinito

Abilita l'API Compute Engine e concedi all'account di servizio predefinito l'accesso a Vertex AI. Tieni presente che potrebbe essere necessario un po' di tempo prima che la modifica dell'accesso venga propagata.

In Cloud Shell, aggiorna l'account di servizio predefinito con il ruolo aiplatform.user

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

Esempio:

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

11. Esegui il deployment del job Vertex AI Pipelines

Nella sezione seguente, creerai un notebook per eseguire un PING riuscito all'istanza consumer test-svc-1.

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

1. Nella console Google Cloud, vai alla scheda Istanze nella pagina Vertex AI Workbench.
2. Accanto al nome dell'istanza Vertex AI Workbench (workbench-tutorial), fai clic su Apri JupyterLab. L'istanza di Vertex AI Workbench si apre in JupyterLab.
3. Seleziona File > Nuovo > Notebook
4. Seleziona Kernel > Python 3
5. In una nuova cella del notebook, esegui il seguente comando per assicurarti di avere la versione più recente di pip:

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

6. 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"

7. Definisci un nome 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"

8. Crea il bucket in una nuova cella del notebook

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

Nella sezione seguente, determinerai l'account di servizio Compute Engine predefinito da utilizzare per eseguire il job della pipeline e gli concederai le autorizzazioni necessarie.

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

Per confermare un'esecuzione riuscita, vengono stampati l'account di servizio e il numero del progetto

9. In una nuova cella del notebook, concedi all'account di servizio l'autorizzazione a leggere e scrivere gli elementi 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}

10. 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}"

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

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

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

14. In una nuova cella del notebook, 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")

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

16. In una nuova cella del notebook, compila la pipeline

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

17. In una nuova cella del notebook, 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, la pipeline richiederà circa 8 minuti per essere completata.

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 la 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 ed eseguita nel sistema operativo test-svc-1 che fornisce i log che indicano il traffico bidirezionale.

Nell'esempio tcpdump, Vertex AI Pipelines ha recuperato l'indirizzo IP 192.168.10.3 dalla subnet 192.168.10.0/28, 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 Vertex AI Pipelines (192.168.10.0/28) a test-svc-2, poi aggiornerai il notebook in modo che rifletta l'indirizzo IP di test-svc-2 ed infine eseguirai l'esecuzione dei job di Pipelines.

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

Creare una regola firewall di rifiuto in entrata

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

In Cloud Shell, aggiorna l'intervallo di destinazione 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

Eseguire il job della pipeline dalla cella del notebook

In una nuova cella del notebook, 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 delle pipeline.

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 la 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 non riuscito da Vertex AI Pipelines e la risposta da test-svc-2.

Con Log Explorer puoi visualizzare le voci di logging del firewall corrispondenti alla regola di rifiuto in entrata composta 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 seguente, Ultimi 15 minuti, seguito da Esegui query.

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

Nota:se i log non vengono generati, ricarica il browser web ed esegui "Esegui query" con il filtro e l'intervallo di tempo specificati.

Seleziona una voce di log, quindi espandi i campi nidificati per visualizzare gli elementi di informazione costituiti da Vertex AI Pipelines e dall'indirizzo IP test-svc-2 che convalidano la regola del firewall di ingresso rifiutata.

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à di consumer e producer implementando il firewall di autorizzazione e rifiuto 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 del consumatore che consentivano e negavano la connettività alle istanze nella rete del consumatore.

Cosmopup pensa che i tutorial siano fantastici.

Passaggi successivi

Letture e video di approfondimento

• Panoramica di Private Service Connect

Documentazione di riferimento

• Configurare l'interfaccia Private Service Connect per una pipeline | Vertex AI | Google Cloud
• Configurare un'interfaccia Private Service Connect per le risorse Vertex AI | Google Cloud