Usa Private Service Connect para acceder a las predicciones en línea de Vertex AI desde las instalaciones locales

Crea las redes de VPC

En esta sección, crearás dos redes de VPC: una para crear un modelo de predicción en línea y, luego, implementarla en un extremo, la otra para el acceso privado a ese extremo. 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.

Crea la red de VPC para el extremo de predicción en línea (aiml-vpc)

1. Crea la red de VPC:

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

2. Crea una subred llamada workbench-subnet, con un rango IPv4 principal de 172.16.10.0/28:

   gcloud compute networks subnets create workbench-subnet --project=$projectid --range=172.16.10.0/28 --network=aiml-vpc --region=us-central1 --enable-private-ip-google-access
   

3. Crea un Cloud Router regional llamado cloud-router-us-central1-aiml-nat:

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

4. Agrega una puerta de enlace de Cloud NAT al Cloud Router:

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

Crea la red de VPC “local” (on-prem-vpc)

1. Crea la red de VPC:

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

2. Crea una subred llamada nat-subnet, con un rango IPv4 principal de 192.168.10.0/28:

   gcloud compute networks subnets create nat-subnet --project=$projectid --range=192.168.10.0/28 --network=on-prem-vpc --region=us-central1
   

3. Crea una subred llamada private-ip-subnet, con un rango IPv4 principal de 192.168.20.0/28:

   gcloud compute networks subnets create private-ip-subnet --project=$projectid --range=192.168.20.0/28 --network=on-prem-vpc --region=us-central1
   

4. Crea un Cloud Router regional llamado cloud-router-us-central1-on-prem-nat:

   gcloud compute routers create cloud-router-us-central1-on-prem-nat --network on-prem-vpc --region us-central1
   

5. Agrega una puerta de enlace de Cloud NAT al Cloud Router:

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

Crea el extremo de Private Service Connect (PSC)

En esta sección, crearás el extremo de Private Service Connect (PSC) que las instancias de VM en la red on-prem-vpc usan para acceder al extremo de predicción en línea a través de la API de Vertex AI. El extremo de Private Service Connect (PSC) es una dirección IP interna en la red on-prem-vpc a la que pueden acceder directamente los clientes de esa red. Este extremo se crea mediante la implementación de una regla de reenvío que dirige el tráfico de red que coincide con la dirección IP del extremo de PSC con un paquete de APIs de Google. La dirección IP del extremo de PSC (100.100.10.10) se anunciará desde aiml-vpc-cloud-router-vpn como un anuncio de router personalizado a la red local en un paso posterior.

1. Reserva direcciones IP para el extremo de PSC:

   gcloud compute addresses create psc-ip \
      --global \
      --purpose=PRIVATE_SERVICE_CONNECT \
      --addresses=100.100.10.10 \
      --network=aiml-vpc
   

2. Crea el extremo de PSC:

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

3. Enumera los extremos configurados de PSC y verifica que se haya creado el extremo pscvertex:

   gcloud compute forwarding-rules list  \
    --filter target="(all-apis OR vpc-sc)" --global
   

4. Obtén los detalles del extremo de PSC configurado y verifica que la dirección IP sea 100.100.10.10:

   gcloud compute forwarding-rules describe \
    pscvertex --global
   

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í. Cada puerta de enlace contiene un Cloud Router y un par de túneles VPN.

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

   gcloud compute vpn-gateways create aiml-vpn-gw \
      --network=aiml-vpc\
      --region=us-central1
   

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

   gcloud compute vpn-gateways create on-prem-vpn-gw \
      --network=on-prem-vpc\
      --region=us-central1
   

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

   Ir a VPN

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

5. En la lista de puertas de enlace de VPN, verifica que haya dos puertas de enlace y que cada una tenga dos direcciones IP.

6. En Cloud Shell, crea un Cloud Router para la red de nube privada virtual aiml-vpc:

   gcloud compute routers create aiml-cr-us-central1 \
      --region=us-central1 \
      --network=aiml-vpc\
      --asn=65001
   

7. Crea un Cloud Router para la red de nube privada virtual on-prem-vpc:

   gcloud compute routers create on-prem-cr-us-central1 \
      --region=us-central1 \
      --network=on-prem-vpc \
      --asn=65002
   

Crea los túneles VPN para aiml-vpc

1. Crea un túnel VPN llamado aiml-vpc-tunnel0:

   gcloud compute vpn-tunnels create aiml-vpc-tunnel0 \
      --peer-gcp-gateway on-prem-vpn-gw \
      --region us-central1 \
      --ike-version 2 \
      --shared-secret [ZzTLxKL8fmRykwNDfCvEFIjmlYLhMucH] \
      --router aiml-cr-us-central1 \
      --vpn-gateway aiml-vpn-gw \
      --interface 0
   

2. Crea un túnel VPN llamado aiml-vpc-tunnel1:

   gcloud compute vpn-tunnels create aiml-vpc-tunnel1 \
      --peer-gcp-gateway on-prem-vpn-gw \
      --region us-central1 \
      --ike-version 2 \
      --shared-secret [bcyPaboPl8fSkXRmvONGJzWTrc6tRqY5] \
      --router aiml-cr-us-central1 \
      --vpn-gateway aiml-vpn-gw \
      --interface 1
   

Crea los túneles VPN para on-prem-vpc

1. Crea un túnel VPN llamado on-prem-vpc-tunnel0:

   gcloud compute vpn-tunnels create on-prem-tunnel0 \
      --peer-gcp-gateway aiml-vpn-gw \
      --region us-central1 \
      --ike-version 2 \
      --shared-secret [ZzTLxKL8fmRykwNDfCvEFIjmlYLhMucH] \
      --router on-prem-cr-us-central1 \
      --vpn-gateway on-prem-vpn-gw \
      --interface 0
   

2. Crea un túnel VPN llamado on-prem-vpc-tunnel1:

   gcloud compute vpn-tunnels create on-prem-tunnel1 \
      --peer-gcp-gateway aiml-vpn-gw \
      --region us-central1 \
      --ike-version 2 \
      --shared-secret [bcyPaboPl8fSkXRmvONGJzWTrc6tRqY5] \
      --router on-prem-cr-us-central1 \
      --vpn-gateway on-prem-vpn-gw \
      --interface 1
   

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

   Ir a VPN

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

5. En la lista de túneles VPN, verifica que se hayan establecido 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, aiml-vpc) y tu red local (representada por on-prem-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 aiml-vpc y dos para on-prem-vpc.

Establece sesiones de BGP para aiml-vpc

1. En Cloud Shell, crea la primera interfaz de BGP:

   gcloud compute routers add-interface aiml-cr-us-central1 \
      --interface-name if-tunnel0-to-onprem \
      --ip-address 169.254.1.1 \
      --mask-length 30 \
      --vpn-tunnel aiml-vpc-tunnel0 \
      --region us-central1
   

2. Crea el primer intercambio de tráfico de BGP:

   gcloud compute routers add-bgp-peer aiml-cr-us-central1 \
      --peer-name bgp-on-premises-tunnel0 \
      --interface if-tunnel1-to-onprem \
      --peer-ip-address 169.254.1.2 \
      --peer-asn 65002 \
      --region us-central1
   

3. Crea la segunda interfaz de BGP:

   gcloud compute routers add-interface aiml-cr-us-central1 \
      --interface-name if-tunnel1-to-onprem \
      --ip-address 169.254.2.1 \
      --mask-length 30 \
      --vpn-tunnel aiml-vpc-tunnel1 \
      --region us-central1
   

4. Crea el segundo intercambio de tráfico de BGP:

   gcloud compute routers add-bgp-peer aiml-cr-us-central1 \
      --peer-name bgp-on-premises-tunnel1 \
      --interface if-tunnel2-to-onprem \
      --peer-ip-address 169.254.2.2 \
      --peer-asn 65002 \
      --region us-central1
   

Establece sesiones de BGP para on-prem-vpc

1. Crea la primera interfaz de BGP:

   gcloud compute routers add-interface on-prem-cr-us-central1 \
      --interface-name if-tunnel0-to-aiml-vpc\
      --ip-address 169.254.1.2 \
      --mask-length 30 \
      --vpn-tunnel on-prem-tunnel0 \
      --region us-central1
   

2. Crea el primer intercambio de tráfico de BGP:

   gcloud compute routers add-bgp-peer on-prem-cr-us-central1 \
      --peer-name bgp-aiml-vpc-tunnel0 \
      --interface if-tunnel1-to-aiml-vpc\
      --peer-ip-address 169.254.1.1 \
      --peer-asn 65001 \
      --region us-central1
   

3. Crea la segunda interfaz de BGP:

   gcloud compute routers add-interface on-prem-cr-us-central1 \
      --interface-name if-tunnel1-to-aiml-vpc\
      --ip-address 169.254.2.2 \
      --mask-length 30 \
      --vpn-tunnel on-prem-tunnel1 \
      --region us-central1
   

4. Crea el segundo intercambio de tráfico de BGP:

   gcloud compute routers add-bgp-peer on-prem-cr-us-central1 \
      --peer-name bgp-aiml-vpc-tunnel1\
      --interface if-tunnel2-to-aiml-vpc\
      --peer-ip-address 169.254.2.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 página VPN, haz clic en la pestaña Túneles de Cloud VPN.

3. En la lista de túneles VPN, deberías ver que el valor en la columna Estado de la sesión de BGP para cada uno de los cuatro túneles cambió 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 que aiml-vpc haya aprendido rutas de subred a través de VPN con alta disponibilidad

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 aiml-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 la red de VPC aiml-vpc aprendió rutas desde la subred nat-subnet de las redes de VPC on-prem-vpc (192.168.10.0/28) y la subred private-ip-subnet (192.168.20.0/28).

Valida que on-prem-vpc haya aprendido rutas de subred a través de VPN con alta disponibilidad

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 on-prem-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 la red de VPC on-prem-vpc aprendió rutas desde la subred workbench-subnet de las redes de VPC aiml-vpc (172.16.10.0/28).

Crea anuncios de ruta personalizados para aiml-vpc

El Cloud Router aiml-cr-us-central1 no anuncia de forma automática la dirección IP del extremo de Private Service Connect porque la subred no está configurada en la red de VPC.

Por lo tanto, deberás crear un anuncio de ruta personalizado desde el Cloud Router aiml-cr-us-central para la dirección IP del extremo 100.100.10.10 que se anunciará al entorno local a través de BGP al on-prem-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 aiml-cr-us-central1.

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. Haz clic en Agregar una ruta personalizada.

6. En Fuente, selecciona Rango de IP personalizado.

7. En Rango de direcciones IP, ingresa 100.100.10.10.

8. En Descripción, ingresa Private Service Connect Endpoint IP.

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

Valida que on-prem-vpc haya aprendido la dirección IP del extremo de PSC a través de una VPN con alta disponibilidad

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 on-prem-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 la red de VPC on-prem-vpc haya aprendido la dirección IP del extremo de PSC (100.100.10.10).

Crea anuncios de ruta personalizados para on-prem-vpc

El Cloud Router on-prem-vpc anuncia todas las subredes de forma predeterminada, pero solo se necesita la subred private-ip-subnet.

En la siguiente sección, actualiza los anuncios de ruta del Cloud Router on-prem-cr-us-central1.

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 on-prem-cr-us-central1.

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. Desmarca la casilla de verificación Anunciar todas las subredes visibles para Cloud Router si está seleccionada.

6. Haz clic en Agregar una ruta personalizada.

7. En Fuente, selecciona Rango de IP personalizado.

8. En Rango de direcciones IP, ingresa 192.168.20.0/28.

9. En Descripción, ingresa Private Service Connect Endpoint IP subnet (private-ip-subnet).

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

Verifica que aiml-vpc haya aprendido la ruta private-ip-subnet desde on-prem-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 aiml-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 la red de VPC aiml-vpc aprendió la ruta private-ip-subnet (192.168.20.0/28).

Crea las instancias de VM de prueba

Crea una cuenta de servicio administrada por el usuario.

Si tienes aplicaciones que necesitan realizar llamadas a las APIs de Google Cloud, Google recomienda que conectes una cuenta de servicio administrada por el usuario a la VM en la que se ejecuta la aplicación o la carga de trabajo. Por lo tanto, en esta sección, crearás una cuenta de servicio administrada por el usuario para que se aplique a las instancias de VM que crearás más adelante en este instructivo.

1. En Cloud Shell, crea la cuenta de servicio :

   gcloud iam service-accounts create gce-vertex-sa \
      --description="service account for vertex" \
      --display-name="gce-vertex-sa"
   

2. Asigna el rol de administrador de instancias de Compute (v1) (roles/compute.instanceAdmin.v1) a la cuenta de servicio:

   gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:gce-vertex-sa@$projectid.iam.gserviceaccount.com" --role="roles/compute.instanceAdmin.v1"
   

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:gce-vertex-sa@$projectid.iam.gserviceaccount.com" --role="roles/aiplatform.user"
   

Crea las instancias de VM de prueba

En este paso, crearás instancias de VM de prueba para validar diferentes métodos para llegar a las APIs de Vertex AI, específicamente:

• La instancia nat-client usa Cloud NAT para resolver Vertex AI para acceder al extremo de predicción en línea a través de la Internet pública.
• La instancia private-client usa la dirección IP 100.100.10.10 de Private Service Connect para acceder al extremo de predicción en línea a través de VPN con alta disponibilidad.

Para permitir que Identity-Aware Proxy (IAP) se conecte a tus instancias de VM, crea una regla de firewall que cumpla con lo siguiente:

• Se aplica a todas las instancias de VM que deseas que sean accesibles a través de IAP.
• Permite el tráfico de TCP a través del puerto 22 desde el rango de IP 35.235.240.0/20. Este rango contiene todas las direcciones IP que IAP usa para el reenvío de TCP.

1. Crea la instancia de VM nat-client:

   gcloud compute instances create nat-client \
      --zone=us-central1-a \
      --image-family=debian-11 \
      --image-project=debian-cloud \
      --subnet=nat-subnet \
      --service-account=gce-vertex-sa@$projectid.iam.gserviceaccount.com \
      --scopes=http://www.googleapis.com/auth/cloud-platform \
      --no-address \
      --metadata startup-script="#! /bin/bash
         sudo apt-get update
         sudo apt-get install tcpdump dnsutils -y"
   

2. Crea la instancia de VM private-client:

   gcloud compute instances create private-client \
      --zone=us-central1-a \
      --image-family=debian-11 \
      --image-project=debian-cloud \
      --subnet=private-ip-subnet \
      --service-account=gce-vertex-sa@$projectid.iam.gserviceaccount.com \
      --scopes=http://www.googleapis.com/auth/cloud-platform \
      --no-address \
      --metadata startup-script="#! /bin/bash
         sudo apt-get update
         sudo apt-get install tcpdump dnsutils -y"
   

3. Crea la regla de firewall IAP:

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

Crea una instancia de notebooks administrados por el usuario

Crea una cuenta de servicio administrada por el usuario.

Cuando creas una instancia de notebooks administrados por el usuario de Vertex AI Workbench, Google recomienda que especifiques una cuenta de servicio administrada por el usuario en lugar de usar la cuenta de servicio predeterminada de Compute Engine. La cuenta de servicio predeterminada de Compute Engine (y, por lo tanto, cualquier persona que especifiques como usuario de la instancia) recibe el rol de editor (roles/editor) en tu proyecto de Google Cloud. Puedes inhabilitar este comportamiento si inhabilitas las asignaciones de roles automáticos para las cuentas de servicio predeterminadas.

1. En Cloud Shell, crea una cuenta de servicio llamada user-managed-notebook-sa:

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

2. 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:user-managed-notebook-sa@$projectid.iam.gserviceaccount.com" --role="roles/storage.admin"
   

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:user-managed-notebook-sa@$projectid.iam.gserviceaccount.com" --role="roles/aiplatform.user"
   

4. Asigna el rol de IAM de administrador de Artifact Registry a la cuenta de servicio:

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

Crea la instancia de notebooks administrados por el usuario

Crea una instancia de notebooks administrados por el usuario y especifica la cuenta de servicio user-managed-notebook-sa.

1. Crea la instancia de notebooks administrados por el usuario:

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

Crea e implementa un modelo de predicción en línea

Prepare el entorno

1. En la consola de Google Cloud, ve a la pestaña Notebooks administrados por el usuario en la página de Vertex AI Workbench.

   Ir a Notebooks administrados por el usuario

2. Junto al nombre de la instancia de notebooks administrados por el usuario, haz clic en Abrir JupyterLab.

   Tu instancia de notebooks administrados por el usuario abre JupyterLab.

   En el resto de esta sección, incluso hasta la implementación del modelo, trabajarás en Jupyterlab, no en la consola de Google Cloud o Cloud Shell.

3. Selecciona Archivo > Nuevo > Terminal.

4. En la terminal de JupyterLab (no en Cloud Shell), define una variable de entorno para tu proyecto. Reemplaza PROJECT_ID por el ID del proyecto:

   PROJECT_ID=PROJECT_ID
   

5. Crea un directorio nuevo llamado cpr-codelab y cd en él (aún en la terminal de JupyterLab):

   mkdir cpr-codelab
   cd cpr-codelab
   

6. En el navegador de archivos folder, haz doble clic en la carpeta cpr-codelab nueva.

   Si esta carpeta no aparece en el navegador de archivos, actualiza la pestaña del navegador de la consola de Google Cloud y vuelve a intentarlo.

7. Select Archivo > Nuevo > Notebook.

8. En el menú Seleccionar kernel, selecciona Python 3 y haz clic en Seleccionar.

9. Cambia el nombre de tu nuevo archivo de notebook de la siguiente manera:

   En el navegador de archivos folder, haz clic con el botón derecho en el ícono de archivo Untitled.ipynb y, luego, ingresa task.ipynb.

   Tu directorio cpr-codelab debería verse de la siguiente manera:

   + cpr-codelab/
      + task.ipynb
   

   En los siguientes pasos, crearás el modelo en el notebook de Jupyterlab mediante la creación de nuevas celdas de notebook, el pegado del código en ellas y la ejecución de las celdas.

10. Instala las dependencias de la siguiente manera.

    1. Cuando abras tu notebook nuevo, habrá una celda de código predeterminada en la que podrás ingresar el código. Se verá como [ ]: seguido de un campo de texto. En ese campo de texto, pegará su código.

       Pega el siguiente código en la celda y haz clic en play_arrow Ejecutar las celdas seleccionadas y avanzar para crear un archivo requirements.txt que se usará como entrada en la celda paso siguiente:

       %%writefile requirements.txt
       fastapi
       uvicorn==0.17.6
       joblib~=1.1.1
       numpy>=1.17.3, <1.24.0
       scikit-learn~=1.0.0
       pandas
       google-cloud-storage>=2.2.1,<3.0.0dev
       google-cloud-aiplatform[prediction]>=1.18.2
       

    2. En este paso y cada uno de los siguientes, haz agrega una celda de código haciendo clic enadd Insertar una celda a continuación, pega el código en la celda y haz clic enplay_arrow Ejecutar las celdas seleccionadas y avanza.

       Usa Pip para instalar dependencias en la instancia de notebook:

       !pip install -U --user -r requirements.txt
       

    3. Cuando finalice la instalación, selecciona Kernel > Reiniciar kernel para reiniciar el kernel y asegúrate de que la biblioteca esté disponible para importar

    4. Pega el siguiente código en una celda de notebook nueva para crear los directorios para almacenar el modelo y los artefactos de procesamiento previo:

       USER_SRC_DIR = "src_dir"
       !mkdir $USER_SRC_DIR
       !mkdir model_artifacts
       # copy the requirements to the source dir
       !cp requirements.txt $USER_SRC_DIR/requirements.txt
       

    En el navegador de archivos de folder, la estructura de directorios cpr-codelab debería verse de la siguiente manera:

    + cpr-codelab/
      + model_artifacts/
      + src_dir/
         + requirements.txt
      + requirements.txt
      + task.ipynb
    

Entrenar el modelo

Sigue agregando celdas de código al notebook task.ipynb, pega y ejecuta el siguiente código en cada celda nueva:

1. Importa las bibliotecas:

   import seaborn as sns
   import numpy as np
   import pandas as pd
   
   from sklearn import preprocessing
   from sklearn.ensemble import RandomForestRegressor
   from sklearn.pipeline import make_pipeline
   from sklearn.compose import make_column_transformer
   
   import joblib
   import logging
   
   # set logging to see the docker container logs
   logging.basicConfig(level=logging.INFO)
   

2. Define las siguientes variables y reemplaza PROJECT_ID por el ID del proyecto:

   REGION = "us-central1"
   MODEL_ARTIFACT_DIR = "sklearn-model-artifacts"
   REPOSITORY = "diamonds"
   IMAGE = "sklearn-image"
   MODEL_DISPLAY_NAME = "diamonds-cpr"
   PROJECT_ID = "PROJECT_ID"
   BUCKET_NAME = "gs://PROJECT_ID-cpr-bucket"
   

3. Crea un bucket de Cloud Storage:

   !gsutil mb -l us-central1 $BUCKET_NAME
   

4. Carga los datos desde la biblioteca de Seaborn y, luego, crea dos marcos de datos, uno con las funciones y el otro con la etiqueta:

   data = sns.load_dataset('diamonds', cache=True, data_home=None)
   
   label = 'price'
   
   y_train = data['price']
   x_train = data.drop(columns=['price'])
   

5. Observa los datos de entrenamiento y verifica que cada fila represente un diamante.

   x_train.head()
   

6. Mira las etiquetas, que son los precios correspondientes.

   y_train.head()
   

7. Define una transformación de columna de sklearn para una codificación en caliente en los atributos categóricos y escala los atributos numéricos:

   column_transform = make_column_transformer(
      (preprocessing.OneHotEncoder(sparse=False), [1,2,3]),
      (preprocessing.StandardScaler(), [0,4,5,6,7,8]))
   

8. Define el modelo de bosque aleatorio:

   regr = RandomForestRegressor(max_depth=10, random_state=0)
   

9. Crea una canalización de sklearn. Esta canalización toma datos de entrada, los codifica y los escala, y los pasa al modelo.

   my_pipeline = make_pipeline(column_transform, regr)
   

10. Entrena el modelo:

    my_pipeline.fit(x_train, y_train)
    

11. Llama al método de predicción en el modelo y pasa una muestra de prueba.

    my_pipeline.predict([[0.23, 'Ideal', 'E', 'SI2', 61.5, 55.0, 3.95, 3.98, 2.43]])
    

    Es posible que veas advertencias como "X does not have valid feature names, but", pero puedes ignorarlas.

12. Guarda la canalización en el directorio model_artifacts y cópialo en el bucket de Cloud Storage:

    joblib.dump(my_pipeline, 'model_artifacts/model.joblib')
    
    !gsutil cp model_artifacts/model.joblib {BUCKET_NAME}/{MODEL_ARTIFACT_DIR}/
    

Guarda un artefacto de procesamiento previo

1. Crea un artefacto de procesamiento previo. Este artefacto se cargará al contenedor personalizado cuando se inicie el servidor de modelos. Tu artefacto de procesamiento previo puede tener casi cualquier forma (como un archivo pickle), pero en este caso escribirás un diccionario en un archivo JSON:

   clarity_dict={"Flawless": "FL",
      "Internally Flawless": "IF",
      "Very Very Slightly Included": "VVS1",
      "Very Slightly Included": "VS2",
      "Slightly Included": "S12",
      "Included": "I3"}
   

Crea un contenedor de entrega personalizado con el servidor de modelo de CPR

1. El atributo clarity en nuestros datos de entrenamiento siempre estaba en el formato abreviado (es decir, “FL” en lugar de “Flawless”). En el momento de la entrega, queremos comprobar que los datos de este atributo también se abrevian. Esto se debe a que nuestro modelo sabe cómo codificar “FLO” de forma activa, pero no “Flawless”. Escribirás esta lógica de procesamiento previo personalizado más adelante. Sin embargo, por ahora, solo guarda esta tabla de consulta en un archivo JSON y, luego, escríbela en tu bucket de Cloud Storage:

   import json
   with open("model_artifacts/preprocessor.json", "w") as f:
      json.dump(clarity_dict, f)
   
   !gsutil cp model_artifacts/preprocessor.json {BUCKET_NAME}/{MODEL_ARTIFACT_DIR}/
   

   En el navegador de archivos de folder, la estructura del directorio ahora debería verse así:

   + cpr-codelab/
   + model_artifacts/
      + model.joblib
      + preprocessor.json
   + src_dir/
      + requirements.txt
   + requirements.txt
   + task.ipynb
   

2. En tu notebook, pega y ejecuta el siguiente código para subclasificar el sklearnPredictionor y escribirlo en un archivo de Python en el src_dir/. Ten en cuenta que, en este ejemplo, solo personalizamos los métodos de carga, procesamiento previo y proceso posterior, y no el método de predicción.

   %%writefile $USER_SRC_DIR/predictor.py
   
   import joblib
   import numpy as np
   import json
   
   from google.cloud import storage
   from google.cloud.aiplatform.prediction.sklearn.predictor import SklearnPredictor
   
   class CprPredictor(SklearnPredictor):
   
    def __init__(self):
        return
   
    def load(self, artifacts_uri: str) -> None:
        """Loads the sklearn pipeline and preprocessing artifact."""
   
        super().load(artifacts_uri)
   
        # open preprocessing artifact
        with open("preprocessor.json", "rb") as f:
            self._preprocessor = json.load(f)
   
    def preprocess(self, prediction_input: np.ndarray) -> np.ndarray:
        """Performs preprocessing by checking if clarity feature is in abbreviated form."""
   
        inputs = super().preprocess(prediction_input)
   
        for sample in inputs:
            if sample[3] not in self._preprocessor.values():
                sample[3] = self._preprocessor[sample[3]]
        return inputs
   
    def postprocess(self, prediction_results: np.ndarray) -> dict:
        """Performs postprocessing by rounding predictions and converting to str."""
   
        return {"predictions": [f"${value}" for value in np.round(prediction_results)]}
   

3. Usa el SDK de Vertex AI para Python para compilar la imagen con rutinas de predicción personalizadas. Se genera el Dockerfile y se compila una imagen para ti.

   from google.cloud import aiplatform
   
   aiplatform.init(project=PROJECT_ID, location=REGION)
   
   import os
   
   from google.cloud.aiplatform.prediction import LocalModel
   
   from src_dir.predictor import CprPredictor  # Should be path of variable $USER_SRC_DIR
   
   local_model = LocalModel.build_cpr_model(
      USER_SRC_DIR,
      f"{REGION}-docker.pkg.dev/{PROJECT_ID}/{REPOSITORY}/{IMAGE}",
      predictor=CprPredictor,
      requirements_path=os.path.join(USER_SRC_DIR, "requirements.txt"),
   )
   

4. Escribe un archivo de prueba con dos muestras para la predicción. Una de las instancias tiene el nombre abreviado de claridad, pero la otra debe convertirse primero.

   import json
   
   sample = {"instances": [
      [0.23, 'Ideal', 'E', 'VS2', 61.5, 55.0, 3.95, 3.98, 2.43],
      [0.29, 'Premium', 'J', 'Internally Flawless', 52.5, 49.0, 4.00, 2.13, 3.11]]}
   
   with open('instances.json', 'w') as fp:
      json.dump(sample, fp)
   

5. Prueba el contenedor de forma local mediante la implementación de un modelo local.

   with local_model.deploy_to_local_endpoint(
      artifact_uri = 'model_artifacts/', # local path to artifacts
   ) as local_endpoint:
      predict_response = local_endpoint.predict(
         request_file='instances.json',
         headers={"Content-Type": "application/json"},
      )
   
      health_check_response = local_endpoint.run_health_check()
   

6. Puedes ver los resultados de la predicción de la siguiente forma:

   predict_response.content
   

Implementa el modelo en el extremo del modelo de predicción en línea

Ahora que probaste el contenedor de forma local, es momento de enviar la imagen a Artifact Registry y subir el modelo a Vertex AI Model Registry.

1. Configurar Docker para acceder a Artifact Registry

   !gcloud artifacts repositories create {REPOSITORY} --repository-format=docker \
   --location=us-central1 --description="Docker repository"
   
   !gcloud auth configure-docker {REGION}-docker.pkg.dev --quiet
   

2. Envía la imagen.

   local_model.push_image()
   

3. Sube el modelo.

   model = aiplatform.Model.upload(local_model = local_model,
                                   display_name=MODEL_DISPLAY_NAME,
                                   artifact_uri=f"{BUCKET_NAME}/{MODEL_ARTIFACT_DIR}",)
   

4. Implementa el modelo:

   endpoint = model.deploy(machine_type="n1-standard-2")
   

   Espera hasta que tu modelo se implemente antes de continuar con el siguiente paso. La implementación tardará de 10 a 15 minutos como mínimo.

5. Prueba el modelo implementado mediante una predicción:

   endpoint.predict(instances=[[0.23, 'Ideal', 'E', 'VS2', 61.5, 55.0, 3.95, 3.98, 2.43]])
   

Valida el acceso a Internet pública para las APIs de Vertex AI

En esta sección, accederás a la instancia de VM nat-client en una pestaña de sesión de Cloud Shell y usarás otra pestaña de sesión para validar la conectividad a las APIs de Vertex AI mediante la ejecución de dig y tcpdump comandos en el dominio us-central1-aiplatform.googleapis.com.

1. En Cloud Shell (Tab One), 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 nat-client con IAP:

   gcloud compute ssh nat-client --project=$projectid --zone=us-central1-a --tunnel-through-iap
   

3. Ejecuta el comando dig:

   dig us-central1-aiplatform.googleapis.com
   

4. Desde la VM nat-client (Tab One), ejecuta el siguiente comando para validar la resolución de DNS cuando envíes una solicitud de predicción en línea al extremo.

    sudo tcpdump -i any port 53 -n
   

5. Para abrir una sesión nueva de Cloud Shell (pestaña dos), haz clic en add abrir una pestaña nueva en Cloud Shell.

6. En la sesión nueva de Cloud Shell (pestaña dos), ejecuta los siguientes comandos y reemplaza PROJECT_ID por el ID del proyecto:

   projectid=PROJECT_ID
   gcloud config set project ${projectid}
   

7. Accede a la instancia de VM nat-client:

   gcloud compute ssh --zone "us-central1-a" "nat-client" --project "$projectid"
   

8. Desde la VM nat-client (pestaña dos), usa un editor de texto, como vim o nano para crear un archivo instances.json. Debes anteponer sudo para tener permiso para escribir en el archivo, por ejemplo:

   sudo vim instances.json
   

9. Agrega la siguiente string de datos al archivo:

   {"instances": [
      [0.23, 'Ideal', 'E', 'VS2', 61.5, 55.0, 3.95, 3.98, 2.43],
      [0.29, 'Premium', 'J', 'Internally Flawless', 52.5, 49.0, 4.00, 2.13, 3.11]]}
   

10. 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.

11. Ubica el ID de extremo de predicción en línea del extremo de PSC:

    1. En la consola de Google Cloud, en la sección Vertex AI, ve a la pestaña Extremos en la página Predicción en línea.

       Ir a Endpoints

    2. Busca la fila del extremo que creaste, llamada diamonds-cpr_endpoint.

    3. Ubica el ID de extremo de 19 dígitos en la columna ID y cópialo.

12. En Cloud Shell, desde la VM nat-client (pestaña dos), ejecuta los siguientes comandos y reemplaza PROJECT_ID por el ID de tu proyecto y ENDPOINT_ID por el ID de extremo de PSC:

    projectid=PROJECT_ID
    gcloud config set project ${projectid}
    ENDPOINT_ID=ENDPOINT_ID
    

13. Desde la VM de nat-client (pestaña dos), ejecuta el siguiente comando para enviar una solicitud de predicción en línea:

    curl -X POST -H "Authorization: Bearer $(gcloud auth print-access-token)" -H "Content-Type: application/json" http://us-central1-aiplatform.googleapis.com/v1/projects/${projectid}/locations/us-central1/endpoints/${ENDPOINT_ID}:predict -d @instances.json
    

Ahora que ejecutaste la predicción, verás que los resultados de tcpdump (pestaña uno) muestran la instancia de VM nat-client (192.168.10.2) que realiza una consulta de Cloud DNS a el servidor DNS local (169.254.169.254) para el dominio de la API de Vertex AI (us-central1-aiplatform.googleapis.com). La consulta de DNS muestra direcciones IP virtuales (VIP) públicas para las APIs de Vertex AI.

Valida el acceso privado a las APIs de Vertex AI

En esta sección, accederás a la instancia de VM private-client mediante Identity-Aware Proxy en una sesión nueva de Cloud Shell (pestaña tres) y, luego, validarás la conectividad a las APIs de Vertex AI mediante la ejecución del comando dig en el dominio de Vertex AI (us-central1-aiplatform.googleapis.com)

1. Para abrir una sesión nueva de Cloud Shell (pestaña tres), haz clic en add abrir una pestaña nueva en Cloud Shell. Esta es la pestaña tres.

2. En la sesión nueva de Cloud Shell (pestaña tres), ejecuta los siguientes comandos y reemplaza PROJECT_ID por el ID del proyecto:

   projectid=PROJECT_ID
   gcloud config set project ${projectid}
   

3. Accede a la instancia de VM private-client mediante IAP:

   gcloud compute ssh private-client --project=$projectid --zone=us-central1-a --tunnel-through-iap
   

4. Ejecuta el comando dig:

   dig us-central1-aiplatform.googleapis.com
   

5. En la instancia de VM private-client (pestaña tres), usa un editor de texto, como vim o nano, para agregar la siguiente línea al archivo /etc/hosts:

   100.100.10.10 us-central1-aiplatform.googleapis.com
   

   Esta línea asigna la dirección IP del extremo de PSC (100.100.10.10) al nombre de dominio completamente calificado para la API de Google de Vertex AI (us-central1-aiplatform.googleapis.com). El archivo editado debe verse de la siguiente manera:

   127.0.0.1       localhost
   ::1             localhost ip6-localhost ip6-loopback
   ff02::1         ip6-allnodes
   ff02::2         ip6-allrouters
   
   100.100.10.10 us-central1-aiplatform.googleapis.com # Added by you
   192.168.20.2 private-client.c.$projectid.internal private-client  # Added by Google
   169.254.169.254 metadata.google.internal  # Added by Google
   

6. Desde la VM de private-client (pestaña tres), haz ping al extremo de Vertex AI y a Control+C para salir cuando veas el resultado:

   ping us-central1-aiplatform.googleapis.com
   

   El comando ping debe mostrar el siguiente resultado que contiene la dirección IP del extremo de PSC:

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

7. Desde la VM private-client (pestaña tres), usa tcpdump para ejecutar el siguiente comando para validar la resolución de DNS y la ruta de acceso de los datos IP cuando envíes una solicitud de predicción en línea al extremo:

    sudo tcpdump -i any port 53 -n or host 100.100.10.10
   

8. Para abrir una sesión nueva de Cloud Shell (pestaña cuatro), haz clic en add Abrir una pestaña nueva en Cloud Shell.

9. En la sesión nueva de Cloud Shell (pestaña cuatro), ejecuta los siguientes comandos y reemplaza PROJECT_ID por el ID del proyecto:

   projectid=PROJECT_ID
   gcloud config set project ${projectid}
   

10. En la pestaña cuatro, accede a la instancia private-client:

    gcloud compute ssh --zone "us-central1-a" "private-client" --project "$projectid"
    

11. Desde la VM de private-client (pestaña cuatro), con un editor de texto, como vim o nano, crea un archivo instances.json que contenga la siguiente string de datos:

    {"instances": [
       [0.23, 'Ideal', 'E', 'VS2', 61.5, 55.0, 3.95, 3.98, 2.43],
       [0.29, 'Premium', 'J', 'Internally Flawless', 52.5, 49.0, 4.00, 2.13, 3.11]]}
    

12. Desde la VM private-client (pestaña cuatro), ejecuta los siguientes comandos y reemplaza PROJECT_ID por el nombre de tu proyecto y ENDPOINT_ID por el ID de extremo de PSC:

    projectid=PROJECT_ID
    echo $projectid
    ENDPOINT_ID=ENDPOINT_ID
    

13. Desde la VM de private-client (pestaña cuatro), ejecuta el siguiente comando para enviar una solicitud de predicción en línea:

    curl -v -X POST -H "Authorization: Bearer $(gcloud auth print-access-token)" -H "Content-Type: application/json" http://us-central1-aiplatform.googleapis.com/v1/projects/${projectid}/locations/us-central1/endpoints/${ENDPOINT_ID}:predict -d @instances.json
    

14. Desde la VM private-client en Cloud Shell (pestaña tres), verifica que se haya usado la dirección IP del extremo (100.100.10.10) de PSC para acceder a las APIs de Vertex AI.

    Desde la terminal private-client tcpdump en la pestaña tres de Cloud Shell, puedes ver que no es necesaria una búsqueda de DNS a us-central1-aiplatform.googleapis.com, ya que la línea que agregaste a /etc/hosts tiene prioridad, y se usa la dirección IP PSC 100.100.10.10 en la ruta de datos.