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

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 hayan creado 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 se hayan creado las dos puertas de enlace (vertex-networking-vpn-gw1 y onprem-vpn-gw1) 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 pestaña del navegador de la consola de Google Cloud 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 arrow_back 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 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 de la subred onprem-vpc-subnet1 (172.16.10.0/29) aparezca dos veces.

Valida las rutas aprendidas onprem-vpc

1. Haz clic en la flecha hacia atrás arrow_back para volver 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 de la subred workbench-subnet (10.0.1.0/28) 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 anuncios de ruta personalizados para vertex-networking-vpc

En esta sección, crearás un anuncio de ruta personalizado para vertex-networking-vpc-router1 (el Cloud Router d 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 editEditar.

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 consola de Google Cloud.

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íe 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=http://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, debes usar 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). En el resultado dig, se 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 la 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 visor 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ña Instancias en 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 abra el notebook nuevo, habrá una celda de código predeterminada en la que podrás ingresar el código. Parece [ ]: seguido de un campo de texto. El campo de texto es donde pegarás 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 play_arrow 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 add Insertar una celda a continuación, pega el código en la celda y haz clic en play_arrow 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 y reemplaza PROJECT_ID por el ID de tu 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}"
   !gsutil mb -l {REGION} -p {PROJECT_ID} {BUCKET_URI}
   

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 el 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 marcos de datos 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, se incluye la creación y compilación de la aplicación de entrenamiento de Python y se guarda en el bucket de etapa de pruebas.

1. En el 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 las características, el objetivo, la etiqueta y los pasos para entrenar y exportar 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:

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

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

   !gsutil 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 mediante 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 en 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 poder usarlos en el siguiente paso.

   Using endpoint [http://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 mediante la transmisión de registros desde el trabajo a medida que 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 se está ejecutando. Tardará aproximadamente 10 minutos en completarse.

   Cuando se completa el trabajo, puedes importar el modelo del 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 se completa el trabajo, 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.

   Anota el valor en la columna MODEL_ID. La necesitarás para crear la solicitud de predicción por lotes.

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

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

   En la consola de Google Cloud, en la sección Vertex AI, ve a la página 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 a partir 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 de on-prem-client. En la instancia de VM, crea un archivo de texto llamado request.json que contenga la carga útil para una solicitud curl de muestra que envías a tu modelo a fin de 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: El ID del modelo
   • BUCKET_URI: El URI del bucket de almacenamiento en el que almacenaste en etapa intermedia 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 \
      "http://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"
   

   El trabajo de predicción por lotes ahora se ejecuta de forma asíncrona. Toma alrededor de 20 minutos en ejecutarse.

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 storageVisualiza el resultado de la predicción en Cloud Storage (entre la columna Última actualización y el menú more_vertAcciones).

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