Usa Private Service Connect para acceder a las inferencias por lotes de la plataforma de agentes de Gemini Enterprise 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 inferencia por lotes y la otra para 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 Cloud de Confiance , 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 Cloud de Confiance , 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 Cloud de Confiance , 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 Cloud de Confiance by S3NS 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 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 Cloud de Confiance , 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 Cloud de Confiance , 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 Cloud de Confiance by S3NS pestaña del navegador de la consola para ver los valores nuevos.

Valida las rutas aprendidas de vertex-networking-vpc

1. En la consola de Cloud de Confiance , 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 arrow_backflecha 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 Cloud de Confiance , 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 Cloud de Confiance , 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 Cloud de Confiance by S3NS .

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 inferencia 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 Agent Platform (roles/aiplatform.user) a la cuenta de servicio:

   gcloud projects add-iam-policy-binding $projectid \
     --member="serviceAccount:onprem-user-managed-sa@$projectid.s3ns.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.s3ns.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.s3ns.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 Agent Platform

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 Agent Platform (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 Agent Platform.

En la siguiente sección, configurarás el acceso privado a la API de Gemini Enterprise Agent Platform.

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 Agent Platform

En esta sección, debes configurar el acceso privado a la API de Agent Platform para que, cuando envíes solicitudes de inferencia 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 inferencia por lotes de Gemini Enterprise Agent Platform.

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 Gemini Enterprise Agent Platform (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 al extremo de Gemini Enterprise Agent Platform 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 Agent Platform (roles/aiplatform.user) a la cuenta de servicio:

   gcloud projects add-iam-policy-binding $projectid \
     --member="serviceAccount:workbench-sa@$projectid.s3ns.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.s3ns.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.s3ns.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.s3ns.iam.gserviceaccount.com" \
     --role="roles/logging.viewer"
   

Crea la instancia de Agent Platform Workbench

1. En Cloud Shell, crea una instancia de Agent Platform 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.s3ns.iam.gserviceaccount.com
   

2. En la Cloud de Confiance consola, ve a la pestaña Instancias en la página Gemini Enterprise Agent Platform Workbench.

   Ir a Agent Platform Workbench

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

   Tu instancia de Agent Platform 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.

   Para instalar el SDK de Agent Platform 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, 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 inferencia.

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 Model Registry de Gemini Enterprise Agent Platform.

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 Model Registry de Gemini Enterprise Agent Platform.

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 Gemini Enterprise Agent Platform 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 inferencia 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 Cloud de Confiance , en la sección Agent Platform, ve a la página Model Registry de Gemini Enterprise Agent Platform.

   Ir a la página Model Registry de Gemini Enterprise Agent Platform

   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 inferencias por lotes del modelo

Ahora puedes solicitar inferencias por lotes desde el modelo. Las solicitudes de inferencia por lotes se realizan desde la instancia de VM on-prem-client.

Crea la solicitud de inferencia 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 inferencias 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 inferencia 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 con el ID del proyecto.

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

   "state": "JOB_STATE_PENDING"
   

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

5. En la Cloud de Confiance consola, en la sección Agent Platform, ve a la página Predicciones por lotes.

   Ir a la página Batch predictions

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

6. Haz clic en el nombre de tu trabajo de inferencia por lotes (income-classification-batch-job) y, luego, haz clic en el vínculo Ubicación de la exportació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 inferencia 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"}