Interface Private Service Connect Vertex AI Pipelines

1. Introduction

Une interface Private Service Connect est une ressource qui permet à un réseau VPC (Virtual Private Cloud) de producteur d'initier des connexions avec différentes destinations dans un réseau consommateur. Les réseaux de producteurs et les réseaux de clients peuvent appartenir à différents projets et organisations.

Une connexion entre un rattachement de réseau et une interface Private Service Connect est semblable à la connexion entre un point de terminaison Private Service Connect et un rattachement de service, avec toutefois deux différences majeures :

  • Un rattachement de réseau permet à un réseau producteur d'établir des connexions avec un réseau consommateur (sortie de service géré), tandis qu'un point de terminaison permet à un réseau consommateur d'établir des connexions avec un réseau producteur (entrée de service géré).
  • Une connexion d'interface Private Service Connect est transitive. Cela signifie qu'un réseau de producteur peut communiquer avec d'autres réseaux connectés au réseau du client.

Ce que vous allez faire

Vertex AI Pipelines, déployé dans un projet locataire géré par Google, utilisera le rattachement de réseau PSC pour créer une instance multi-NIC entre le réseau producteur et le réseau consommateur. Étant donné que le rattachement de réseau PSC est déployé avec plusieurs cartes d'interface réseau à partir du réseau du consommateur, Vertex AI Pipelines peut atteindre les routes disponibles à partir du réseau du consommateur.

Dans ce tutoriel, vous allez créer une architecture d'interface Private Service Connect (PSC) complète pour Vertex AI Pipelines, qui utilise des règles de pare-feu cloud pour autoriser ou refuser la connectivité entre le producteur et les instances de test du consommateur, comme illustré à la figure 1.

Figure 1

12714b6f0f8fa411.png

Vous allez créer un seul rattachement de réseau PSC dans le VPC consommateur, ce qui entraînera les cas d'utilisation suivants :

  1. Créez une règle de pare-feu d'entrée dans le VPC du consommateur pour autoriser le sous-réseau Vertex AI Pipelines (192.168.10.0/28) à accéder à test-svc-1. Confirmer la réussite du PING généré à partir du job de pipeline vers test-svc-1 à l'aide de TCPDUMP
  2. Créez une règle de pare-feu d'entrée dans le consumer-vpc pour refuser le sous-réseau Vertex AI Pipelines (192.168.10.0/28) à test-svc-2. Confirmez l'échec du PING en fonction des journaux du pare-feu générés par l'explorateur de journaux.

Points abordés

  • Créer un rattachement de réseau
  • Comment Vertex AI Pipelines peut utiliser une pièce jointe réseau pour créer une interface PSC
  • Établir la communication entre le producteur et le consommateur
  • Autoriser l'accès de Vertex AI Pipelines à la VM consommateur test-svc-1
  • Comment refuser l'accès depuis Vertex AI Pipelines à la VM consommateur, test-svc-2, à l'aide du pare-feu cloud

Prérequis

2. Avant de commencer

Ce tutoriel utilise des $variables pour faciliter l'implémentation de la configuration gcloud dans Cloud Shell.

Dans Cloud Shell, procédez comme suit :

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

Mettre à jour le projet pour qu'il soit compatible avec le tutoriel

Dans Cloud Shell, procédez comme suit :

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. Configuration par le consommateur

Créer le VPC consommateur

Dans Cloud Shell, procédez comme suit :

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

Créer les sous-réseaux consommateurs

Dans Cloud Shell, procédez comme suit :

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

Dans Cloud Shell, procédez comme suit :

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

Dans Cloud Shell, procédez comme suit :

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

Configuration de Cloud Router et de NAT

La traduction d'adresse réseau (NAT) Cloud est utilisée dans le tutoriel pour les téléchargements de packages logiciels de notebooks, car l'instance de notebook ne possède pas d'adresse IP externe. Cloud NAT offre des fonctionnalités de NAT de sortie, ce qui signifie que les hôtes Internet ne sont pas autorisés à initier une communication avec un notebook géré par l'utilisateur, ce qui le rend plus sécurisé.

Dans Cloud Shell, créez le routeur cloud régional.

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

Dans Cloud Shell, créez la passerelle Cloud NAT régionale.

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

Créer le sous-réseau de rattachement de réseau Private Service Connect

Dans Cloud Shell, créez le sous-réseau Network Attachment utilisé par 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. Activer Identity-Aware Proxy (IAP)

Pour permettre à IAP de se connecter à vos instances de VM, créez une règle de pare-feu qui :

  • S'applique à toutes les instances de VM auxquelles vous souhaitez être accessible à l'aide d'IAP.
  • Autorise le trafic entrant à partir de la plage d'adresses IP 35.235.240.0/20. Cette plage contient toutes les adresses IP qu'IAP utilise pour le transfert TCP.

Dans Cloud Shell, créez la règle de pare-feu IAP.

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

5. Créer des instances de VM consommateur

Dans Cloud Shell, créez l'instance de VM consommateur 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

Dans Cloud Shell, créez l'instance de VM consommateur 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

Obtenez et stockez les adresses IP des instances :

Dans Cloud Shell, exécutez une commande "describe" sur les instances de VM de 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:

Exemple :

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. Rattachement de réseau Private Service Connect

Les rattachements de réseau sont des ressources régionales qui représentent le côté utilisateur d'une interface Private Service Connect. Vous associez un seul sous-réseau à un rattachement de réseau, et le producteur (Vertex AI Pipelines) attribue des adresses IP à l'interface Private Service Connect.

Créer le rattachement de réseau

Dans Cloud Shell, créez le rattachement de réseau.

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

Lister les rattachements de réseau

Dans Cloud Shell, listez le rattachement réseau.

gcloud compute network-attachments list

Décrire les rattachements de réseau

Dans Cloud Shell, décrivez le rattachement de réseau.

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

Notez l'URI psc-network-attachment qui sera utilisé par le producteur lors de la création de l'interface Private Service Connect.

Dans l'exemple ci-dessous, l'URI du rattachement réseau PSC est le suivant :

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

La section suivante vous explique comment créer un notebook Jupyter. Ce notebook sera utilisé pour déployer un job Pipelines qui envoie un PING depuis Vertex AI Pipelines vers les instances de test. Le chemin de données entre Vertex AI Pipelines et le réseau consommateur contenant les instances utilise une interface réseau Private Service Connect.

Créer un compte de service géré par l'utilisateur

Dans la section suivante, vous allez créer un compte de service qui sera associé à l'instance Vertex AI Workbench utilisée dans le tutoriel.

Dans le tutoriel, les rôles suivants seront appliqués au compte de service :

Dans Cloud Shell, créez le compte de service.

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

Dans Cloud Shell, mettez à jour le compte de service avec le rôle "Administrateur Storage".

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

Dans Cloud Shell, mettez à jour le compte de service avec le rôle Utilisateur Vertex AI.

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

Dans Cloud Shell, mettez à jour le compte de service avec le rôle Administrateur Artifact Registry.

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

Dans Cloud Shell, autorisez le compte de service du notebook à utiliser le compte de service Compute Engine par défaut pour instancier le job de 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"

Créer une instance Vertex AI Workbench

Dans la section suivante, créez une instance Vertex AI Workbench qui intègre le compte de service notebook-sa créé précédemment.

Dans Cloud Shell, créez l'instance de client privé.

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. Connectivité Vertex AI Pipelines à test-svc-1

Ouvrez un nouvel onglet Cloud Shell et mettez à jour les paramètres de votre projet.

Dans Cloud Shell, procédez comme suit :

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

Pour autoriser la connectivité de Vertex AI Pipelines à test-svc-1, créez des règles de pare-feu d'entrée qui spécifient le rattachement réseau PSC comme source (192.168.10.0/28) et l'adresse IP test-svc-1 comme destination.

Dans Cloud Shell, mettez à jour la destination-range pour qu'elle corresponde à l'adresse IP de 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

Exemple :

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

Connectez-vous à l'instance test-svc-1 à l'aide d'IAP dans Cloud Shell.

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

Dans l'OS, exécutez tcpdump pour capturer tout le trafic ICMP. Cette session d'OS sera utilisée pour valider la communication entre Vertex AI Pipelines et la VM.

sudo tcpdump -i any icmp -nn

9. Mise à jour de l'agent de service Vertex AI

Vertex AI Pipelines agit en votre nom pour effectuer des opérations telles que l'obtention d'une adresse IP à partir du sous-réseau de rattachement de réseau PSC utilisé pour créer l'interface PSC. Pour ce faire, Vertex AI Pipelines utilise un agent de service (listé ci-dessous) qui nécessite l'autorisation Administrateur réseau.

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

Dans Cloud Shell, obtenez le numéro de votre projet.

gcloud projects describe $projectid | grep projectNumber

Exemple :

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

Dans Cloud Shell, mettez à jour le compte de l'agent de service avec le rôle compute.networkAdmin.

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

Exemple :

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

10. Mise à jour du compte de service par défaut

Activez l'API Compute Engine et accordez à votre compte de service par défaut l'accès à Vertex AI. Notez que la propagation de la modification d'accès peut prendre un certain temps.

Dans Cloud Shell, mettez à jour le compte de service par défaut avec le rôle aiplatform.user.

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

Exemple :

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

11. Déployer un job Vertex AI Pipelines

Dans la section suivante, vous allez créer un notebook pour effectuer un PING réussi vers l'instance consumer test-svc-1.

Exécutez le job d'entraînement dans l'instance Vertex AI Workbench.

  1. Dans la console Google Cloud, accédez à l'onglet "Instances" de la page Vertex AI Workbench.
  2. À côté du nom de votre instance Vertex AI Workbench (workbench-tutorial), cliquez sur "Ouvrir JupyterLab". Votre instance Vertex AI Workbench ouvre JupyterLab.
  3. Sélectionnez Fichier > Nouveau > Notebook.
  4. Sélectionnez Kernel > Python 3.
  5. Dans une nouvelle cellule de notebook, exécutez la commande suivante pour vous assurer que vous disposez de la dernière version de pip :
! pip3 install --upgrade --quiet google-cloud-aiplatform \
  kfp \
  google-cloud-pipeline-components
  1. Définissez les variables de votre projet dans la nouvelle cellule du notebook.
PROJECT_ID = "<your-projectid>" 
REGION = "<your-region>"  
NETWORK_ATTACHMENT_NAME = "psc-network-attachment"

Exemple :

PROJECT_ID = "psc-vertex" 
REGION = "us-central1"  
NETWORK_ATTACHMENT_NAME = "psc-network-attachment"
  1. Définissez un nom de bucket unique au monde comme variable dans une nouvelle cellule de notebook.
BUCKET_URI = f"gs://<your-bucket-name>"

Exemple :

BUCKET_URI = f"gs://psc-vertex-bucket"
  1. Dans une nouvelle cellule de notebook, créez le bucket.
! gsutil mb -l {REGION} -p {PROJECT_ID} {BUCKET_URI}

Dans la section suivante, vous allez déterminer le compte de service Compute Engine par défaut à utiliser pour exécuter le job de pipeline, et lui accorder les autorisations appropriées.

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

Pour confirmer l'exécution, votre compte de service et votre numéro de projet sont imprimés.

  1. Dans une nouvelle cellule de notebook, accordez à votre compte de service l'autorisation de lire et d'écrire des artefacts de pipeline dans le bucket créé à l'étape précédente.
! gsutil iam ch serviceAccount:{SERVICE_ACCOUNT}:roles/storage.objectCreator {BUCKET_URI}

! gsutil iam ch serviceAccount:{SERVICE_ACCOUNT}:roles/storage.objectViewer {BUCKET_URI}
  1. Dans une nouvelle cellule de notebook, définissez les paramètres du pipeline. Notez que NETWORK_ATTACHMENT_NAME correspond au rattachement réseau PSC et doit donc être identique.
PIPELINE_ROOT = f"{BUCKET_URI}/pipeline_root/psc_test"
NETWORK_ATTACHMENT_URI = f"projects/{PROJECT_NUMBER}/regions/{REGION}/networkAttachments/{NETWORK_ATTACHMENT_NAME}"
  1. Dans une nouvelle cellule de notebook, initialisez le 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')
  1. Dans une nouvelle cellule de notebook, définissez le composant de 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
            """
        ],
    )
  1. Dans une nouvelle cellule de notebook, définissez le 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
  1. Dans une nouvelle cellule de notebook, exécutez la fonction utilitaire et attendez la fin du 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")
  1. Dans une nouvelle cellule de notebook, exécutez la fonction utilitaire pour exécuter le 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
  1. Dans une nouvelle cellule de notebook, compilez le pipeline.
from kfp import compiler
compiler.Compiler().compile(pipeline_func=pipeline, package_path='pipeline.yaml')
  1. Dans une nouvelle cellule de notebook, mettez à jour TARGET_IP_ADDRESS pour refléter l'adresse IP obtenue à l'étape précédente pour test-svc-1 et observez l'état du job de 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}")

Exemple :

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

Une fois l'étape 17 exécutée, l'exécution du pipeline prendra environ huit minutes.

12. Valider la connectivité à test-svc-1

Dans la cellule utilisée pour exécuter l'étape 17, observez la transition de l'état du job de pipeline de PIPELINE_STATE_PENDING à PIPELINE_STATE_RUNNING, puis à PIPELINE_STATE_SUCCEEDED, ce qui indique que le ping de Vertex AI Pipelines a réussi et que test-svc-1 a répondu.

Pour valider le trafic ICMP entre Vertex AI Pipelines et test-svc-1, consultez la session tcpdump générée précédemment et exécutée dans l'OS test-svc-1. Elle fournit des journaux indiquant le trafic bidirectionnel.

Dans l'exemple tcpdump, Vertex AI Pipelines a obtenu l'adresse IP 192.168.10.3 à partir du sous-réseau 192.168.10.0/28, tandis que 192.168.20.2 est l'adresse IP de test-svc-1. Notez que les adresses IP peuvent être différentes dans votre environnement.

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. Connectivité Vertex AI Pipelines AI à test-svc-2

Dans la section suivante, vous allez créer une règle de pare-feu d'entrée pour refuser le trafic provenant du sous-réseau Vertex AI Pipelines (192.168.10.0/28) vers test-svc-2. Vous allez ensuite mettre à jour le notebook pour refléter l'adresse IP de test-svc-2, puis exécuter les jobs Pipelines.

Dans la cellule du notebook, l'état du job de pipeline indique "Erreur : échec du pipeline". De plus, les journaux du pare-feu fournissent des informations sur l'échec de la connexion.

Créer une règle de pare-feu d'entrée "Refuser"

Pour refuser la connectivité de Vertex AI Pipelines à test-svc-2, créez une règle de pare-feu d'entrée qui spécifie l'association de réseau PSC comme source (192.168.10.0/28) et l'adresse IP de test-svc-2 comme destination.

Dans Cloud Shell, mettez à jour la destination-range pour qu'elle corresponde à l'adresse IP de 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

Exemple :

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

Exécuter un job de pipeline à partir d'une cellule de notebook

Dans une nouvelle cellule de notebook, mettez à jour TARGET_IP_ADDRESS pour refléter l'adresse IP obtenue à l'étape précédente pour test-svc-2, puis observez l'état du 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}")

Exemple :

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

Une fois exécuté, le job de pipeline prendra environ huit minutes.

14. Valider l'échec de la connectivité à test-svc-2

Dans la cellule utilisée pour exécuter le job Pipelines, notez la transition de l'état de PIPELINE_STATE_PENDING à PIPELINE_STATE_FAILED, qui indique un ping infructueux de Vertex AI Pipelines et une réponse de test-svc-2.

L'explorateur de journaux vous permet d'afficher les entrées de journalisation du pare-feu correspondant à la règle "Refuser l'entrée" composée du sous-réseau Vertex AI Pipelines (192.168.10.0/28) et de l'adresse IP test-svc-2.

Sélectionnez "Afficher la requête", insérez le filtre ci-dessous (15 dernières minutes), puis cliquez sur "Exécuter la requête".

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

20e072f26d9a113b.png

5fb3d2de0a85e3c6.png

Sélectionnez une entrée de journal, puis développez les champs imbriqués pour afficher les éléments d'information comprenant l'adresse IP de Vertex AI Pipelines et de test-svc-2, qui valident la règle de pare-feu d'entrée refusée.

903aaf2c10d07460.png

15. Effectuer un nettoyage

Dans Cloud Shell, supprimez les composants du tutoriel.

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. Félicitations

Félicitations ! Vous avez configuré et validé une interface Private Service Connect, ainsi que la connectivité entre le consommateur et le producteur, en implémentant un pare-feu d'autorisation et de refus d'entrée.

Vous avez créé l'infrastructure du consommateur et ajouté un rattachement de réseau qui a permis au service Vertex AI Pipelines de créer une VM d'interface PSC pour faire le lien entre la communication du consommateur et du producteur. Vous avez appris à créer des règles de pare-feu dans le réseau VPC consommateur qui autorisaient et refusaient la connectivité aux instances du réseau consommateur.

Cosmopup pense que les tutoriels sont géniaux !!

c911c127bffdee57.jpeg

Et ensuite ?

Lectures et vidéos complémentaires

Documents de référence