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, que se implementa en un proyecto de usuario administrado por Google, aprovechará el adjunto de red de PSC para crear una instancia de varios NIC entre la red de productor y la de consumidor. Dado que el adjunto de red de PSC se implementa con un NIC múltiple de la red del consumidor, Vertex AI Pipelines puede llegar a las rutas disponibles desde la red del consumidor.

En este instructivo, crearás una arquitectura de interfaz de Private Service Connect (PSC) integral para las canalización de Vertex AI que utilice reglas de firewall de Cloud 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) acceda a test-svc-1. Confirma que se haya generado un PING correcto desde el trabajo de canalización a test-svc-1 con TCPDUMP
  2. Crea una regla de firewall de entrada en consumer-vpc que niegue la subred de canalización de Vertex AI (192.168.10.0/28) a test-svc-2. Confirma la falla de PING en función de los registros del firewall que genera el Explorador de registros.

Qué aprenderás

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

Requisitos

2. Antes de comenzar

En este instructivo, se usan $variables para ayudar a implementar la configuración de gcloud en Cloud Shell.

En 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 admitir el instructivo

En 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 de consumidor

En Cloud Shell, haz lo siguiente:

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

Crea las subredes de consumidor

En 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

En 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

En 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 para descargar paquetes de software de notebooks, se usa la Traducción de direcciones de red (NAT) de Cloud, ya que la instancia del 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 una notebook administrada por el usuario, lo que la hace más segura.

En Cloud Shell, crea el router de nube regional.

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

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

En Cloud Shell, crea la subred de conexión 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.

En 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

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

En Cloud Shell, crea la instancia de VM de 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, realiza una descripción de 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 IP a la interfaz de Private Service Connect.

Crea el adjunto de red

En Cloud Shell, crea el adjunto de red.

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

Cómo mostrar una lista de los archivos adjuntos de red

En Cloud Shell, enumera el adjunto de red.

gcloud compute network-attachments list

Describe los archivos adjuntos de red

En Cloud Shell, describe el adjunto de red.

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

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

En el siguiente ejemplo, el URI del archivo 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 te guiará para crear un notebook de Jupyter. Este notebook se usará para implementar un trabajo de canalización que envíe un PING de Vertex AI Pipelines a las instancias de prueba. La ruta de datos entre Vertex AI Pipelines y la red de consumidores 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, se aplicarán los siguientes roles a la cuenta de servicio:

En 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 Administrador de almacenamiento.

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

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

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

En 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 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 notebook-sa que creaste anteriormente.

Dentro de Cloud Shell, crea la instancia de cliente privado.

gcloud workbench instances create workbench-tutorial --vm-image-project=deeplearning-platform-release --vm-image-family=common-cpu-notebooks --machine-type=n1-standard-4 --location=us-central1-a --subnet-region=us-central1 --subnet=workbench-subnet --disable-public-ip --shielded-secure-boot=true --service-account-email=notebook-sa@$projectid.iam.gserviceaccount.com

8. Vertex AI Pipelines para la conectividad de test-svc-1

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

En 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 las canalización de Vertex AI a test-svc-1, crea una regla de firewall de entrada que especifique el archivo adjunto de red de PSC como la fuente (192.168.10.0/28) y la dirección IP de test-svc-1 como el destino.

En 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 Pipeline 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 de 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 el 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'

En 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 predeterminada de la cuenta de servicio

Habilita la API de Compute Engine y otorga a tu cuenta de servicio predeterminada acceso 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 correcto a la instancia de consumidor 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 de instancias en la página de Vertex AI Workbench.
  2. Junto al nombre de tu instancia de Vertex AI Workbench (workbench-tutorial), haz clic en Abrir JupyterLab. Tu instancia de Vertex AI Workbench abre JupyterLab.
  3. Selecciona File > New > Notebook.
  4. Selecciona Kernel > Python 3.
  5. En una celda nueva del notebook, 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 de tu 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 nueva del notebook
BUCKET_URI = f"gs://<your-bucket-name>"

Ejemplo:

BUCKET_URI = f"gs://psc-vertex-bucket"
  1. En una celda nueva del notebook, 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 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 imprimen tu cuenta de servicio y número de proyecto.

  1. En una celda nueva del notebook, otorga a tu cuenta de servicio permiso 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 nueva del notebook, define los parámetros de la canalización. Ten en cuenta que NETWORK_ATTACHMENT_NAME es el archivo 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 celda nueva 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 nueva del notebook, 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 nueva del notebook, 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 celda nueva del notebook, ejecuta la función de utilidad y espera a que termine 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 nueva celda del notebook, actualiza TARGET_IP_ADDRESS para que refleje la dirección IP obtenida en el paso anterior para test-svc-1 y observa el estado de la tarea 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 a test-svc-1

En la celda que se usó 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, finalmente, a PIPELINE_STATE_SUCCEEDED, que indica que se realizó correctamente un ping de Vertex AI Pipelines y la respuesta de test-svc-1.

Para validar el tráfico ICMP entre la canalización de Vertex AI y test-svc-1, consulta la sesión de tcpdump generada anteriormente que se ejecutó en el SO 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, 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 Vertex AI Pipelines AI a test-svc-2

En la siguiente sección, crearás una regla de firewall de entrada para denegar 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 trabajos de Pipelines.

En la celda del notebook, el estado del trabajo de canalización indicará Error: Canalización fallida. 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 las canalización de Vertex AI a test-svc-2, crea una regla de firewall de entrada que especifique el archivo adjunto de red de PSC como la fuente (192.168.10.0/28) y la dirección IP de test-svc-2 como el destino.

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

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 de notebook

En una celda nueva del notebook, actualiza TARGET_IP_ADDRESS para que refleje la dirección IP obtenida en el paso anterior para test-svc-2 y observa el estado de la tarea 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 que se ejecute, el trabajo de canalización tardará unos 8 minutos en completarse.

14. Valida la conectividad fallida a test-svc-2

En la celda que se usa para ejecutar el trabajo de Pipelines, observa la transición de estado de PIPELINE_STATE_PENDING a PIPELINE_STATE_FAILED, lo que indica que no se pudo realizar un ping de Vertex AI Pipelines y la respuesta de test-svc-2.

Con el Explorador de registros, puedes ver las entradas de 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 test-svc-2.

Selecciona Mostrar consulta y, luego, inserta el siguiente filtro: últimos 15 minutos seguido de 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 consisten en Vertex AI Pipelines y la dirección IP test-svc-2 que validan la regla de firewall de entrada rechazada.

903aaf2c10d07460.png

15. Limpia

En Cloud Shell, borra los componentes del instructivo.

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 de consumidores y productores mediante la implementación de un firewall de entrada de permiso y denegación.

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 unir la comunicación entre el consumidor y el productor. Aprendiste a crear reglas de firewall en la red de VPC del consumidor que permitieron y rechazaron la conectividad a las instancias de la red del consumidor.

Cosmopup piensa que los instructivos son geniales.

c911c127bffdee57.jpeg

¿Qué sigue?

Lecturas adicionales y videos

Documentos de referencia