Vertex AI Pipelines PSC Interface SWP

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 VPC de consumidor. Las redes de productores y consumidores pueden estar en diferentes proyectos y organizaciones.

Si un adjunto de red acepta una conexión desde una interfaz de Private Service Connect, Google Cloud asigna a la interfaz una dirección IP de una subred de consumidor que especifica el adjunto de red. Las redes del consumidor y del productor están conectadas y pueden comunicarse mediante direcciones IP internas.

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.

d7dc28d6567e6283.pngFigura 1

Consideraciones sobre la accesibilidad de la interfaz de PSC de Vertex AI

  • La interfaz de PSC de Vertex AI puede enrutar el tráfico a destinos en una VPC o en las instalaciones dentro del bloque de direcciones RFC1918.
  • El destino de la interfaz de PSC a bloques de direcciones que no son RFC-1918 requiere un proxy explícito implementado en la VPC del consumidor con una dirección RFC-1918. Dentro de la implementación de Vertex AI, el proxy se debe definir junto con un FQDN del extremo de destino. Consulta la figura 1, que representa el modo de proxy explícito del proxy web seguro (SWP) configurado en la VPC del consumidor para facilitar el enrutamiento a los siguientes CIDR que no son RFC-1918:
  1. 240.0.0.0/4
  2. 203.0.113.0/24
  3. 10.10.20.0/28 no requiere proxy y se encuentra dentro del rango RFC-1918.
  4. Salida de Internet

Conexión a Internet para la red de usuarios administrados por Google:

Interfaz de PSC de Vertex AI sin VPC-SC

  • Cuando configuras tu implementación solo con una interfaz de PSC, esta conserva su acceso predeterminado a Internet. Este tráfico saliente sale directamente de la red de usuarios administrada por Google.

Interfaz de PSC de Vertex AI con VPC-SC

  • Cuando tu proyecto forma parte de un perímetro de los Controles del servicio de VPC, el perímetro bloquea el acceso predeterminado a Internet del arrendatario administrado por Google para evitar el robo de datos.
  • Para permitir que la implementación acceda a Internet pública en esta situación, debes configurar de forma explícita una ruta de salida segura que dirija el tráfico a través de tu VPC conectada a Vertex AI. Implementar un servidor proxy dentro de la red de VPC con dirección RFC 1918, junto con una puerta de enlace de Cloud NAT, es una forma de lograrlo. Ten en cuenta que también puedes usar el proxy web seguro para reenviar el tráfico a Internet. La creación del proxy web seguro crea automáticamente una puerta de enlace de Cloud NAT.

Para obtener más información, consulta los siguientes recursos:

Configura una interfaz de Private Service Connect para los recursos de Vertex AI | Google Cloud

Qué compilarás

En este instructivo, compilarás una implementación integral de Vertex AI Pipelines con una interfaz de Private Service Connect (PSC) para permitir la conectividad desde el productor hasta el procesamiento del consumidor, como se ilustra en la figura 1, con el objetivo de un extremo que no sea RFC 1918 en class-e-subnet.

2d095dc2f4de6b4b.pngFigura 2

Crearás un solo psc-network-attachment en la VPC del consumidor aprovechando el intercambio de tráfico de DNS para resolver las VMs de los consumidores en el proyecto del inquilino que aloja Vertex AI Training, lo que generará los siguientes casos de uso:

Implementa Vertex AI Pipelines y configura el Proxy web seguro en un modo de proxy explícito, lo que le permite realizar un wget en una VM de la subred de clase E.

Qué aprenderás

  • Cómo crear un adjunto de red
  • Cómo un productor puede usar un adjunto de red para crear una interfaz de PSC
  • Cómo establecer el intercambio de tráfico de DNS para resolver dominios privados configurados en la red de VPC del consumidor desde las redes de VPC administradas por Google
  • Cómo reenvía el tráfico desde la interfaz de PSC de Vertex AI a Secure Web Proxy
  • Cómo establecer la comunicación con el espacio de direcciones IP que no son RFC-1918 desde Vertex AI Pipelines

Requisitos

Proyecto de Google Cloud

Permisos de IAM

2. Antes de comenzar

Actualiza el proyecto para que admita el instructivo

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-ID]
projectid=YOUR-PROJECT-ID
echo $projectid

Habilitación de la API

Dentro de Cloud Shell, haz lo siguiente:

gcloud services enable "compute.googleapis.com"
gcloud services enable "aiplatform.googleapis.com"
gcloud services enable "dns.googleapis.com"
gcloud services enable "notebooks.googleapis.com"
gcloud services enable "storage.googleapis.com"
gcloud services enable "cloudresourcemanager.googleapis.com"
gcloud services enable "artifactregistry.googleapis.com"
gcloud services enable "cloudbuild.googleapis.com"
gcloud services enable "networkservices.googleapis.com"
gcloud services enable "networksecurity.googleapis.com"
gcloud services enable "certificatemanager.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 class-e-subnet --project=$projectid --range=240.0.0.0/4 --network=consumer-vpc --region=us-central1

Dentro de Cloud Shell, haz lo siguiente:

gcloud compute networks subnets create rfc1918-subnet1 --project=$projectid --range=10.10.10.0/28 --network=consumer-vpc --region=us-central1 --enable-private-ip-google-access

Crea la subred de solo proxy

gcloud compute networks subnets create proxy-only-uscentral1 \
    --purpose=REGIONAL_MANAGED_PROXY \
    --role=ACTIVE \
    --region=us-central1 \
    --network=consumer-vpc \
    --range=10.10.100.0/26

Crea la subred del adjunto de red de Private Service Connect

Dentro de Cloud Shell, haz lo siguiente:

gcloud compute networks subnets create intf-subnet \
--project=$projectid \
--range=192.168.10.0/28 \
--network=consumer-vpc \
--region=us-central1 \
--enable-private-ip-google-access

Configuración de Cloud Router y NAT

El Proxy web seguro de Google Cloud aprovisiona y administra automáticamente una puerta de enlace de Cloud NAT y un Cloud Router asociado en la región en la que se implementa.

4. Habilitar IAP

Para permitir que IAP (proxy de Identity-Aware) 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, class-e-vm.

gcloud compute instances create class-e-vm \
    --project=$projectid \
    --machine-type=e2-micro \
    --image-family debian-11 \
    --no-address \
    --shielded-secure-boot \
    --image-project debian-cloud \
    --zone us-central1-a \
    --subnet=class-e-subnet \ 
    --private-network-ip=240.0.0.2

6. Proxy web seguro

El modo explícito de Secure Web Proxy (o modo de enrutamiento de proxy explícito) es un método de implementación en el que las cargas de trabajo del cliente se deben configurar de forma explícita para usar la dirección IP interna o el nombre de dominio completamente calificado y el puerto de SWP como su proxy de reenvío.

En los siguientes pasos, asegúrate de modificar YOUR-PROJECT-ID por el ID de tu proyecto.

Crea un proxy web:

En Cloud Shell, crea el archivo policy.yaml con un editor de texto:

cat > policy.yaml << EOF
description: basic Secure Web Proxy policy
name: projects/$projectid/locations/us-central1/gatewaySecurityPolicies/policy1
EOF

En Cloud Shell, genera la política del Proxy web seguro:

gcloud network-security gateway-security-policies import policy1 \
    --source=policy.yaml \
    --location=us-central1

En la siguiente sección, crea una regla para permitir el acceso a class-e-vm según el host sessionMatcher.

En Cloud Shell, crea el archivo rule1.yaml con un editor de texto:

cat > rule1.yaml << EOF
name: projects/$projectid/locations/us-central1/gatewaySecurityPolicies/policy1/rules/allow-nonrfc-classe
description: Allow nonrfc class-e
enabled: true
priority: 1
basicProfile: ALLOW
sessionMatcher: host() == 'class-e-vm.demo.com'
EOF

En la siguiente sección, crea una regla para permitir que el notebook de Jupyter acceda a la VM de "class-e" y, así, permitir la instalación de apache2.

En Cloud Shell, crea el archivo rule2.yaml con un editor de texto:

cat > rule2.yaml << EOF
name: projects/$projectid/locations/us-central1/gatewaySecurityPolicies/policy1/rules/allow-apache2
description: Allow Apache2 install on class-e VM
enabled: true
priority: 2
basicProfile: ALLOW
sessionMatcher: inIpRange(source.ip,'240.0.0.2')
EOF

En Cloud Shell, genera la regla1 de la política de seguridad:

gcloud network-security gateway-security-policies rules import allow-nonrfc-classe \
    --source=rule1.yaml \
    --location=us-central1 \
    --gateway-security-policy=policy1

En Cloud Shell, genera la regla2 de la política de seguridad:

gcloud network-security gateway-security-policies rules import allow-apache2 \
    --source=rule2.yaml \
    --location=us-central1 \
    --gateway-security-policy=policy1

Para admitir Vertex AI Training, configura la puerta de enlace del proxy web seguro con estos parámetros de configuración:

  • Puerto de escucha: Usa el mismo puerto configurado en la configuración explícita del proxy del código de la aplicación de Vertex AI (p.ej., 8080).
  • Dirección: Asigna una dirección IP privada del rango RFC 1918.
  • Modo de enrutamiento: Establece este parámetro en EXPLICIT_ROUTING_MODE.

En Cloud Shell, crea un archivo gateway.yaml para definir la puerta de enlace del proxy web seguro:

cat > gateway.yaml << EOF
name: projects/$projectid/locations/us-central1/gateways/swp1
type: SECURE_WEB_GATEWAY
addresses: ["10.10.10.5"]
ports: [8080]
gatewaySecurityPolicy: projects/$projectid/locations/us-central1/gatewaySecurityPolicies/policy1
network: projects/$projectid/global/networks/consumer-vpc
subnetwork: projects/$projectid/regions/us-central1/subnetworks/rfc1918-subnet1
routingMode: EXPLICIT_ROUTING_MODE
EOF

En Cloud Shell, genera la instancia del proxy web seguro:

gcloud network-services gateways import swp1 \
    --source=gateway.yaml \
    --location=us-central1

La implementación de un proxy web seguro puede tardar varios minutos.

e8a4cf23bfc63030.png

7. 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 asigna IPs a la interfaz de Private Service Connect desde esa subred. La subred debe estar en la misma región que el adjunto de red. Un adjunto de red debe estar en la misma región que el servicio del productor.

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

Nota: No es necesario que menciones explícitamente el ID del proyecto aceptado en este adjunto. Cuando se configura el proyecto de inquilino administrado por Google de Vertex AI, se agrega automáticamente como si estuviera configurado como "Aceptar automáticamente".

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 nombre del adjunto de red de PSC, psc-network-attachment, que usará el productor cuando cree la interfaz de Private Service Connect.

Para ver la URL de la conexión de red de PSC en la consola de Cloud, navega a la siguiente ubicación:

Servicios de red → Private Service Connect → Adjunto de red → psc-network-attachment

b969cca5242d9c8a.png

8. Zona de DNS privada

Crearás una zona de Cloud DNS para demo.com y la propagarás con registros A que apunten a las direcciones IP de tus VMs. Más adelante, se implementará el intercambio de tráfico de DNS en el trabajo de Vertex AI Pipelines, lo que le permitirá acceder a los registros de DNS del consumidor.

Dentro de Cloud Shell, haz lo siguiente:

gcloud dns --project=$projectid managed-zones create private-dns-codelab --description="" --dns-name="demo.com." --visibility="private" --networks="https://compute.googleapis.com/compute/v1/projects/$projectid/global/networks/consumer-vpc"

Dentro de Cloud Shell, crea el conjunto de registros para la VM, class-e-vm, y asegúrate de actualizar la dirección IP según el resultado de tu entorno.

gcloud dns --project=$projectid record-sets create class-e-vm.demo.com. --zone="private-dns-codelab" --type="A" --ttl="300" --rrdatas="240.0.0.2"

En Cloud Shell, crea el conjunto de registros para el proxy web seguro y asegúrate de actualizar la dirección IP según el resultado de tu entorno.

gcloud dns --project=$projectid record-sets create explicit-swp.demo.com. --zone="private-dns-codelab" --type="A" --ttl="300" --rrdatas="10.10.10.5"

Crea una regla de Cloud Firewall para permitir el acceso desde la interfaz de PSC

En la siguiente sección, crea una regla de firewall que permita que el tráfico que se origina en el adjunto de red de PSC acceda a los recursos de procesamiento de RFC 1918 en la VPC del consumidor.

En Cloud Shell, crea la regla de firewall de entrada que permite el acceso desde la subred de solo proxy a la subred de clase E. Como SWP inicia la conexión con la subred solo de proxy como dirección de origen.

gcloud compute firewall-rules create allow-access-to-class-e \
    --network=consumer-vpc \
    --action=ALLOW \
    --rules=ALL \
    --direction=INGRESS \
    --priority=1000 \
    --source-ranges="10.10.100.0/28" \
    --destination-ranges="240.0.0.0/4" \
    --enable-logging

9. Crea un notebook de Jupyter

En la siguiente sección, se te guiará para crear un notebook de Jupyter. Este notebook se usará para implementar un trabajo de Vertex AI Pipelines que envíe un wget 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 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:

Accede a Cloud Shell y realiza las siguientes acciones:

Crea la cuenta de servicio.

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

Actualiza la cuenta de servicio con el rol de administrador de almacenamiento.

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

Actualiza la cuenta de servicio con el rol de usuario de AI Platform.

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

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"

Actualiza la cuenta de servicio con el rol de editor de Cloud Build.

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

Permite que la cuenta de servicio del notebook use la cuenta de servicio predeterminada de Compute Engine.

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"

10. 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 del cliente privado.

gcloud workbench instances create workbench-tutorial --vm-image-project=cloud-notebooks-managed --vm-image-family=workbench-instances --machine-type=n1-standard-4 --location=us-central1-a --subnet-region=us-central1 --subnet=rfc1918-subnet1 --disable-public-ip --shielded-secure-boot=true --shielded-integrity-monitoring=true --shielded-vtpm=true --service-account-email=notebook-sa@$projectid.iam.gserviceaccount.com

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

Vertex AI 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 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

Nota: Antes de actualizar los permisos del agente de servicio, navega a Vertex AI en la consola de Cloud para asegurarte de que la API de Vertex AI esté habilitada.

En Cloud Shell, haz lo siguiente:

Obtén tu número de proyecto.

gcloud projects describe $projectid | grep projectNumber

Configura tu número de proyecto.

projectnumber=YOUR-PROJECT-NUMBER

Crea una cuenta de servicio para AI Platform. Omite este paso si ya tienes una cuenta de servicio en tu proyecto.

gcloud beta services identity create --service=aiplatform.googleapis.com --project=$projectnumber

Actualiza la cuenta del agente de servicio con el rol compute.networkAdmin.

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

Actualiza la cuenta del agente de servicio con el rol dns.peer.

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

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.

Usa Cloud Shell para actualizar la cuenta de servicio predeterminada de la siguiente manera:

Actualiza la cuenta de servicio predeterminada con el rol aiplatform.user

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

Actualiza la cuenta de servicio predeterminada con el rol storage.admin

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

Actualiza la cuenta de servicio predeterminada con el rol artifactregistry.admin

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

12. Instala Apache2 y habilita Tcpdump en “class-e-vm”:

Desde class-e-vm, instala apache2 a través de Secure Web Proxy:

Abre una nueva pestaña de Cloud Shell, actualiza la variable de tu proyecto y accede a class-e-vm con SSH.

gcloud compute ssh --zone us-central1-a "class-e-vm" --tunnel-through-iap --project $projectid

sudo apt-get -o Acquire::http::Proxy="http://10.10.10.5:8080" update
sudo apt-get -o Acquire::http::Proxy="http://10.10.10.5:8080" install apache2 -y
sudo service apache2 restart
echo 'class-e Server !!' | sudo tee /var/www/html/index.html

Ejecuta el filtrado de tcpdump en la subred de solo proxy, que usa el Proxy web seguro para reenviar el tráfico a los destinos.

Desde el SO de la VM de clase E, ejecuta el filtrado de tcpdump en la subred de proxy-vm.

sudo tcpdump -i any net 10.10.100.0/24 -nn

Nota: Asegúrate de activar el Acceso privado a Google en la subred de la instancia de workbench-tutorial para que se abra la sesión de JupyterLab.

13. Implementa un trabajo de Vertex AI Pipelines

En la siguiente sección, crearás un notebook para realizar una wget exitosa desde Vertex AI Pipelines al proxy explícito. Esto te permite acceder a VMs que no son RFC 1918, como class-e-vm. No se requiere un proxy explícito para que Vertex AI Pipelines acceda a rfc1918-vm, ya que su destino es una dirección IP RFC 1918.

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.

En tu notebook de JupyterLab, crea una celda nueva, actualiza y ejecuta lo siguiente. Asegúrate de actualizar PROJECT_ID con los detalles de tu entorno.

import json
import requests
import pprint

PROJECT_ID = 'YOUR-PROJECT-ID' #Enter your project ID
PROJECT_NUMBER=!gcloud projects list --filter="project_id:$PROJECT_ID" --format="value(PROJECT_NUMBER)"
PROJECT_NUMBER=str(PROJECT_NUMBER).strip('[').strip(']').strip("'")
print(PROJECT_NUMBER)

En tu notebook de JupyterLab, crea una celda nueva y ejecuta lo siguiente.

# us-central1 is used for the codelab
REGION = "us-central1" #@param {type:"string"}
SERVICE_NAME = "aiplatform" #@param {type:"string"}
SERVICE ="{}.googleapis.com".format(SERVICE_NAME)
ENDPOINT="{}-{}.googleapis.com".format(REGION, SERVICE_NAME)
API_VERSION = "v1" # @param {type: "string"}

LOCATION = REGION

En tu notebook de JupyterLab, crea una celda nueva y ejecuta la siguiente configuración. Ten en cuenta los siguientes aspectos destacados:

  • proxy_server = "http://explicit-swp.demo.com:8080"
  • Un FQDN está asociado a la VM de proxy implementada en la VPC del consumidor. Usaremos la interconexión de DNS para resolver el FQDN en un paso posterior.
%%writefile main.py

import logging
import socket
import sys
import os

def make_api_request(url: str, proxy_vm_ip: str, proxy_vm_port: str):
    """
    Makes a GET request to a nonRFC-1918 API and saves the response.

    Args:
        url: The URL of the API to send the request to.
    """
    import requests

    try:
        # response = requests.get(url)
        proxy_server = f"http://explicit-swp.demo.com:8080" # replace it with your Secure Web proxy Ip-address and the port.

        proxies = {
          "http": proxy_server,
          "https": proxy_server,
        }

        response = requests.get(url, proxies=proxies)
        logging.info(response.text)

        response.raise_for_status()  # Raise an exception for bad status codes
        logging.info(f"Successfully fetched data from {url}")
    except requests.exceptions.RequestException as e:
        logging.error(f"An error occurred: {e}")
        raise e

if __name__ == '__main__':
  # Configure logging to print clearly to the console
  logging.basicConfig(
      level=logging.INFO,
      format='%(levelname)s: %(message)s',
      stream=sys.stdout
  )
  url_to_test = os.environ['NONRFC_URL']
  proxy_vm_ip = os.environ['PROXY_VM_IP']
  proxy_vm_port = os.environ['PROXY_VM_PORT']

  logging.info(f"url_to_test: {url_to_test}")
  logging.info(f"proxy_vm_ip: {proxy_vm_ip}")
  logging.info(f"proxy_vm_port: {proxy_vm_port}")
  make_api_request(url_to_test, proxy_vm_ip, proxy_vm_port)

En tu notebook de JupyterLab, crea una celda nueva y ejecuta lo siguiente.

%%writefile Dockerfile
FROM python:3.9-slim

RUN apt-get update && \
  apt-get install -y iputils-ping && \
  apt-get install -y wget

RUN pip install cloudml-hypertune requests kfp

COPY main.py /main.py

ENTRYPOINT ["python3", "/main.py"]

En tu notebook de JupyterLab, crea una celda nueva y ejecuta lo siguiente.

!gcloud artifacts repositories create pipelines-test-repo-psc --repository-format=docker --location=us-central1

En tu notebook de JupyterLab, crea una celda nueva y ejecuta lo siguiente.

IMAGE_PROJECT = PROJECT_ID
IMAGE_REPO = 'pipelines-test-repo-psc' 
IMAGE_NAME = 'nonrfc-ip-call'
TAG = 'v1'

IMAGE_URI= f'us-central1-docker.pkg.dev/{IMAGE_PROJECT}/{IMAGE_REPO}/{IMAGE_NAME}:{TAG}'
IMAGE_URI

En tu notebook de JupyterLab, crea una celda nueva y ejecuta lo siguiente.

!gcloud auth configure-docker us-docker.pkg.dev --quiet

En tu notebook de JupyterLab, crea una celda nueva y ejecuta lo siguiente. Ignora el error (gcloud.builds.submit) si está presente.

!gcloud builds submit --tag {IMAGE_URI} --region=us-central1

En tu notebook de JupyterLab, crea y ejecuta la siguiente celda. Ten en cuenta los siguientes aspectos destacados:

  • El intercambio de tráfico de DNS a las VPC de consumidor se configura con dnsPeeringConfigs (dnsPeeringConfigs) para el nombre de dominio demo.com.
  • El proxy web en modo de enrutamiento explícito aquí es explicit-swp.demo.com. La resolución se controla a través del intercambio de tráfico de DNS dentro de la VPC del consumidor.
  • El puerto 8080 es el puerto de escucha (predeterminado) configurado en Secure Web Proxy.
  • wget a class-e-vm-demo.com se resuelve a través del intercambio de tráfico de DNS.
  • El código especifica el "psc-network-attachment" para Vertex, lo que le permite utilizar la subred de adjunto de red para implementar dos instancias de la interfaz de PSC.
import json
from datetime import datetime


JOB_ID_PREFIX='test_psci-nonRFC' #@param {type:"string"}
JOB_ID = '{}_{}'.format(JOB_ID_PREFIX, datetime.now().strftime("%Y%m%d%H%M%S"))

# PSC-I configs

PRODUCER_PROJECT_ID = PROJECT_ID
DNS_DOMAIN = 'class-e-vm.demo.com' #@param {type:"string"}
NON_RFC_URL = f"http://{DNS_DOMAIN}"

PROXY_VM_IP = "explicit-swp.demo.com" #@param {type:"string"}
PROXY_VM_PORT = "8080" #@param {type:"string"}

CUSTOM_JOB = {
  "display_name": JOB_ID,
  "job_spec": {
      "worker_pool_specs": [
          {
           "machine_spec": {
             "machine_type": "n1-standard-4",
           },
           "replica_count": 1,
           "container_spec": {
             "image_uri": IMAGE_URI,
             "env": [{
               "name": "NONRFC_URL",
               "value": NON_RFC_URL
             },
             {
               "name": "PROXY_VM_IP",
               "value": PROXY_VM_IP
             },
             {
               "name": "PROXY_VM_PORT",
               "value": PROXY_VM_PORT
             }]
           },
         },
      ],
      "enable_web_access": True,
      "psc_interface_config": {
        "network_attachment": "psc-network-attachment",
        "dns_peering_configs": [
          {
            "domain": "demo.com.",
            "target_project": PROJECT_ID,
            "target_network": "consumer-vpc"
          },
        ]
      },
  }
}

print(json.dumps(CUSTOM_JOB, indent=2))

En tu notebook de JupyterLab, crea una celda nueva y ejecuta lo siguiente.

import requests
bearer_token = !gcloud auth application-default print-access-token
headers = {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer {}'.format(bearer_token[0]),
}

request_uri = f"https://{REGION}-aiplatform.googleapis.com/{API_VERSION}/projects/{PROJECT_NUMBER}/locations/{REGION}/customJobs/"

print("request_uri: ", request_uri)

En tu notebook de JupyterLab, crea una celda nueva y ejecuta lo siguiente.

response_autopush = requests.post(request_uri, json=CUSTOM_JOB, headers=headers)
response = response_autopush
print("response:", response)
if response.reason == 'OK':
  job_name = response.json()['name']
  job_id = job_name.split('/')[-1]
  print("Created Job: ", response.json()['name'])
else:
  print(response.text)

En tu notebook de JupyterLab, crea una celda nueva y ejecuta lo siguiente.

# Print KFP SDK version (should be >= 1.6)
! python3 -c "import kfp; print('KFP SDK version: {}'.format(kfp.__version__))"

# Print AI Platform version
! python3 -c "from google.cloud import aiplatform; print('AI Platform version: {}'.format(aiplatform.__version__))"

En tu notebook de JupyterLab, crea una celda nueva y ejecuta lo siguiente.

BUCKET_URI = "your-unique-bucket" # Provide a globally unique bucket name

En tu notebook de JupyterLab, crea una celda nueva y ejecuta lo siguiente.

!gcloud storage buckets create gs://{BUCKET_URI}

En tu notebook de JupyterLab, crea una celda nueva y ejecuta lo siguiente.

# pipeline parameters
CACHE_PIPELINE = False # @param {type: "string"}
_DEFAULT_IMAGE = IMAGE_URI
BUCKET_URI = "gs://{BUCKET_URI}"  # @param {type: "string"}
PIPELINE_ROOT = f"{BUCKET_URI}/pipeline_root/intro"
PIPELINE_DISPLAY_NAME = "pipeline_nonRFCIP" # @param {type: "string"}

En tu notebook de JupyterLab, crea una celda nueva y ejecuta lo siguiente.

from re import S
import kfp
from kfp import dsl
from kfp.dsl import container_component, ContainerSpec
from kfp import compiler
from google.cloud import aiplatform


# ==== Component with env variable ====

@container_component
def dns_peering_test_op(dns_domain: str, proxy_vm_ip:str, proxy_vm_port:str):
    return ContainerSpec(
        image=_DEFAULT_IMAGE,
        command=["bash", "-c"],
        args=[
            """
            apt-get update && apt-get install inetutils-traceroute inetutils-ping netcat-openbsd curl -y

            echo "Local IP(s): $(hostname -I)"

            echo "Attempting to trace route to %s"
            traceroute -w 1 -m 7 "%s"

            echo "Sending curl requests to http://%s via proxy %s:%s and recording trace..."
            if curl -L -v --trace-ascii /dev/stdout -x http://%s:%s "http://%s"; then
                echo "Curl request succeeded!"
            else
                echo "Curl request failed!"
                exit 1
            fi
            """ % (dns_domain, dns_domain, dns_domain, proxy_vm_ip, proxy_vm_port, proxy_vm_ip, proxy_vm_port, dns_domain)

        ]
    )

# ==== Pipeline ====
@dsl.pipeline(
    name="dns-peering-test-pipeline",
    description="Test DNS Peering using env variable",
    pipeline_root=PIPELINE_ROOT,
)
def dns_peering_test_pipeline(dns_domain: str, proxy_vm_ip:str, proxy_vm_port:str):
    dns_test_task = dns_peering_test_op(dns_domain=dns_domain, proxy_vm_ip=proxy_vm_ip, proxy_vm_port=proxy_vm_port)
    dns_test_task.set_caching_options(enable_caching=CACHE_PIPELINE)

# ==== Compile pipeline ====
if __name__ == "__main__":
    aiplatform.init(project=PROJECT_ID, location=LOCATION)

    compiler.Compiler().compile(
        pipeline_func=dns_peering_test_pipeline,
        package_path="dns_peering_test_pipeline.yaml",
    )
    print("✅ Pipeline compiled to dns_peering_test_pipeline.yaml")

En tu notebook de JupyterLab, crea una celda nueva y ejecuta lo siguiente.

# Define the PipelineJob body; see API Reference https://cloud.google.com/vertex-ai/docs/reference/rest/v1/projects.locations.pipelineJobs/create

import requests, json
import datetime

bearer_token = !gcloud auth application-default print-access-token
headers = {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer {}'.format(bearer_token[0]),
}

request_uri = f"https://{REGION}-aiplatform.googleapis.com/{API_VERSION}/projects/{PROJECT_NUMBER}/locations/{REGION}/pipelineJobs/"

print("request_uri: ", request_uri)

14. Validación de la interfaz de PSC

También puedes ver las IPs de la vinculación de red que usa Vertex AI Pipelines. Para ello, navega a la siguiente ubicación:

Servicios de red → Private Service Connect → Adjunto de red → psc-network-attachment

Selecciona el proyecto de usuario (el nombre del proyecto termina en -tp).

a2e0b6d6243f26f1.png

El campo destacado indica la dirección IP que usa Vertex AI Pipelines desde el adjunto de red de PSC.

11e411ea919d3bad.png

15. Validación de Cloud Logging

El trabajo de Vertex AI Pipelines tardará aproximadamente 14 minutos en ejecutarse la primera vez. Las ejecuciones posteriores serán mucho más cortas. Para validar un resultado exitoso, haz lo siguiente:

Navega a Vertex AI → Entrenamiento → Trabajos personalizados

Selecciona el trabajo personalizado ejecutado

2f467254aa0c2e3a.png

Selecciona Ver registros.

8d525d3b152bcc61.png

Una vez que Cloud Logging esté disponible, selecciona Ejecutar consulta que genera la selección destacada a continuación, lo que confirma un wget exitoso de Vertex AI Pipelines al class-e-vm.

a4f9e9167f4ce1ae.png

38972f834aa2bd1d.png

16. Validación de TCPDump

Revisemos el resultado de TCPDUMP que valida aún más la conectividad a las instancias de procesamiento:

Desde class-e-vm, observa el HTTP GET y el 200 OK.

XXXXXXXXX@class-e-vm:~$ sudo tcpdump -i any net 10.10.100.0/28 -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
05:51:14.173641 ens4  In  IP 10.10.100.8.55306 > 240.0.0.2.80: Flags [S], seq 1747181041, win 65535, options [mss 1420,sackOK,TS val 3942828403 ecr 0,nop,wscale 8], length 0
05:51:14.173668 ens4  Out IP 240.0.0.2.80 > 10.10.100.8.55306: Flags [S.], seq 3013226100, ack 1747181042, win 64768, options [mss 1420,sackOK,TS val 1886125065 ecr 3942828403,nop,wscale 7], length 0
05:51:14.174977 ens4  In  IP 10.10.100.8.55306 > 240.0.0.2.80: Flags [.], ack 1, win 1054, options [nop,nop,TS val 3942828405 ecr 1886125065], length 0
05:51:14.175066 ens4  In  IP 10.10.100.8.55306 > 240.0.0.2.80: Flags [P.], seq 1:223, ack 1, win 1054, options [nop,nop,TS val 3942828405 ecr 1886125065], length 222: HTTP: GET / HTTP/1.1
05:51:14.175096 ens4  Out IP 240.0.0.2.80 > 10.10.100.8.55306: Flags [.], ack 223, win 505, options [nop,nop,TS val 1886125066 ecr 3942828405], length 0
05:51:14.239042 ens4  Out IP 240.0.0.2.80 > 10.10.100.8.55306: Flags [P.], seq 1:246, ack 223, win 505, options [nop,nop,TS val 1886125130 ecr 3942828405], length 245: HTTP: HTTP/1.1 200 OK

17. Limpia

Borra los componentes del instructivo desde Cloud Shell.

gcloud workbench instances delete workbench-tutorial --project=$projectid --location=us-central1-a

gcloud network-security gateway-security-policies rules delete allow-nonrfc-classe \
    --gateway-security-policy=policy1 \
    --location=us-central1

gcloud network-security gateway-security-policies rules delete allow-apache2 \
    --gateway-security-policy=policy1 \
    --location=us-central1

gcloud network-security gateway-security-policies delete policy1 \
    --location=us-central1
gcloud network-services gateways delete swp1 \
    --location=us-central1

gcloud compute network-attachments delete psc-network-attachment --region=us-central1 --quiet

gcloud compute networks subnets delete intf-subnet rfc1918-subnet1 --region=us-central1 --quiet

gcloud dns record-sets delete class-e-vm.demo.com --zone=private-dns-codelab  --type=A
gcloud dns record-sets delete explicit-swp.demo.com --zone=private-dns-codelab  --type=A

gcloud dns managed-zones delete private-dns-codelab

gcloud computeinstances delete class-e-vm --project=$projectid --zone=us-central1-a --quiet
gcloud compute networks delete consumer-vpc --quiet

18. Felicitaciones

Felicitaciones. Configuraste y validaste correctamente una conexión entre la interfaz de Private Service Connect de Vertex AI Pipelines y los rangos de IP que no son de RFC a través del proxy web seguro.

Creaste la infraestructura del consumidor y agregaste un adjunto de red que permitió al productor crear una VM con varias NICs para conectar la comunicación entre el consumidor y el productor. Aprendiste a crear el intercambio de tráfico de DNS mientras implementabas un proxy explícito en la red de VPC del consumidor que permitía la conectividad a la instancia de class-e-vm a la que no se puede acceder directamente desde Vertex.

678ba30d64a76795.png

¿Qué sigue?

Lecturas y videos adicionales

Documentos de referencia