Usa Private Service Connect para acceder a predicciones por lotes de Vertex AI desde las instalaciones locales

Las predicciones por lotes son solicitudes asíncronas que solicitan predicciones directamente del recurso del modelo sin tener que implementar el modelo en un extremo.

En este instructivo, usarás una VPN con alta disponibilidad para enviar solicitudes de predicción por lotes a un modelo entrenado de forma privada entre dos redes de nube privada virtual que pueden servir como base para la conectividad privada local y de múltiples nubes.

Este instructivo está dirigido a administradores de redes empresariales, investigadores y científicos de datos que estén familiarizados con Vertex AI, la nube privada virtual (VPC), la consola de Google Cloud y Cloud Shell. Estar familiarizado con Vertex AI Workbench es útil, pero no obligatorio.

Diagrama de la arquitectura del uso de Private Service Connect para acceder a las predicciones por lotes.

Objetivos

  • Crear dos redes de nube privada virtual (VPC), como se muestra en el diagrama anterior:
    • Una (vertex-networking-vpc) es para acceder a las APIs de Google para la predicción por lotes.
    • La otra (onprem-vpc) representa una red local.
  • Implementa puertas de enlace de VPN con alta disponibilidad, túneles de Cloud VPN y Cloud Routers para conectar vertex-networking-vpc y onprem-vpc.
  • Crea un modelo de predicción por lotes de Vertex AI y súbelo a un bucket de Cloud Storage.
  • Crea un extremo de Private Service Connect (PSC) para reenviar solicitudes privadas a la API de REST de predicción por lotes de Vertex AI.
  • Configura el modo de anuncio personalizado de Cloud Router en vertex-networking-vpc para anunciar rutas para el extremo de Private Service Connect a onprem-vpc.
  • Crea una instancia de VM de Compute Engine en onprem-vpc para representar una aplicación cliente (on-prem-client) que envía solicitudes de predicciones por lotes de forma privada mediante VPN con alta disponibilidad.

Costos

En este documento, usarás los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios. Es posible que los usuarios nuevos de Google Cloud califiquen para obtener una prueba gratuita.

Cuando finalices las tareas que se describen en este documento, puedes borrar los recursos que creaste para evitar que continúe la facturación. Para obtener más información, consulta Cómo realizar una limpieza.

Antes de comenzar

  1. In the Google Cloud console, go to the project selector page.

    Go to project selector

  2. Select or create a Google Cloud project.

  3. Make sure that billing is enabled for your Google Cloud project.

  4. Abre Cloud Shell para ejecutar los comandos detallados en este instructivo. Cloud Shell es un entorno de shell interactivo para Google Cloud que te permite administrar proyectos y recursos desde el navegador web.
  5. En Cloud Shell, establece el proyecto actual como el ID del proyecto Google Cloud y almacena el mismo ID del proyecto en la variable de shell projectid: 
      projectid="PROJECT_ID"
  gcloud config set project ${projectid}
     Reemplaza PROJECT_ID por el ID del proyecto. Si es necesario, puedes ubicar el ID del proyecto en la consola de Google Cloud. Para obtener más información, consulta Encuentra el ID del proyecto.
  6. Si no eres el propietario del proyecto, pídele al propietario que te otorgue el rol de administrador de IAM del proyecto (roles/resourcemanager.projectIamAdmin). Debes tener este rol para otorgar roles de IAM en el siguiente paso.

  7. Grant roles to your user account. Run the following command once for each of the following IAM roles: roles/compute.instanceAdmin.v1, roles/compute.networkAdmin, roles/compute.securityAdmin, roles/dns.admin, roles/iap.tunnelResourceAccessor, roles/notebooks.admin, roles/iam.serviceAccountAdmin, roles/iam.serviceAccountUser, roles/servicedirectory.editor, roles/serviceusage.serviceUsageAdmin, roles/storage.admin, roles/aiplatform.admin, roles/aiplatform.user, roles/resourcemanager.projectIamAdmin 

    gcloud projects add-iam-policy-binding PROJECT_ID --member="user:USER_IDENTIFIER" --role=ROLE
    • Replace PROJECT_ID with your project ID.

    • Replace USER_IDENTIFIER with the identifier for your user account. For example, user:myemail@example.com.

    • Replace ROLE with each individual role.

  8. Enable the DNS, Artifact Registry, IAM, Compute Engine, Notebooks, and Vertex AI APIs: 

    gcloud services enable dns.googleapis.com artifactregistry.googleapis.com iam.googleapis.com compute.googleapis.com notebooks.googleapis.com aiplatform.googleapis.com

Crea las redes de VPC

En esta sección, crearás dos redes de VPC: una para acceder a las APIs de Google en la predicción por lotes y la otra con el fin de simular una red local. En cada una de las dos redes de VPC, debes crear un Cloud Router y una puerta de enlace de Cloud NAT. Una puerta de enlace de Cloud NAT proporciona conectividad saliente para las instancias de máquina virtual (VM) de Compute Engine sin direcciones IP externas.

  1. Crea la red de VPC vertex-networking-vpc

    gcloud compute networks create vertex-networking-vpc \
  --subnet-mode custom

  2. En la red vertex-networking-vpc, crea una subred llamada workbench-subnet, con un rango IPv4 principal de 10.0.1.0/28:

    gcloud compute networks subnets create workbench-subnet \
  --range=10.0.1.0/28 \
  --network=vertex-networking-vpc \
  --region=us-central1 \
  --enable-private-ip-google-access

  3. Crea la red de VPC para simular la red local (onprem-vpc):

    gcloud compute networks create onprem-vpc \
  --subnet-mode custom

  4. En la red onprem-vpc, crea una subred llamada onprem-vpc-subnet1, con un rango IPv4 principal de 172.16.10.0/29:

    gcloud compute networks subnets create onprem-vpc-subnet1 \
  --network onprem-vpc \
  --range 172.16.10.0/29 \
  --region us-central1

Verifica que las redes de VPC estén configuradas de forma correcta

  1. En la consola de Google Cloud, ve a la pestaña Redes en el proyecto actual en la página Redes de VPC.

    Ir a las redes de VPC

  2. En la lista de redes de VPC, verifica que se hayan creado las dos redes: vertex-networking-vpc y onprem-vpc.

  3. Haz clic en la pestaña Subredes del proyecto actual.

  4. En la lista de subredes de VPC, verifica que se crearon las subredes workbench-subnet y onprem-vpc-subnet1.

Configura la conectividad híbrida

En esta sección, crearás dos puertas de enlace de VPN con alta disponibilidad que están conectadas entre sí. Una reside en la red de VPC vertex-networking-vpc. La otra se encuentra en la red de VPC onprem-vpc. Cada puerta de enlace contiene un Cloud Router y un par de túneles VPN.

Crea las puertas de enlace de VPN con alta disponibilidad

  1. En Cloud Shell, crea la puerta de enlace de VPN con alta disponibilidad para la red de VPC vertex-networking-vpc:

    gcloud compute vpn-gateways create vertex-networking-vpn-gw1 \
   --network vertex-networking-vpc \
   --region us-central1

  2. Crea la puerta de enlace de VPN con alta disponibilidad para la red de VPC onprem-vpc:

    gcloud compute vpn-gateways create onprem-vpn-gw1 \
   --network onprem-vpc \
   --region us-central1

  3. En la consola de Google Cloud, ve a la pestaña Puertas de enlace de Cloud VPN en la página VPN.

    Ir a VPN

  4. Verifica que ambas puertas de enlace (vertex-networking-vpn-gw1 y onprem-vpn-gw1) se hayan creado y que cada puerta de enlace tenga dos direcciones IP de interfaz.

Crea Cloud Routers y puertas de enlace Cloud NAT

En cada una de las dos redes de VPC, debes crear dos Cloud Routers: uno general y otro regional. En cada uno de los Cloud Routers regionales, debes crear una puerta de enlace de Cloud NAT. Las puertas de enlace de Cloud NAT proporcionan conectividad saliente para las instancias de máquina virtual (VM) de Compute Engine que no tienen direcciones IP externas.

  1. En Cloud Shell, crea un Cloud Router para la red de VPC vertex-networking-vpc:

    gcloud compute routers create vertex-networking-vpc-router1 \
   --region us-central1\
   --network vertex-networking-vpc \
   --asn 65001

  2. Crea un Cloud Router para la red de VPC onprem-vpc:

    gcloud compute routers create onprem-vpc-router1 \
   --region us-central1\
   --network onprem-vpc\
   --asn 65002

  3. Crea un Cloud Router regional para la red de VPC vertex-networking-vpc:

    gcloud compute routers create cloud-router-us-central1-vertex-nat \
  --network vertex-networking-vpc \
  --region us-central1

  4. Configura una puerta de enlace de Cloud NAT en el Cloud Router regional:

    gcloud compute routers nats create cloud-nat-us-central1 \
  --router=cloud-router-us-central1-vertex-nat \
  --auto-allocate-nat-external-ips \
  --nat-all-subnet-ip-ranges \
  --region us-central1

  5. Crea un Cloud Router regional para la red de VPC onprem-vpc:

    gcloud compute routers create cloud-router-us-central1-onprem-nat \
  --network onprem-vpc \
  --region us-central1

  6. Configura una puerta de enlace de Cloud NAT en el Cloud Router regional:

    gcloud compute routers nats create cloud-nat-us-central1-on-prem \
  --router=cloud-router-us-central1-onprem-nat \
  --auto-allocate-nat-external-ips \
  --nat-all-subnet-ip-ranges \
  --region us-central1

  7. En la consola de Google Cloud, ve a la página Cloud Routers.

    Ir a Cloud Routers

  8. En la lista de Cloud Routers, verifica que se hayan creado los siguientes routers:

    • cloud-router-us-central1-onprem-nat
    • cloud-router-us-central1-vertex-nat
    • onprem-vpc-router1
    • vertex-networking-vpc-router1

    Es posible que debas actualizar la Google Cloud pestaña del navegador de la consola para ver los valores nuevos.

  9. En la lista de Cloud Routers, haz clic en cloud-router-us-central1-vertex-nat.

  10. En la página Detalles del router, verifica que se haya creado la puerta de enlace de Cloud NAT cloud-nat-us-central1.

  11. Haz clic en la flecha hacia atrás para volver a la página Cloud Routers.

  12. En la lista de routers, haz clic en cloud-router-us-central1-onprem-nat.

  13. En la página Detalles del router, verifica que se haya creado la puerta de enlace de Cloud NAT cloud-nat-us-central1-on-prem.

Crea túneles VPN

  1. En Cloud Shell, en la red vertex-networking-vpc, crea un túnel VPN llamado vertex-networking-vpc-tunnel0:

    gcloud compute vpn-tunnels create vertex-networking-vpc-tunnel0 \
  --peer-gcp-gateway onprem-vpn-gw1 \
  --region us-central1 \
  --ike-version 2 \
  --shared-secret [ZzTLxKL8fmRykwNDfCvEFIjmlYLhMucH] \
  --router vertex-networking-vpc-router1 \
  --vpn-gateway vertex-networking-vpn-gw1 \
  --interface 0

  2. En la red vertex-networking-vpc, crea un túnel VPN llamado vertex-networking-vpc-tunnel1:

    gcloud compute vpn-tunnels create vertex-networking-vpc-tunnel1 \
  --peer-gcp-gateway onprem-vpn-gw1 \
  --region us-central1 \
  --ike-version 2 \
  --shared-secret [bcyPaboPl8fSkXRmvONGJzWTrc6tRqY5] \
  --router vertex-networking-vpc-router1 \
  --vpn-gateway vertex-networking-vpn-gw1 \
  --interface 1

  3. En la red onprem-vpc, crea un túnel VPN llamado onprem-vpc-tunnel0:

    gcloud compute vpn-tunnels create onprem-vpc-tunnel0 \
  --peer-gcp-gateway vertex-networking-vpn-gw1 \
  --region us-central1\
  --ike-version 2 \
  --shared-secret [ZzTLxKL8fmRykwNDfCvEFIjmlYLhMucH] \
  --router onprem-vpc-router1 \
  --vpn-gateway onprem-vpn-gw1 \
  --interface 0

  4. En la red onprem-vpc, crea un túnel VPN llamado onprem-vpc-tunnel1:

    gcloud compute vpn-tunnels create onprem-vpc-tunnel1 \
  --peer-gcp-gateway vertex-networking-vpn-gw1 \
  --region us-central1\
  --ike-version 2 \
  --shared-secret [bcyPaboPl8fSkXRmvONGJzWTrc6tRqY5] \
  --router onprem-vpc-router1 \
  --vpn-gateway onprem-vpn-gw1 \
  --interface 1

  5. En la consola de Google Cloud, ve a la página VPN.

    Ir a VPN

  6. En la lista de túneles VPN, verifica que se hayan creado los cuatro túneles VPN.

Establece sesiones de BGP

Cloud Router usa el protocolo de puerta de enlace fronteriza (BGP) para intercambiar rutas entre tu red de VPC (en este caso, vertex-networking-vpc) y tu red local (representada por onprem-vpc). En Cloud Router, configura una interfaz y un par de BGP para tu router local. La interfaz y la configuración de par de BGP juntas forman una sesión de BGP. En esta sección, crearás dos sesiones de BGP para vertex-networking-vpc y dos para onprem-vpc.

Una vez que hayas configurado las interfaces y los pares BGP entre tus routers, comenzarán automáticamente a intercambiar rutas.

Establece sesiones de BGP para vertex-networking-vpc

  1. En Cloud Shell, en la red vertex-networking-vpc, crea una interfaz de BGP para vertex-networking-vpc-tunnel0:

    gcloud compute routers add-interface vertex-networking-vpc-router1 \
  --interface-name if-tunnel0-to-onprem \
  --ip-address 169.254.0.1 \
  --mask-length 30 \
  --vpn-tunnel vertex-networking-vpc-tunnel0 \
  --region us-central1

  2. En la red vertex-networking-vpc, crea un par de BGP para bgp-onprem-tunnel0:

    gcloud compute routers add-bgp-peer vertex-networking-vpc-router1 \
  --peer-name bgp-onprem-tunnel0 \
  --interface if-tunnel0-to-onprem \
  --peer-ip-address 169.254.0.2 \
  --peer-asn 65002 \
  --region us-central1

  3. En la red vertex-networking-vpc, crea una interfaz de BGP para vertex-networking-vpc-tunnel1:

    gcloud compute routers add-interface vertex-networking-vpc-router1 \
  --interface-name if-tunnel1-to-onprem \
  --ip-address 169.254.1.1 \
  --mask-length 30 \
  --vpn-tunnel vertex-networking-vpc-tunnel1 \
  --region us-central1

  4. En la red vertex-networking-vpc, crea un par de BGP para bgp-onprem-tunnel1:

    gcloud compute routers add-bgp-peer vertex-networking-vpc-router1 \
  --peer-name bgp-onprem-tunnel1 \
  --interface if-tunnel1-to-onprem \
  --peer-ip-address 169.254.1.2 \
  --peer-asn 65002 \
  --region us-central1

Establece sesiones de BGP para onprem-vpc

  1. En la red onprem-vpc, crea una interfaz de BGP para onprem-vpc-tunnel0:

    gcloud compute routers add-interface onprem-vpc-router1 \
  --interface-name if-tunnel0-to-vertex-networking-vpc \
  --ip-address 169.254.0.2 \
  --mask-length 30 \
  --vpn-tunnel onprem-vpc-tunnel0 \
  --region us-central1

  2. En la red onprem-vpc, crea un par de BGP para bgp-vertex-networking-vpc-tunnel0:

    gcloud compute routers add-bgp-peer onprem-vpc-router1 \
  --peer-name bgp-vertex-networking-vpc-tunnel0 \
  --interface if-tunnel0-to-vertex-networking-vpc \
  --peer-ip-address 169.254.0.1 \
  --peer-asn 65001 \
  --region us-central1

  3. En la red onprem-vpc, crea una interfaz de BGP para onprem-vpc-tunnel1:

    gcloud compute routers add-interface   onprem-vpc-router1  \
  --interface-name if-tunnel1-to-vertex-networking-vpc \
  --ip-address 169.254.1.2 \
  --mask-length 30 \
  --vpn-tunnel onprem-vpc-tunnel1 \
  --region us-central1

  4. En la red onprem-vpc, crea un par de BGP para bgp-vertex-networking-vpc-tunnel1:

    gcloud compute routers add-bgp-peer onprem-vpc-router1 \
  --peer-name bgp-vertex-networking-vpc-tunnel1 \
  --interface if-tunnel1-to-vertex-networking-vpc \
  --peer-ip-address 169.254.1.1 \
  --peer-asn 65001 \
  --region us-central1

Valida la creación de sesiones de BGP

  1. En la consola de Google Cloud, ve a la página VPN.

    Ir a VPN

  2. En la lista de túneles VPN, verifica que el valor en la columna Estado de la sesión de BGP para cada uno de los túneles haya cambiado de Configura la sesión de BGP a BGP establecida. Es posible que debas actualizar la pestaña del navegador de la consola de Google Cloud para ver los valores nuevos.

Valida las rutas aprendidas de vertex-networking-vpc

  1. En la consola de Google Cloud, ve a la página Redes de VPC.

    Ir a las redes de VPC

  2. En la lista de redes de VPC, haz clic en vertex-networking-vpc.

  3. Haz clic en la pestaña Rutas.

  4. Selecciona us-central1 (Iowa) en la lista Región y haz clic en Ver.

  5. En la columna Rango de IP de destino, verifica que el rango de IP (172.16.10.0/29) de la subred onprem-vpc-subnet1 aparezca dos veces.

Valida las rutas aprendidas de onprem-vpc

  1. Haz clic en la flecha hacia atrás para regresar a la página Redes de VPC.

  2. En la lista de redes de VPC, haz clic en onprem-vpc.

  3. Haz clic en la pestaña Rutas.

  4. Selecciona us-central1 (Iowa) en la lista Región y haz clic en Ver.

  5. En la columna Rango de IP de destino, verifica que el rango de IP (10.0.1.0/28) de la subred workbench-subnet aparezca dos veces.

Crea el extremo del consumidor de Private Service Connect

  1. En Cloud Shell, reserva una dirección IP de extremo del consumidor que se usará para acceder a las APIs de Google:

    gcloud compute addresses create psc-googleapi-ip \
  --global \
  --purpose=PRIVATE_SERVICE_CONNECT \
  --addresses=192.168.0.1 \
  --network=vertex-networking-vpc

  2. Crea una regla de reenvío para conectar el extremo a los servicios y las APIs de Google.

    gcloud compute forwarding-rules create pscvertex \
 --global \
 --network=vertex-networking-vpc\
 --address=psc-googleapi-ip \
 --target-google-apis-bundle=all-apis

Crea rutas anunciadas personalizadas para vertex-networking-vpc

En esta sección, configurarás el modo de anuncio personalizado de Cloud Router para Anunciar rangos de IP personalizados para vertex-networking-vpc-router1 (el Cloud Router para vertex-networking-vpc) para anunciar la dirección IP del extremo de PSC a la red onprem-vpc.

  1. En la consola de Google Cloud, ve a la página Cloud Routers.

    Ir a Cloud Routers

  2. En la lista de Cloud Router, haz clic en vertex-networking-vpc-router1.

  3. En la página de detalles del router, haz clic en Editar.

  4. En la sección Rutas anunciadas, en Rutas, selecciona Crear rutas personalizadas.

  5. Selecciona la casilla de verificación Anunciar todas las subredes visibles para Cloud Router. Esto hará que continúe el anuncio de las subredes disponibles en el Cloud Router. Habilitar esta opción imita el comportamiento de Cloud Router en el modo de anuncio predeterminado.

  6. Haz clic en Agregar una ruta personalizada.

  7. En Fuente, selecciona Rango de IP personalizado.

  8. En Rango de direcciones IP, ingresa la siguiente dirección IP:

    192.168.0.1

  9. En Descripción, ingresa el siguiente texto:

    Custom route to advertise Private Service Connect endpoint IP address

  10. Haz clic en Listo y, luego, en Guardar.

Valida que onprem-vpc haya aprendido las rutas anunciadas

  1. En la consola de Google Cloud, ve a la página Rutas.

    Ir a Rutas

  2. En la pestaña Effective routes, haz lo siguiente:

    1. En Red, elige onprem-vpc.
    2. En Región, elige us-central1 (Iowa).
    3. Haz clic en Ver.

    4. En la lista de rutas, verifica que haya entradas cuyos nombres comiencen con onprem-vpc-router1-bgp-vertex-networking-vpc-tunnel0 y onprem-vpc-router1-bgp-vfertex-networking-vpc-tunnel1 y que ambos tengan el rango de IP de destino de192.168.0.1.

      Si estas entradas no aparecen de inmediato, espera unos minutos y, luego, actualiza la pestaña del navegador de la Google Cloud consola.

Crear una VM en onprem-vpc que use una cuenta de servicio administrada por el usuario

En esta sección, crearás una instancia de VM que simule una aplicación cliente local que envía solicitudes de predicción por lotes. Siguiendo prácticas recomendadas de Compute Engine e IAM, esta VM usa una cuenta de servicio administrada por el usuario en lugar cuenta de servicio predeterminada de la instancia de Compute Engine.

Crea una cuenta de servicio administrada por el usuario.

  1. En Cloud Shell, ejecuta los siguientes comandos y reemplaza PROJECT_ID por el ID del proyecto:

    projectid=PROJECT_ID
gcloud config set project ${projectid}

  2. Crea una cuenta de servicio llamada onprem-user-managed-sa:

    gcloud iam service-accounts create onprem-user-managed-sa \
  --display-name="onprem-user-managed-sa-onprem-client"

  3. Asigna el rol de usuario de Vertex AI (roles/aiplatform.user) a la cuenta de servicio:

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

  4. Asigna el rol de visualizador de objetos de almacenamiento (storage.objectViewer) a la cuenta de servicio:

    gcloud projects add-iam-policy-binding $projectid \
  --member="serviceAccount:onprem-user-managed-sa@$projectid.iam.gserviceaccount.com" \
  --role="roles/storage.objectViewer"

Crea la instancia de VM on-prem-client

La instancia de VM que creas no tiene una dirección IP externa y no permite el acceso directo a través de Internet. Para habilitar el acceso de administrador a la VM, usa el reenvío de TCP de Identity-Aware Proxy (IAP).

  1. En Cloud Shell, crea la instancia de VM on-prem-client:

    gcloud compute instances create on-prem-client \
  --zone=us-central1-a \
  --image-family=debian-11 \
  --image-project=debian-cloud \
  --subnet=onprem-vpc-subnet1 \
  --scopes=https://www.googleapis.com/auth/cloud-platform \
  --no-address \
  --shielded-secure-boot \
  --service-account=onprem-user-managed-sa@$projectid.iam.gserviceaccount.com \
  --metadata startup-script="#! /bin/bash
    sudo apt-get update
    sudo apt-get install tcpdump dnsutils -y"

  2. Crea una regla de firewall para permitir que IAP se conecte a tu instancia de VM:

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

Valida el acceso público a la API de Vertex AI

En esta sección, usarás la utilidad dig para realizar una búsqueda de DNS desde la instancia de VM on-prem-client a la API de Vertex AI (us-central1-aiplatform.googleapis.com). El resultado de dig muestra que el acceso predeterminado solo usa VIP públicas para acceder a la API de Vertex AI.

En la siguiente sección, configurarás el acceso privado a la API de Vertex AI.

  1. En Cloud Shell, accede a la instancia de VM on-prem-client con IAP:

    gcloud compute ssh on-prem-client \
  --zone=us-central1-a \
  --tunnel-through-iap

  2. En la instancia de VM on-prem-client, ejecuta el comando dig:

    dig us-central1-aiplatform.googleapis.com

    Deberías ver un resultado de dig similar al siguiente, en el que las direcciones IP en la sección de respuesta son direcciones IP públicas:

    ; <<>> DiG 9.16.44-Debian <<>> us-central1.aiplatfom.googleapis.com
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 42506
;; flags: qr rd ra; QUERY: 1, ANSWER: 16, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 512
;; QUESTION SECTION:
;us-central1.aiplatfom.googleapis.com. IN A

;; ANSWER SECTION:
us-central1.aiplatfom.googleapis.com. 300 IN A  173.194.192.95
us-central1.aiplatfom.googleapis.com. 300 IN A  142.250.152.95
us-central1.aiplatfom.googleapis.com. 300 IN A  172.217.219.95
us-central1.aiplatfom.googleapis.com. 300 IN A  209.85.146.95
us-central1.aiplatfom.googleapis.com. 300 IN A  209.85.147.95
us-central1.aiplatfom.googleapis.com. 300 IN A  142.250.125.95
us-central1.aiplatfom.googleapis.com. 300 IN A  142.250.136.95
us-central1.aiplatfom.googleapis.com. 300 IN A  142.250.148.95
us-central1.aiplatfom.googleapis.com. 300 IN A  209.85.200.95
us-central1.aiplatfom.googleapis.com. 300 IN A  209.85.234.95
us-central1.aiplatfom.googleapis.com. 300 IN A  142.251.171.95
us-central1.aiplatfom.googleapis.com. 300 IN A  108.177.112.95
us-central1.aiplatfom.googleapis.com. 300 IN A  142.250.128.95
us-central1.aiplatfom.googleapis.com. 300 IN A  142.251.6.95
us-central1.aiplatfom.googleapis.com. 300 IN A  172.217.212.95
us-central1.aiplatfom.googleapis.com. 300 IN A  74.125.124.95

;; Query time: 8 msec
;; SERVER: 169.254.169.254#53(169.254.169.254)
;; WHEN: Wed Sep 27 04:10:16 UTC 2023
;; MSG SIZE  rcvd: 321

Configura y valida el acceso privado a la API de Vertex AI

En esta sección, debes configurar el acceso privado a la API de Vertex AI para que, cuando envíes solicitudes de predicción por lotes, se redireccionen a tu extremo de PSC. El extremo de PSC, a su vez, reenvía estas solicitudes privadas a la API de REST de predicción por lotes de Vertex AI.

Actualiza el archivo /etc/hosts para que apunte al extremo de PSC

En este paso, agregarás una línea al archivo /etc/hosts que hace que las solicitudes enviadas al extremo del servicio público (us-central1-aiplatform.googleapis.com) se redireccionen al extremo de PSC (192.168.0.1).

  1. En la instancia de VM on-prem-client, usa un editor de texto, como vim o nano para abrir el archivo /etc/hosts:

    sudo vim /etc/hosts

  2. Agrega la siguiente línea al archivo:

    192.168.0.1 us-central1-aiplatform.googleapis.com

    Esta línea asigna la dirección IP del extremo de PSC (192.168.0.1) al nombre de dominio completamente calificado para la API de Google de Vertex AI (us-central1-aiplatform.googleapis.com).

    El archivo editado debería verse de la siguiente manera:

    127.0.0.1       localhost
::1             localhost ip6-localhost ip6-loopback
ff02::1         ip6-allnodes
ff02::2         ip6-allrouters

192.168.0.1 us-central1-aiplatform.googleapis.com  # Added by you
172.16.10.6 on-prem-client.us-central1-a.c.vertex-genai-400103.internal on-prem-client  # Added by Google
169.254.169.254 metadata.google.internal  # Added by Google

  3. Guarda el archivo de la siguiente manera:

    • Si usas vim, presiona la tecla Esc y, a continuación, escribe :wq para guardar el archivo y salir.
    • Si usas nano, escribe Control+O y presiona Enter para guardar el archivo y, luego, escribe Control+X para salir.

  4. Haz ping en el extremo de Vertex AI de la siguiente manera:

    ping us-central1-aiplatform.googleapis.com

    El comando ping debería devolver el siguiente resultado. 192.168.0.1 es la dirección IP del extremo de PSC:

    PING us-central1-aiplatform.googleapis.com (192.168.0.1) 56(84) bytes of data.

  5. Escribe Control+C para salir de ping.

  6. Escribe exit para salir de la instancia de VM on-prem-client.

Crea una cuenta de servicio administrada por el usuario para Vertex AI Workbench en vertex-networking-vpc

En esta sección, para controlar el acceso a tu instancia de Vertex AI Workbench, debes crear una cuenta de servicio administrada por el usuario y, luego, asignar roles de IAM a la cuenta de servicio. Cuando creas la instancia, especificas cuenta de servicio.

  1. En Cloud Shell, ejecuta los siguientes comandos y reemplaza PROJECT_ID por el ID del proyecto:

    projectid=PROJECT_ID
gcloud config set project ${projectid}

  2. Crea una cuenta de servicio llamada workbench-sa:

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

  3. Asigna el rol de IAM de usuario de Vertex AI (roles/aiplatform.user) a la cuenta de servicio:

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

  4. Asigna el rol de IAM de Usuario de BigQuery (roles/bigquery.user) a la cuenta de servicio:

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

  5. Asigna el rol de IAM de administrador de almacenamiento (roles/storage.admin) a la cuenta de servicio:

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

  6. Asigna el rol de IAM de Visualizador de registros (roles/logging.viewer) a la cuenta de servicio:

    gcloud projects add-iam-policy-binding $projectid \
  --member="serviceAccount:workbench-sa@$projectid.iam.gserviceaccount.com" \
  --role="roles/logging.viewer"

Crea la instancia de Vertex AI Workbench

  1. En Cloud Shell, crea una instancia de Vertex AI Workbench y especifica la cuenta de servicio workbench-sa:

    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 \
  --shielded-secure-boot=True \
  --subnet=workbench-subnet \
  --disable-public-ip \
  --service-account-email=workbench-sa@$projectid.iam.gserviceaccount.com

  2. En la consola de Google Cloud, ve a la pestañaInstancias. de la página Vertex AI Workbench.

    Ir a Vertex AI Workbench

  3. Junto al nombre de la instancia de Vertex AI Workbench (workbench-tutorial), haz clic en Abrir JupyterLab.

    Tu instancia de Vertex AI Workbench abre JupyterLab.

  4. Select Archivo > Nuevo > Notebook.

  5. En el menú Seleccionar kernel, selecciona Python 3 (local) y haz clic en Seleccionar.

  6. Cuando se abre tu notebook nuevo, hay una celda de código predeterminada en la que puedes ingresar código. Parece [ ]: seguido de un campo de texto. El campo de texto es donde pegas tu código.

    Si deseas instalar el SDK de Vertex AI para Python, pega el siguiente código en la celda y haz clic en Ejecutar las celdas seleccionadas y avanzar:

    !pip3 install --upgrade google-cloud-bigquery scikit-learn==1.2

  7. En este paso y cada uno de los siguientes, agrega una nueva celda de código (si fuera necesario) haciendo clic en Insertar una celda a continuación, pega el código en la celda y haz clic en  Ejecutar las celdas seleccionadas y avanzar.

    Para usar los paquetes recién instalados en este entorno de ejecución de Jupyter, debes reiniciar el entorno de ejecución:

    # Restart kernel after installs so that your environment can access the new packages
import IPython

app = IPython.Application.instance()
app.kernel.do_shutdown(True)

  8. Configura las siguientes variables de entorno en tu notebook de JupyterLab, reemplaza PROJECT_ID por el ID del proyecto.

    # set project ID and location
PROJECT_ID = "PROJECT_ID"
REGION = "us-central1"

  9. Crea un bucket de Cloud Storage para la etapa de pruebas del trabajo de entrenamiento:

    BUCKET_NAME = f"{PROJECT_ID}-ml-staging"
BUCKET_URI = f"gs://{BUCKET_NAME}"
!gcloud storage buckets create {BUCKET_URI} --location={REGION} --project={PROJECT_ID}

Prepara los datos de entrenamiento

En esta sección, prepararás los datos que se usarán para entrenar un modelo de predicción.

  1. En tu notebook de JupyterLab, crea un cliente de BigQuery:

    from google.cloud import bigquery
bq_client = bigquery.Client(project=PROJECT_ID)

  2. Recupera datos del conjunto de datos públicos ml_datasets de BigQuery:

    DATA_SOURCE = "bigquery-public-data.ml_datasets.census_adult_income"
# Define the SQL query to fetch the dataset
query = f"""
SELECT * FROM `{DATA_SOURCE}` LIMIT 20000
"""
# Download the dataset to a dataframe
df = bq_client.query(query).to_dataframe()
df.head()

  3. Usa la biblioteca sklearn para dividir los datos para entrenamiento y pruebas:

    from sklearn.model_selection import train_test_split
# Split the dataset
X_train, X_test = train_test_split(df, test_size=0.3, random_state=43)
# Print the shapes of train and test sets
print(X_train.shape, X_test.shape)

  4. Exporta los DataFrames de entrenamiento y prueba a archivos CSV en el bucket de etapa de pruebas:

    X_train.to_csv(f"{BUCKET_URI}/train.csv",index=False, quoting=1, quotechar='"')
X_test[[i for i in X_test.columns if i != "income_bracket"]].iloc[:20].to_csv(f"{BUCKET_URI}/test.csv",index=False,quoting=1, quotechar='"')

Prepara la aplicación de entrenamiento

En esta sección, crearás y compilarás la aplicación de entrenamiento de Python y la guardarás en el bucket de etapa de pruebas.

  1. En tu notebook de JupyterLab, crea una carpeta nueva para los archivos de la aplicación de entrenamiento:

    !mkdir -p training_package/trainer

    Ahora deberías ver una carpeta llamada training_package en el menú de navegación de JupyterLab.

  2. Define los atributos, el objetivo, la etiqueta y los pasos para el entrenamiento y la exportación el modelo a un archivo:

    %%writefile training_package/trainer/task.py
from sklearn.ensemble import RandomForestClassifier
from sklearn.feature_selection import SelectKBest
from sklearn.pipeline import FeatureUnion, Pipeline
from sklearn.preprocessing import LabelBinarizer
import pandas as pd
import argparse
import joblib
import os

TARGET = "income_bracket"
# Define the feature columns that you use from the dataset
COLUMNS = (
  "age",
  "workclass",
  "functional_weight",
  "education",
  "education_num",
  "marital_status",
  "occupation",
  "relationship",
  "race",
  "sex",
  "capital_gain",
  "capital_loss",
  "hours_per_week",
  "native_country",
)

# Categorical columns are columns that have string values and
# need to be turned into a numerical value to be used for training
CATEGORICAL_COLUMNS = (
  "workclass",
  "education",
  "marital_status",
  "occupation",
  "relationship",
  "race",
  "sex",
  "native_country",
)

# load the arguments
parser = argparse.ArgumentParser()
parser.add_argument('--training-dir', dest='training_dir', default=os.getenv('AIP_MODEL_DIR'), type=str,help='get the staging directory')
args = parser.parse_args()

# Load the training data
X_train = pd.read_csv(os.path.join(args.training_dir,"train.csv"))
# Remove the column we are trying to predict ('income-level') from our features list
# Convert the Dataframe to a lists of lists
train_features = X_train.drop(TARGET, axis=1).to_numpy().tolist()
# Create our training labels list, convert the Dataframe to a lists of lists
train_labels = X_train[TARGET].to_numpy().tolist()

# Since the census data set has categorical features, we need to convert
# them to numerical values. We'll use a list of pipelines to convert each
# categorical column and then use FeatureUnion to combine them before calling
# the RandomForestClassifier.
categorical_pipelines = []

# Each categorical column needs to be extracted individually and converted to a numerical value.
# To do this, each categorical column will use a pipeline that extracts one feature column via
# SelectKBest(k=1) and a LabelBinarizer() to convert the categorical value to a numerical one.
# A scores array (created below) will select and extract the feature column. The scores array is
# created by iterating over the COLUMNS and checking if it is a CATEGORICAL_COLUMN.
for i, col in enumerate(COLUMNS):
   if col in CATEGORICAL_COLUMNS:
      # Create a scores array to get the individual categorical column.
      # Example:
      #  data = [39, 'State-gov', 77516, 'Bachelors', 13, 'Never-married', 'Adm-clerical',
      #         'Not-in-family', 'White', 'Male', 2174, 0, 40, 'United-States']
      #  scores = [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
      #
      # Returns: [['Sate-gov']]
      scores = []
      # Build the scores array
      for j in range(len(COLUMNS)):
         if i == j:  # This column is the categorical column we want to extract.
            scores.append(1)  # Set to 1 to select this column
         else:  # Every other column should be ignored.
            scores.append(0)
      skb = SelectKBest(k=1)
      skb.scores_ = scores
      # Convert the categorical column to a numerical value
      lbn = LabelBinarizer()
      r = skb.transform(train_features)
      lbn.fit(r)
      # Create the pipeline to extract the categorical feature
      categorical_pipelines.append(
         (
            "categorical-{}".format(i),
            Pipeline([("SKB-{}".format(i), skb), ("LBN-{}".format(i), lbn)]),
         )
      )

# Create pipeline to extract the numerical features
skb = SelectKBest(k=6)
# From COLUMNS use the features that are numerical
skb.scores_ = [1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0]
categorical_pipelines.append(("numerical", skb))

# Combine all the features using FeatureUnion
preprocess = FeatureUnion(categorical_pipelines)

# Create the classifier
classifier = RandomForestClassifier()

# Transform the features and fit them to the classifier
classifier.fit(preprocess.transform(train_features), train_labels)

# Create the overall model as a single pipeline
pipeline = Pipeline([("union", preprocess), ("classifier", classifier)])

# Save the model pipeline
joblib.dump(pipeline, os.path.join(args.training_dir,"model.joblib"))

  3. Crea un archivo __init__.py en cada subdirectorio para convertirlo en un paquete.

    !touch training_package/__init__.py
!touch training_package/trainer/__init__.py

  4. Crea una secuencia de comandos de configuración de paquete de Python:

    %%writefile training_package/setup.py
from setuptools import find_packages
from setuptools import setup

setup(
   name='trainer',
   version='0.1',
   packages=find_packages(),
   include_package_data=True,
   description='Training application package for census income classification.'
)

  5. Usa el comando sdist para crear la distribución de fuente de la aplicación de entrenamiento:

    !cd training_package && python setup.py sdist --formats=gztar

  6. Copia el paquete de Python en el bucket de etapa de pruebas:

    !gcloud storage cp training_package/dist/trainer-0.1.tar.gz $BUCKET_URI/

  7. Verifica que el bucket de etapa de pruebas contenga tres archivos:

    !gcloud storage ls $BUCKET_URI

    El resultado debería ser el siguiente:

    gs://$BUCKET_NAME/test.csv
gs://$BUCKET_NAME/train.csv
gs://$BUCKET_NAME/trainer-0.1.tar.gz

Entrenar el modelo

En esta sección, entrenarás el modelo con la creación y ejecución de un trabajo de entrenamiento personalizado.

  1. En tu notebook de JupyterLab, ejecuta el siguiente comando para crear un trabajo de entrenamiento personalizado:

    !gcloud ai custom-jobs create --display-name=income-classification-training-job \
   --project=$PROJECT_ID \
   --worker-pool-spec=replica-count=1,machine-type='e2-highmem-2',executor-image-uri='us-docker.pkg.dev/vertex-ai/training/sklearn-cpu.1-0:latest',python-module=trainer.task \
   --python-package-uris=$BUCKET_URI/trainer-0.1.tar.gz \
   --args="--training-dir","/gcs/$BUCKET_NAME" \
   --region=$REGION

    El resultado debería ser similar al siguiente. El primer número de cada ruta de trabajo personalizada es el número de proyecto (PROJECT_NUMBER). El segundo número es el ID de trabajo personalizado (CUSTOM_JOB_ID). Toma nota de estos números para que puedas usarlos en el siguiente paso.

    Using endpoint [https://us-central1-aiplatform.googleapis.com/]
CustomJob [projects/721032480027/locations/us-central1/customJobs/1100328496195960832] is submitted successfully.

Your job is still active. You may view the status of your job with the command

$ gcloud ai custom-jobs describe projects/721032480027/locations/us-central1/customJobs/1100328496195960832

or continue streaming the logs with the command

$ gcloud ai custom-jobs stream-logs projects/721032480027/locations/us-central1/customJobs/1100328496195960832

  2. Ejecuta el trabajo de entrenamiento personalizado y muestra el progreso transmitiendo los registros del mientras se ejecuta:

    !gcloud ai custom-jobs stream-logs projects/PROJECT_NUMBER/locations/us-central1/customJobs/CUSTOM_JOB_ID

    Reemplaza los siguientes valores:

    • PROJECT_NUMBER: el número de proyecto del resultado del comando anterior.
    • CUSTOM_JOB_ID: el ID de trabajo personalizado del resultado del comando anterior.

    Tu trabajo de entrenamiento personalizado ya está en ejecución. Tardará aproximadamente 10 minutos en completarse.

    Cuando se complete el trabajo, podrás importar el modelo desde el bucket de etapa de pruebas a Vertex AI Model Registry.

Importa el modelo

Tu trabajo de entrenamiento personalizado sube el modelo entrenado al bucket de etapa de pruebas. Cuando el trabajo se haya completado, puedes importar el modelo del bucket a Vertex AI Model Registry.

  1. En tu notebook de JupyterLab, importa el modelo mediante la ejecución del siguiente comando:

    !gcloud ai models upload --container-image-uri="us-docker.pkg.dev/vertex-ai/prediction/sklearn-cpu.1-2:latest" \
   --display-name=income-classifier-model \
   --artifact-uri=$BUCKET_URI \
   --project=$PROJECT_ID \
   --region=$REGION

  2. Enumera los modelos de Vertex AI del proyecto de la siguiente manera:

    !gcloud ai models list --region=us-central1

    El resultado debe tener el siguiente aspecto. Si se enumeran dos o más modelos, el primero de la lista es el que importaste más recientemente.

    Toma nota del valor en la columna MODEL_ID. Lo necesitas para crear la solicitud de predicción por lotes.

    Using endpoint [https://us-central1-aiplatform.googleapis.com/]
MODEL_ID             DISPLAY_NAME
1871528219660779520  income-classifier-model

    Como alternativa, puedes enumerar los modelos de tu proyecto de la siguiente manera:

    En la consola de Google Cloud, en la sección Vertex AI, ve a la página de Vertex AI Model Registry.

    Ve a la página Vertex AI Model Registry.

    Para ver los IDs del modelo y otros detalles, haz clic en el nombre del modelo y, luego, en la pestaña Detalles de la versión.

Obtén predicciones por lotes del modelo

Ahora puedes solicitar predicciones por lotes desde el modelo. Las solicitudes de predicción por lotes se realizan desde la instancia de VM on-prem-client.

Crea la solicitud de predicción por lotes

En este paso, usarás ssh para acceder a la instancia de VM on-prem-client. En la instancia de VM, crea un archivo de texto llamado request.json que contenga la carga útil de una solicitud de curl de muestra que envías al modelo para obtener predicciones por lotes.

  1. En Cloud Shell, ejecuta los siguientes comandos y reemplaza PROJECT_ID por el ID del proyecto:

    projectid=PROJECT_ID
gcloud config set project ${projectid}

  2. Accede a la instancia de VM on-prem-client utilizando ssh:

    gcloud compute ssh on-prem-client \
  --project=$projectid \
  --zone=us-central1-a

  3. En la instancia de VM on-prem-client, usa un editor de texto como vim o nano para crear un archivo nuevo llamado request.json que contenga el siguiente texto:

    {
  "displayName": "income-classification-batch-job",
  "model": "projects/PROJECT_ID/locations/us-central1/models/MODEL_ID",
  "inputConfig": {
    "instancesFormat": "csv",
    "gcsSource": {
      "uris": ["BUCKET_URI/test.csv"]
    }
  },
  "outputConfig": {
    "predictionsFormat": "jsonl",
    "gcsDestination": {
      "outputUriPrefix": "BUCKET_URI"
    }
  },
  "dedicatedResources": {
    "machineSpec": {
      "machineType": "n1-standard-4",
      "acceleratorCount": "0"
    },
    "startingReplicaCount": 1,
    "maxReplicaCount": 2
  }
}

    Reemplaza los siguientes valores:

    • PROJECT_ID: el ID de tu proyecto
    • MODEL_ID: Es el ID de tu modelo.
    • BUCKET_URI: El URI del bucket de almacenamiento en el que publicaste en etapa de pruebas tu modelo

  4. Ejecuta el siguiente comando para enviar la solicitud de predicción por lotes:

    curl -X POST \
   -H "Authorization: Bearer $(gcloud auth print-access-token)" \
   -H "Content-Type: application/json; charset=utf-8" \
   -d @request.json \
   "https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/batchPredictionJobs"

    Reemplaza PROJECT_ID por el ID del proyecto.

    Deberías ver la siguiente línea en la respuesta:

    "state": "JOB_STATE_PENDING"

    Tu trabajo de predicción por lotes ahora se ejecuta de forma asíncrona. Se necesitan alrededor de 20 minutos de ejecución.

  5. En la consola de Google Cloud, en la sección Vertex AI, ve a la página Predicciones por lotes.

    Ir a la página Batch predictions

    Mientras se ejecuta el trabajo de predicción por lotes, su estado es Running. Cuando finalice, su estado cambiará a Finished.

  6. Haz clic en el nombre de tu trabajo de predicción por lotes (income-classification-batch-job) y, luego, haz clic en elExportar ubicación en la página de detalles para ver los archivos de salida de tu trabajo por lotes en Cloud Storage.

    Como alternativa, puedes hacer clic en el ícono Visualiza el resultado de la predicción en Cloud Storage (entre la columna Última actualización y el menú Acciones).

  7. Haz clic en el vínculo del archivo prediction.results-00000-of-00002 o prediction.results-00001-of-00002 y, luego, en el vínculo URL de autenticación para abrir el archivo.

    El resultado del trabajo de predicción por lotes debería ser similar a este ejemplo:

    {"instance": ["27", " Private", "391468", " 11th", "7", " Divorced", " Craft-repair", " Own-child", " White", " Male", "0", "0", "40", " United-States"], "prediction": " <=50K"}
{"instance": ["47", " Self-emp-not-inc", "192755", " HS-grad", "9", " Married-civ-spouse", " Machine-op-inspct", " Wife", " White", " Female", "0", "0", "20", " United-States"], "prediction": " <=50K"}
{"instance": ["32", " Self-emp-not-inc", "84119", " HS-grad", "9", " Married-civ-spouse", " Craft-repair", " Husband", " White", " Male", "0", "0", "45", " United-States"], "prediction": " <=50K"}
{"instance": ["32", " Private", "236543", " 12th", "8", " Divorced", " Protective-serv", " Own-child", " White", " Male", "0", "0", "54", " Mexico"], "prediction": " <=50K"}
{"instance": ["60", " Private", "160625", " HS-grad", "9", " Married-civ-spouse", " Prof-specialty", " Husband", " White", " Male", "5013", "0", "40", " United-States"], "prediction": " <=50K"}
{"instance": ["34", " Local-gov", "22641", " HS-grad", "9", " Never-married", " Protective-serv", " Not-in-family", " Amer-Indian-Eskimo", " Male", "0", "0", "40", " United-States"], "prediction": " <=50K"}
{"instance": ["32", " Private", "178623", " HS-grad", "9", " Never-married", " Other-service", " Not-in-family", " Black", " Female", "0", "0", "40", " ?"], "prediction": " <=50K"}
{"instance": ["28", " Private", "54243", " HS-grad", "9", " Divorced", " Transport-moving", " Not-in-family", " White", " Male", "0", "0", "60", " United-States"], "prediction": " <=50K"}
{"instance": ["29", " Local-gov", "214385", " 11th", "7", " Divorced", " Other-service", " Unmarried", " Black", " Female", "0", "0", "20", " United-States"], "prediction": " <=50K"}
{"instance": ["49", " Self-emp-inc", "213140", " HS-grad", "9", " Married-civ-spouse", " Exec-managerial", " Husband", " White", " Male", "0", "1902", "60", " United-States"], "prediction": " >50K"}

Limpia

Para evitar que se apliquen cargos a tu Google Cloud cuenta por los recursos usados en este instructivo, borra el proyecto que contiene los recursos o conserva el proyecto y borra los recursos individuales.

Puedes borrar los recursos individuales en la consola de Google Cloud de la siguiente manera:

  1. Borra el trabajo de predicción por lotes de la siguiente manera:

    1. En la consola de Google Cloud, en la sección Vertex AI, ve a la página Predicciones por lotes.

      Ir a la página Batch predictions

    2. Junto al nombre de tu trabajo de predicción por lotes (income-classification-batch-job), haz clic en el menú Acciones y elige Borrar trabajo de predicción por lotes.

  2. Borra el modelo de la siguiente manera:

    1. En la consola de Google Cloud, en la sección Vertex AI, ve a la página Model Registry.

      Ir a la página Model Registry

    2. Junto al nombre del modelo (income-classifier-model), haz clic en el menú Acciones y selecciona Borrar modelo.

  3. Borra la instancia de Vertex AI Workbench de la siguiente manera:

    1. En la sección Vertex AI de la consola de Google Cloud, ve a la pestaña Instancias en la página Workbench.

      Ir a Vertex AI Workbench

    2. Selecciona la instancia de Vertex AI Workbench workbench-tutorial y haz clic en Borrar.

  4. Borra la instancia de VM de Compute Engine de la siguiente manera:

    1. En la consola de Google Cloud, ve a la página Compute Engine.

      Ir a Compute Engine

    2. Selecciona la instancia de VM on-prem-client y haz clic en Borrar.

  5. Borra los túneles VPN de la siguiente manera:

    1. En la consola de Google Cloud, ve a la página VPN.

      Ir a VPN

    2. En la página VPN, haz clic en la pestaña Túneles de Cloud VPN.

    3. En la lista de túneles VPN, selecciona los cuatro túneles VPN que creaste en este instructivo y haz clic en Borrar.

  6. Borra las puertas de enlace de VPN con alta disponibilidad de la siguiente manera:

    1. En la página VPN, haz clic en la pestaña Puertas de enlace de Cloud VPN.

      Ir a Puertas de enlace de Cloud VPN

    2. En la lista de puertas de enlace de VPN, haz clic en onprem-vpn-gw1.

    3. En la página Detalles de la puerta de enlace de Cloud VPN, haz clic en Borrar puerta de enlace de VPN.

    4. Haz clic en la flecha hacia atrás si es necesario para regresa a la lista de puertas de enlace de VPN y, luego, haz clic en vertex-networking-vpn-gw1

    5. En la página Detalles de la puerta de enlace de Cloud VPN, haz clic en Borrar puerta de enlace de VPN.

  7. Borra los Cloud Routers de la siguiente manera:

    1. Ve a la página Cloud Routers.

      Ir a Cloud Routers

    2. En la lista de Cloud Routers, selecciona los cuatro routers que creaste en este instructivo.

    3. Para borrar los routers, haz clic en Borrar.

      Esta acción también borrará las dos puertas de enlace de Cloud NAT que están conectadas a los Cloud Routers.

  8. Borra la regla de reenvío pscvertex para la red de VPC vertex-networking-vpc de la siguiente manera:

    1. Ve a la pestaña Frontends de la página Balanceo de cargas.

      Ir a Frontends

    2. En la lista de reglas de reenvío, haz clic en pscvertex.

    3. En la página Detalles de la regla de reenvío, haz clic en Borrar.

  9. Borra las redes de VPC de la siguiente manera:

    1. Ir a la página de redes de VPC

      Ir a las redes de VPC

    2. En la lista de redes de VPC, haz clic en onprem-vpc.

    3. En la página Detalles de la red de VPC, haz clic en Borrar la red de VPC.

      Borrar cada red también borra sus subredes, rutas y reglas de firewall.

    4. En la lista de redes de VPC, haz clic en vertex-networking-vpc.

    5. En la página Detalles de la red de VPC, haz clic en Borrar la red de VPC.

  10. Borra el bucket de almacenamiento de la siguiente manera:

    1. En la consola de Google Cloud, ve a la página de Cloud Storage.

      Ir a Cloud Storage

    2. Selecciona tu bucket de almacenamiento y haz clic en Borrar.

  11. Borra las cuentas de servicio workbench-sa y onprem-user-managed-sa de la siguiente manera:

    1. Ve a la página Cuentas de servicio.

      Ir a Cuentas de servicio

    2. Selecciona las cuentas de servicio onprem-user-managed-sa y workbench-sa y haz clic en Borrar.

¿Qué sigue?