Interface Private Service Connect Vertex AI Pipelines

À propos de cet atelier de programmation
schedule92 minutes
subjectDernière mise à jour : 26 février 2025
account_circleRédigé par Deepak Michael, Rafa Carvalho

Une interface Private Service Connect est une ressource qui permet à un réseau cloud privé virtuel (VPC) de producteur d'établir 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 à une 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 utilisateur (sortie de service géré), tandis qu'un point de terminaison permet à un réseau utilisateur 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, exploitera 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 réseau PSC est déployé avec un multi-NIC à partir du réseau client, Vertex AI Pipelines peut atteindre les routes disponibles à partir du réseau client.

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

Figure 1

12714b6f0f8fa411.png

Vous allez créer un seul psc-network-attachment dans le VPC client, ce qui donne les cas d'utilisation suivants:

  1. Créez une règle de pare-feu d'entrée dans le VPC client pour autoriser le sous-réseau Vertex AI Pipeline (192.168.10.0/28) à accéder à test-svc-1. Confirmer que le PING généré à partir de l'ordre de pipeline vers test-svc-1 a bien fonctionné à l'aide de TCPDUMP
  2. Créez une règle de pare-feu d'entrée dans le VPC client qui refuse le sous-réseau du pipeline Vertex AI (192.168.10.0/28) à test-svc-2. Vérifiez l'échec de 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 connexion réseau pour créer une interface PSC
  • Établir la communication du producteur au consommateur
  • Autoriser l'accès de Vertex AI Pipelines à la VM consommatrice, test-svc-1
  • Refuser l'accès de Vertex AI Pipelines à la VM grand public test-svc-2 à l'aide de Cloud Firewall

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 du client

Créer le VPC client

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

Dans le tutoriel, la traduction d'adresse réseau (NAT, Network Address Translation) dans le cloud est utilisée pour les téléchargements de packages logiciels de notebook, car l'instance de notebook ne dispose pas d'adresse IP externe. Cloud NAT offre des fonctionnalités de NAT sortant, ce qui signifie que les hôtes Internet ne sont pas autorisés à initier la communication avec un bloc-notes 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 d'attachement réseau 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 autoriser IAP à se connecter à vos instances de VM, créez une règle de pare-feu qui:

  • S'applique à toutes les instances de VM que vous souhaitez rendre accessibles à l'aide d'IAP.
  • Autorise le trafic entrant provenant 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 grand public

Dans Cloud Shell, créez l'instance de VM de client, 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 de client, 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, effectuez une description des 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 l'association 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 de l'attachement de 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. Configuration de Vertex AI Workbench

La section suivante vous explique comment créer un notebook Jupyter. Ce notebook vous permettra de déployer un job Pipelines qui envoie un PING de Vertex AI Pipelines aux instances de test. Le chemin de données entre Vertex AI Pipelines et le réseau client 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 ce 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, attribuez le rôle "Storage Admin" au compte de service.

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

Dans Cloud Shell, attribuez le rôle Utilisateur Vertex AI au compte de service.

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

Dans Cloud Shell, attribuez le rôle Administrateur de l'Artifact Registry au compte de service.

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 la tâche 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 vers 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é des pipelines Vertex AI à test-svc-1, créez une règle de pare-feu d'entrée qui spécifie l'attachement 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 plage de destination pour qu'elle corresponde à votre adresse 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

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 trafic ICMP. Cette session d'OS servira à valider la communication entre Vertex AI Pipeline 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 l'attachement 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 Network Admin.

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

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

gcloud projects describe $projectid | grep projectNumber

Exemple :

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

Dans Cloud Shell, attribuez le rôle compute.networkAdmin au compte de l'agent de service.

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 à l'instance de consommation 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" sur 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 File > New > Notebook (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éfinir 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éfinir un nom de bucket unique au niveau mondial en tant que 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 que l'exécution a bien été effectuée, votre compte de service et votre numéro de projet sont imprimés.

  1. Dans une nouvelle cellule de notebook, autorisez votre compte de service à lire et à é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 du PSC et doit donc correspondre.
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, puis 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 qu'elle reflète l'adresse IP obtenue à l'étape précédente pour test-svc-1, puis observez l'état de la tâche du 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é avec test-svc-1

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

Pour valider le trafic ICMP entre le pipeline Vertex AI et test-svc-1, consultez la session tcpdump générée précédemment exécutée dans l'OS test-svc-1, qui 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. L'adresse IP 192.168.20.2 est celle de test-svc-1. Notez que dans votre environnement, les adresses IP peuvent être différentes.

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é de l'IA Vertex AI Pipelines avec 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, puis mettre à jour le notebook pour refléter l'adresse IP de test-svc-2, puis exécuter l'exécution des jobs Pipelines.

Dans la cellule du notebook, l'état de la tâche de pipeline indiquera "Error - Pipeline Failed" (Erreur : échec du pipeline). En outre, les journaux du pare-feu fourniront des informations sur la connexion ayant échoué.

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

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

Dans Cloud Shell, mettez à jour la plage de destination pour qu'elle corresponde à votre adresse IP 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 une tâche 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 de la tâche 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. Vérifier la connectivité défaillante avec test-svc-2

Dans la cellule utilisée pour exécuter le job Pipelines, notez la transition d'état de PIPELINE_STATE_PENDING à PIPELINE_STATE_FAILED, ce 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 de refus d'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", puis insérez le filtre ci-dessous (dernières 15 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'informations correspondant aux pipelines Vertex AI et à l'adresse IP 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 correctement configuré et validé une interface Private Service Connect, ainsi que la connectivité des consommateurs et des producteurs en implémentant le pare-feu d'autorisation et de refus d'entrée.

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

Cosmopup pense que les tutoriels sont géniaux !

c911c127bffdee57.jpeg

Et ensuite ?

Autres ressources et vidéos

Documents de référence