Vertex AI Pipelines de la interfaz de Private Service Connect

1. Introducción

Una interfaz de Private Service Connect es un recurso que permite que una red de nube privada virtual (VPC) de productor inicie conexiones a varios destinos en una red de consumidor. Las redes de productores y consumidores pueden estar en diferentes proyectos y organizaciones.

Una conexión entre un adjunto de red y una interfaz de Private Service Connect es similar a la conexión entre un extremo de Private Service Connect y un adjunto de servicio, pero tiene dos diferencias clave:

  • Un adjunto de red permite que una red de productor inicie conexiones a una red de consumidor (salida de servicio administrado), mientras que un extremo permite que una red de consumidor inicie conexiones a una red de productor (entrada de servicio administrado).
  • Una conexión de la interfaz de Private Service Connect es transitiva. Esto significa que una red del productor puede comunicarse con otras redes que están conectadas a la red del consumidor.

Qué compilarás

Vertex AI Pipelines, implementado en un proyecto de usuario administrado por Google, aprovechará el adjunto de red de PSC para crear una instancia de varias NIC entre la red de productor y la de consumidor. Dado que la conexión de red de PSC se implementa con varias NIC desde la red del consumidor, Vertex AI Pipelines puede acceder a las rutas disponibles desde la red del consumidor.

En este instructivo, crearás una arquitectura integral de la interfaz de Private Service Connect (PSC) para Vertex AI Pipelines que utiliza reglas de Cloud Firewall para permitir o denegar la conectividad del productor a las instancias de prueba del consumidor, como se ilustra en la Figura 1.

Figura 1

12714b6f0f8fa411.png

Crearás un solo psc-network-attachment en la VPC del consumidor, lo que generará los siguientes casos de uso:

  1. Crea una regla de firewall de entrada en consumer-vpc que permita que la subred de Vertex AI Pipeline (192.168.10.0/28) se conecte a test-svc-1. Confirma que se generó un PING exitoso desde el trabajo de la canalización a test-svc-1 con TCPDUMP
  2. Crea una regla de firewall de entrada en consumer-vpc que deniegue la subred de Vertex AI Pipeline (192.168.10.0/28) a test-svc-2. Confirma la falla de PING según los registros del firewall generados por el Explorador de registros.

Qué aprenderás

  • Cómo crear un adjunto de red
  • Cómo Vertex AI Pipelines puede usar una conexión de red para crear una interfaz de PSC
  • Cómo establecer la comunicación del productor al consumidor
  • Cómo permitir el acceso desde Vertex AI Pipelines a la VM del consumidor, test-svc-1
  • Cómo denegar el acceso desde Vertex AI Pipelines a la VM del consumidor, test-svc-2, con Cloud Firewall

Requisitos

2. Antes de comenzar

En este instructivo, se usan variables para facilitar la implementación de la configuración de gcloud en Cloud Shell.

Dentro de Cloud Shell, haz lo siguiente:

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

Actualiza el proyecto para que admita el instructivo

Dentro de Cloud Shell, haz lo siguiente:

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. Configuración del consumidor

Crea la VPC del consumidor

Dentro de Cloud Shell, haz lo siguiente:

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

Crea las subredes de consumidor

Dentro de Cloud Shell, haz lo siguiente:

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

Dentro de Cloud Shell, haz lo siguiente:

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

Dentro de Cloud Shell, haz lo siguiente:

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

Configuración de Cloud Router y NAT

En el instructivo, se usa la Traducción de direcciones de red (NAT) de Cloud para las descargas de paquetes de software de notebooks, ya que la instancia de notebook no tiene una dirección IP externa. Cloud NAT ofrece capacidades de NAT de salida, lo que significa que los hosts de Internet no pueden iniciar la comunicación con un notebook administrado por el usuario, lo que lo hace más seguro.

Dentro de Cloud Shell, crea el Cloud Router regional.

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

Dentro de Cloud Shell, crea la puerta de enlace de Cloud NAT regional.

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 subred del adjunto de red de Private Service Connect

Dentro de Cloud Shell, crea la subred de adjuntos de red que usa 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. Habilita Identity-Aware Proxy (IAP)

Para permitir que IAP se conecte a tus instancias de VM, crea una regla de firewall que cumpla con lo siguiente:

  • Se aplica a todas las instancias de VM a las que deseas acceder mediante IAP.
  • Permite el tráfico de entrada desde el rango de IP 35.235.240.0/20. Este rango contiene todas las direcciones IP que IAP usa para el reenvío de TCP.

Dentro de Cloud Shell, crea la regla de firewall de IAP.

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

5. Crea instancias de VM de consumidor

Dentro de Cloud Shell, crea la instancia de VM del consumidor, 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

Dentro de Cloud Shell, crea la instancia de VM del consumidor, 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

Obtén y almacena las direcciones IP de las instancias:

En Cloud Shell, ejecuta una descripción en las instancias de VM de prueba.

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:

Ejemplo:

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. Adjunto de red de Private Service Connect

Los adjuntos de red son recursos regionales que representan el lado del consumidor de una interfaz de Private Service Connect. Debes asociar una sola subred con un adjunto de red, y el productor (Vertex AI Pipelines) asigna IPs a la interfaz de Private Service Connect.

Crea el adjunto de red

Dentro de Cloud Shell, crea la conexión de red.

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

Enumera los archivos adjuntos de red

Dentro de Cloud Shell, enumera el adjunto de red.

gcloud compute network-attachments list

Describe los adjuntos de red

Dentro de Cloud Shell, describe el adjunto de red.

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

Toma nota del URI de psc-network-attachment que usará el productor cuando cree la interfaz de Private Service Connect.

En el siguiente ejemplo, el URI del adjunto de red de PSC es el siguiente:

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. Configuración de Vertex AI Workbench

En la siguiente sección, se explica cómo crear un notebook de Jupyter. Este notebook se usará para implementar un trabajo de canalización que envíe un PING desde Vertex AI Pipelines a las instancias de prueba. La ruta de datos entre Vertex AI Pipelines y la red del consumidor que contiene las instancias usa una interfaz de red de Private Service Connect.

Crea una cuenta de servicio administrada por el usuario

En la siguiente sección, crearás una cuenta de servicio que se asociará con la instancia de Vertex AI Workbench que se usa en el instructivo.

En el instructivo, la cuenta de servicio tendrá los siguientes roles aplicados:

Dentro de Cloud Shell, crea la cuenta de servicio.

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

En Cloud Shell, actualiza la cuenta de servicio con el rol de administrador de Storage.

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

Dentro de Cloud Shell, actualiza la cuenta de servicio con el rol de usuario de Vertex AI.

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

Dentro de Cloud Shell, actualiza la cuenta de servicio con el rol de administrador de Artifact Registry.

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

Dentro de Cloud Shell, permite que la cuenta de servicio del notebook use la cuenta de servicio predeterminada de Compute Engine para crear una instancia del trabajo de la canalización.

gcloud iam service-accounts add-iam-policy-binding \
    $(gcloud projects describe $(gcloud config get-value project) --format='value(projectNumber)')-compute@developer.gserviceaccount.com \
    --member="serviceAccount:notebook-sa@$projectid.iam.gserviceaccount.com" \
    --role="roles/iam.serviceAccountUser"

Crea una instancia de Vertex AI Workbench

En la siguiente sección, crea una instancia de Vertex AI Workbench que incorpore la cuenta de servicio creada anteriormente, notebook-sa.

Dentro de Cloud Shell, crea la instancia 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. Conectividad de Vertex AI Pipelines a test-svc-1

Abre una pestaña nueva de Cloud Shell y actualiza la configuración de tu proyecto.

Dentro de Cloud Shell, haz lo siguiente:

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

Para permitir la conectividad de Vertex AI Pipelines a test-svc-1, crea reglas de firewall de entrada que especifiquen la vinculación de red de PSC como origen (192.168.10.0/28) y la dirección IP de test-svc-1 como destino.

Dentro de Cloud Shell, actualiza el rango de destino para que coincida con la dirección 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

Ejemplo:

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

Accede a la instancia test-svc-1 con IAP en Cloud Shell.

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

En el SO, ejecuta tcpdump para capturar cualquier tráfico icmp. Esta sesión del SO se usará para validar la comunicación entre Vertex AI Pipelines y la VM.

sudo tcpdump -i any icmp -nn

9. Actualización del agente de servicio de Vertex AI

Vertex AI Pipelines actúa en tu nombre para realizar operaciones, como obtener una dirección IP de la subred del adjunto de red de PSC que se usa para crear la interfaz de PSC. Para ello, Vertex AI Pipelines usa un agente de servicio (que se indica a continuación) que requiere permiso de administrador de red.

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

En Cloud Shell, obtén el número de tu proyecto.

gcloud projects describe $projectid | grep projectNumber

Ejemplo:

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

Dentro de Cloud Shell, actualiza la cuenta del agente de servicio con el rol compute.networkAdmin.

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

Ejemplo:

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

10. Actualización de la cuenta de servicio predeterminada

Habilita la API de Compute Engine y otorga acceso a tu cuenta de servicio predeterminada a Vertex AI. Ten en cuenta que el cambio de acceso puede tardar un poco en propagarse.

En Cloud Shell, actualiza la cuenta de servicio predeterminada con el rol aiplatform.user.

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

Ejemplo:

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

11. Implementa un trabajo de Vertex AI Pipelines

En la siguiente sección, crearás un notebook para realizar un PING exitoso a la instancia de consumer test-svc-1.

Ejecuta el trabajo de entrenamiento en la instancia de Vertex AI Workbench.

  1. En la consola de Google Cloud, ve a la pestaña Instancias en la página de Vertex AI Workbench.
  2. Junto al nombre de la instancia de Vertex AI Workbench (workbench-tutorial), haz clic en Open JupyterLab. Tu instancia de Vertex AI Workbench abre JupyterLab.
  3. Selecciona Archivo > Nuevo > Notebook.
  4. Selecciona Kernel > Python 3.
  5. En una celda de notebook nueva, ejecuta el siguiente comando para asegurarte de tener la versión más reciente de pip:
! pip3 install --upgrade --quiet google-cloud-aiplatform \
  kfp \
  google-cloud-pipeline-components
  1. Configura las variables del proyecto en la nueva celda del notebook
PROJECT_ID = "<your-projectid>" 
REGION = "<your-region>"  
NETWORK_ATTACHMENT_NAME = "psc-network-attachment"

Ejemplo:

PROJECT_ID = "psc-vertex" 
REGION = "us-central1"  
NETWORK_ATTACHMENT_NAME = "psc-network-attachment"
  1. Define un nombre de bucket único a nivel global como una variable en una celda de notebook nueva
BUCKET_URI = f"gs://<your-bucket-name>"

Ejemplo:

BUCKET_URI = f"gs://psc-vertex-bucket"
  1. En una celda de notebook nueva, crea el bucket.
! gsutil mb -l {REGION} -p {PROJECT_ID} {BUCKET_URI}

En la siguiente sección, determinarás la cuenta de servicio predeterminada de Compute Engine que se usará para ejecutar el trabajo de la canalización y le otorgarás los permisos correctos.

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

Para confirmar que la ejecución se realizó correctamente, se imprimirán tu cuenta de servicio y tu número de proyecto.

  1. En una nueva celda del notebook, otorga permiso a tu cuenta de servicio para leer y escribir artefactos de canalización en el bucket creado en el paso anterior.
! gsutil iam ch serviceAccount:{SERVICE_ACCOUNT}:roles/storage.objectCreator {BUCKET_URI}

! gsutil iam ch serviceAccount:{SERVICE_ACCOUNT}:roles/storage.objectViewer {BUCKET_URI}
  1. En una celda de notebook nueva, define los parámetros de la canalización. Ten en cuenta que NETWORK_ATTACHMENT_NAME es el adjunto de red de PSC, por lo que debe coincidir.
PIPELINE_ROOT = f"{BUCKET_URI}/pipeline_root/psc_test"
NETWORK_ATTACHMENT_URI = f"projects/{PROJECT_NUMBER}/regions/{REGION}/networkAttachments/{NETWORK_ATTACHMENT_NAME}"
  1. En una nueva celda del notebook, inicializa el SDK de 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. En una celda de notebook nueva, define el componente de prueba.
@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. En una celda de notebook nueva, define la canalización.
@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. En una nueva celda del notebook, ejecuta la función de utilidad y espera a que finalice la canalización.
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. En una celda de notebook nueva, ejecuta la función de utilidad para ejecutar la canalización.
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. En una celda nueva del notebook, compila la canalización.
from kfp import compiler
compiler.Compiler().compile(pipeline_func=pipeline, package_path='pipeline.yaml')
  1. En una celda de notebook nueva, actualiza TARGET_IP_ADDRESS para que refleje la dirección IP obtenida en el paso anterior para test-svc-1 y observa el estado del trabajo de la canalización.
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}")

Ejemplo:

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 vez que se ejecute el paso 17, la canalización tardará alrededor de 8 minutos en completarse.

12. Valida la conectividad con test-svc-1

En la celda que se usa para ejecutar el paso 17, observa la transición del estado del trabajo de canalización de PIPELINE_STATE_PENDING a PIPELINE_STATE_RUNNING y, por último, a PIPELINE_STATE_SUCCEEDED, lo que indica que se realizó correctamente el ping desde Vertex AI Pipelines y la respuesta desde test-svc-1.

Para validar el tráfico de ICMP entre Vertex AI Pipeline y test-svc-1, consulta la sesión de tcpdump generada anteriormente que se ejecutó en el SO de test-svc-1 y que proporciona registros que indican tráfico bidireccional.

En el ejemplo de tcpdump, Vertex AI Pipelines obtuvo la dirección IP 192.168.10.3 de la subred 192.168.10.0/28, y 192.168.20.2 es la dirección IP de test-svc-1. Ten en cuenta que, en tu entorno, las direcciones IP pueden ser diferentes.

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. Conectividad de la IA de Vertex AI Pipelines a test-svc-2

En la siguiente sección, crearás una regla de firewall de entrada para rechazar el tráfico de la subred de Vertex AI Pipelines (192.168.10.0/28) a test-svc-2. Luego, actualizarás el notebook para que refleje la dirección IP de test-svc-2 y, por último, ejecutarás la ejecución de los trabajos de Pipelines.

En la celda del notebook, el estado del trabajo de la canalización indicará Error: Falló la canalización. Además, los registros del firewall proporcionarán estadísticas sobre la conexión fallida.

Crea una regla de firewall de entrada de denegación

Para denegar la conectividad de Vertex AI Pipelines a test-svc-2, crea reglas de firewall de entrada que especifiquen la conexión de red de PSC como origen (192.168.10.0/28) y la dirección IP de test-svc-2 como destino.

Dentro de Cloud Shell, actualiza el rango de destino para que coincida con la dirección 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

Ejemplo:

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

Ejecuta el trabajo de canalización desde la celda del notebook

En una celda de notebook nueva, actualiza TARGET_IP_ADDRESS para que refleje la dirección IP obtenida en el paso anterior para test-svc-2 y observa el estado del trabajo de 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}")

Ejemplo:

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 vez ejecutado, el trabajo de canalización tardará alrededor de 8 minutos en completarse.

14. No se pudo validar la conectividad con test-svc-2

En la celda que se usa para ejecutar el trabajo de canalización, observa la transición de estado de PIPELINE_STATE_PENDING a PIPELINE_STATE_FAILED, que indica un ping sin éxito de Vertex AI Pipelines y una respuesta de test-svc-2.

Con el Explorador de registros, puedes ver las entradas del registro de firewall que coinciden con la regla de denegación de entrada que consta de la subred de Vertex AI Pipelines (192.168.10.0/28) y la dirección IP de test-svc-2.

Selecciona Mostrar consulta y, luego, inserta el siguiente filtro (últimos 15 minutos) y selecciona Ejecutar consulta.

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

20e072f26d9a113b.png

5fb3d2de0a85e3c6.png

Selecciona una entrada de registro y, luego, expande los campos anidados para revelar los elementos de información que constan de la dirección IP de Vertex AI Pipelines y test-svc-2 que validan la regla de firewall de entrada denegada.

903aaf2c10d07460.png

15. Limpia

Borra los componentes del instructivo desde Cloud Shell.

gcloud compute instances delete test-svc-1 test-svc-2 --zone=us-central1-a --quiet

gcloud workbench instances delete workbench-tutorial --location=us-central1-a --quiet

gcloud compute firewall-rules delete deny-icmp-vertex-pipelines-to-test-svc2-vm allow-icmp-vertex-pipelines-to-test-svc1-vm ssh-iap-consumer --quiet

gcloud compute routers nats delete cloud-nat-us-central1 --router=cloud-router-us-central1 --region us-central1 --quiet

gcloud compute routers delete cloud-router-us-central1 --region=us-central1 --quiet

16. Felicitaciones

Felicitaciones. Configuraste y validaste correctamente una interfaz de Private Service Connect y la conectividad del consumidor y el productor implementando el firewall de entrada permitido y denegado.

Creaste la infraestructura del consumidor y agregaste un adjunto de red que permitió que el servicio de Vertex AI Pipelines creara una VM de interfaz de PSC para conectar la comunicación entre el consumidor y el productor. Aprendiste a crear reglas de firewall en la red de VPC del consumidor que permitían y rechazaban la conectividad a las instancias en la red del consumidor.

Cosmopup cree que los instructivos son geniales.

c911c127bffdee57.jpeg

¿Qué sigue?

Lecturas y videos adicionales

Documentos de referencia