Usa Private Service Connect para acceder a las canalización de entrenamiento desde las instalaciones locales

Vertex AI Pipelines es un servicio administrado que te ayuda a compilar, implementar y administrar flujos de trabajo de aprendizaje automático (AA) de extremo a extremo en la plataforma de Google Cloud. Proporciona un entorno sin servidores para ejecutar tus canalizaciones, de modo que no tengas que preocuparte por administrar la infraestructura.

En este instructivo, usarás Vertex AI Pipelines para ejecutar un trabajo de entrenamiento personalizado y, luego, implementar el modelo entrenado en Vertex AI, en un entorno de red híbrida.

Todo el proceso tarda entre dos y tres horas en completarse, incluidos unos 50 minutos para la ejecución de la canalización.

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

Diagrama de arquitectura del uso de Private Service Connect para acceder a las canalizaciones de entrenamiento.

Crea las redes de VPC

En esta sección, crearás dos redes de VPC: una para acceder a las APIs de Google para Vertex AI Pipelines 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. 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 la red de VPC vertex-networking-vpc

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

  3. En la red vertex-networking-vpc, crea una subred llamada pipeline-networking-subnet1, con un rango IPv4 principal de 10.0.0.0/24:

    gcloud compute networks subnets create pipeline-networking-subnet1 \
    --range=10.0.0.0/24 \
    --network=vertex-networking-vpc \
    --region=us-central1 \
    --enable-private-ip-google-access

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

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

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

    gcloud compute networks subnets create onprem-dataservice-vpc-subnet1 \
    --network onprem-dataservice-vpc \
    --range 172.16.10.0/24 \
    --region us-central1 \
    --enable-private-ip-google-access

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-dataservice-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 pipeline-networking-subnet1 y onprem-dataservice-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-dataservice-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-dataservice-vpc:

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

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

    Ir a VPN

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

Crea Cloud Routers y puertas de enlace Cloud NAT

En cada una de las dos redes de VPC, debes crear dos Cloud Routers: uno para usar con Cloud NAT y otro para administrar las sesiones de BGP para la VPN con alta disponibilidad.

  1. En Cloud Shell, crea un Cloud Router para la red de VPC vertex-networking-vpc que se usará para la VPN:

    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-dataservice-vpc que se usará para la VPN:

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

  3. Crea un Cloud Router para la red de VPC vertex-networking-vpc que se usará para Cloud NAT:

    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:

    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 para la red de VPC onprem-dataservice-vpc que se usará para Cloud NAT:

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

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

    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 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-dataservice-vpc-router1
    • vertex-networking-vpc-router1

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

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

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

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

  12. En la lista de Cloud 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-dataservice-vpc, crea un túnel VPN llamado onprem-dataservice-vpc-tunnel0:

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

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

    gcloud compute vpn-tunnels create onprem-dataservice-vpc-tunnel1 \
    --peer-gcp-gateway vertex-networking-vpn-gw1 \
    --region us-central1\
    --ike-version 2 \
    --shared-secret [bcyPaboPl8fSkXRmvONGJzWTrc6tRqY5] \
    --router onprem-dataservice-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-dataservice-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-dataservice-vpc.

Después de 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-dataservice-vpc

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

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

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

    gcloud compute routers add-bgp-peer onprem-dataservice-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-dataservice-vpc, crea una interfaz de BGP para onprem-dataservice-vpc-tunnel1:

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

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

    gcloud compute routers add-bgp-peer onprem-dataservice-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 Google Cloud pestaña del navegador de la consola para ver los valores nuevos.

Valida las rutas aprendidas de onprem-dataservice-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 onprem-dataservice-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.0.0/24) de la subred pipeline-networking-subnet1 aparezca dos veces.

    Es posible que debas actualizar la pestaña del navegador de la consola Google Cloud para ver ambas entradas.

Valida las rutas aprendidas de vertex-networking-vpc

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

  2. En la lista de redes de VPC, haz clic en 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/24) de la subred onprem-dataservice-vpc-subnet1 aparezca dos veces.

Crea un extremo de Private Service Connect para las APIs de Google

En esta sección, crearás un extremo de Private Service Connect para las APIs de Google que usarás para acceder a la API de Vertex AI Pipelines REST desde tu red local.

  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 de vertex-networking-vpc) para anunciar la dirección IP del extremo de PSC a la red de VPC onprem-dataservice-vpc.

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

    Ir a Cloud Routers

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

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

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

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

  6. Haz clic en Agregar una ruta personalizada.

  7. En Fuente, selecciona Rango de IP personalizado.

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

    192.168.0.1

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

    Custom route to advertise Private Service Connect endpoint IP address

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

Valida que onprem-dataservice-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-dataservice-vpc.
    2. En Región, elige us-central1 (Iowa).
    3. Haz clic en Ver.

    4. En la lista de rutas, verifica que haya dos entradas cuyos nombres comiencen con onprem-dataservice-vpc-router1-bgp-vertex-networking-vpc-tunnel0 y dos que comiencen con onprem-dataservice-vpc-router1-bgp-vertex-networking-vpc-tunnel1.

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

    5. Verifica que dos de las entradas tengan un rango de IP de destino de 192.168.0.1/32 y que dos tengan un rango de IP de destino de 10.0.0.0/24.

Crea una instancia de VM en onprem-dataservice-vpc

En esta sección, crearás una instancia de VM que simule un host de servicio de datos local. 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 la cuenta de servicio administrada por el usuario para la instancia de VM

  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"

  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 Vertex AI (roles/aiplatform.viewer):

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

  5. Asigna el rol Editor de Filestore (roles/file.editor).

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

  6. Asigna el rol de Administrador de cuentas de servicio (roles/iam.serviceAccountAdmin):

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

  7. Asigna el rol Usuario de cuenta de servicio (roles/iam.serviceAccountUser).

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

  8. Asigna el rol de lector de Artifact Registry (roles/artifactregistry.reader):

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

  9. Asigna el rol Administrador de objetos de almacenamiento (roles/storage.objectAdmin).

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

  10. Asigna el rol de administrador de Logging (roles/logging.admin):

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

Crea la instancia de VM on-prem-dataservice-host

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-dataservice-host:

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

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

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

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

En esta sección, 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 Cloud Shell, accede a la instancia de VM on-prem-dataservice-host con IAP:

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

  2. En la instancia de VM on-prem-dataservice-host, usa un editor de texto, como vim o nano para abrir el archivo /etc/hosts, por ejemplo:

    sudo vim /etc/hosts

  3. 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-dataservice-host.us-central1-a.c.PROJECT_ID.internal on-prem-dataservice-host  # Added by Google
169.254.169.254 metadata.google.internal  # Added by Google

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

  5. Haz ping en el extremo de API 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.

  6. Escribe Control+C para salir de ping.

  7. Escribe exit para salir de la instancia de VM on-prem-dataservice-host y volver al símbolo del sistema de Cloud Shell.

Configura las redes para una instancia de Filestore

En esta sección, habilitarás el acceso privado a servicios para tu red de VPC, como preparación para crear una instancia de Filestore y activarla como un recurso compartido del sistema de archivos de red (NFS). Para comprender lo que harás en esta sección y en la siguiente, consulta Cómo activar un recurso compartido de NFS para el entrenamiento personalizado y Cómo configurar el intercambio de tráfico entre redes de VPC.

Habilita el acceso privado a servicios en una red de VPC

En esta sección, crearás una conexión de Service Networking y la usarás para habilitar el acceso privado a servicios a la red de VPC onprem-dataservice-vpc a través del intercambio de tráfico entre redes de VPC.

  1. En Cloud Shell, establece un rango de direcciones IP reservadas con gcloud compute addresses create:

    gcloud compute addresses create filestore-subnet \
   --global \
   --purpose=VPC_PEERING \
   --addresses=10.243.208.0 \
   --prefix-length=24 \
   --description="filestore subnet" \
   --network=onprem-dataservice-vpc

  2. Establece una conexión de intercambio de tráfico entre la red de VPC onprem-dataservice-vpc y las Herramientas de redes de servicios de Google con gcloud services vpc-peerings connect:

    gcloud services vpc-peerings connect \
    --service=servicenetworking.googleapis.com \
    --ranges=filestore-subnet \
    --network=onprem-dataservice-vpc

  3. Actualiza el intercambio de tráfico entre redes de VPC para habilitar la importación y exportación de rutas personalizadas aprendidas:

    gcloud compute networks peerings update servicenetworking-googleapis-com \
    --network=onprem-dataservice-vpc \
    --import-custom-routes \
    --export-custom-routes

  4. En la consola de Google Cloud , ve a la página Intercambio de tráfico entre redes de VPC.

    Ir a Intercambio de tráfico entre redes de VPC

  5. En la lista de intercambios de tráfico entre VPC, verifica que haya una entrada para el intercambio de tráfico entre servicenetworking.googleapis.com y la red de VPC onprem-dataservice-vpc.

Crea anuncios de ruta personalizados para filestore-subnet

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

    Ir a Cloud Routers

  2. En la lista de Cloud Router, haz clic en onprem-dataservice-vpc-router1.

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

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

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

  6. Haz clic en Agregar una ruta personalizada.

  7. En Fuente, selecciona Rango de IP personalizado.

  8. En Rango de direcciones IP, ingresa el siguiente rango de direcciones IP:

    10.243.208.0/24

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

    Filestore reserved IP address range

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

Crea la instancia de Filestore en la red onprem-dataservice-vpc

Después de habilitar el acceso privado a servicios para tu red de VPC, debes crear una instancia de Filestore y activarla como un recurso compartido de NFS para tu trabajo de entrenamiento personalizado. Esto permite que los trabajos accedan a archivos remotos como si fueran locales, lo que permite una alta capacidad de procesamiento y una latencia baja.

Crea la instancia de Filestore

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

    Ir a Instancias de Filestore

  2. Haz clic en Crear instancia y configúrala como se indica a continuación:

    • Establece el ID de instancia como se indica a continuación:

      image-data-instance

    • Configura el Tipo de instancia como Básico.

    • Configura Tipo de almacenamiento como HDD.

    • Establece Asigna la capacidad a 1TiB.

    • Establece la Región en us-central1 y la Zona en us-central1-c.

    • Establece la red de VPC en onprem-dataservice-vpc.

    • Configura el rango de IP asignado como Usar un rango de IP asignado existente y elige filestore-subnet.

    • Configura el Nombre del archivo compartido de la siguiente manera:

      vol1

    • Configura Controles de acceso como Otorgar acceso a todos los clientes en la red de VPC.

  3. Haz clic en Crear.

  4. Anota la dirección IP de tu nueva instancia de Filestore. Es posible que debas actualizar la pestaña del navegador de la consola Google Cloud para ver la instancia nueva.

Activa los archivos compartidos de Filestore

  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-dataservice-host:

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

  3. Instala el paquete de NFS en la instancia de VM:

    sudo apt-get update -y
sudo apt-get -y install nfs-common

  4. Crea un directorio de activación para los archivos compartidos de Filestore:

    sudo mkdir -p /mnt/nfs

  5. Activa el archivo compartido y reemplaza FILESTORE_INSTANCE_IP por la dirección IP de tu instancia de Filestore:

    sudo mount FILESTORE_INSTANCE_IP:/vol1 /mnt/nfs

    Si se agota el tiempo de espera de la conexión, verifica la dirección IP correcta de la instancia de Filestore.

  6. Ejecuta el siguiente comando para validar que la activación de NFS se realizó correctamente:

    df -h

    Verifica que los archivos compartidos /mnt/nfs aparezcan en el resultado:

    Filesystem           Size  Used Avail Use% Mounted on
udev                 1.8G     0  1.8G   0% /dev
tmpfs                368M  396K  368M   1% /run
/dev/sda1            9.7G  1.9G  7.3G  21% /
tmpfs                1.8G     0  1.8G   0% /dev/shm
tmpfs                5.0M     0  5.0M   0% /run/lock
/dev/sda15           124M   11M  114M   9% /boot/efi
tmpfs                368M     0  368M   0% /run/user
10.243.208.2:/vol1  1007G     0  956G   0% /mnt/nfs

  7. Cambia los permisos para acceder a los archivos compartidos:

    sudo chmod go+rw /mnt/nfs

Descarga el conjunto de datos en los archivos compartidos

  1. En la instancia de VM de on-prem-dataservice-host, descarga el conjunto de datos los archivos compartidos:

    gcloud storage cp gs://cloud-samples-data/vertex-ai/dataset-management/datasets/fungi_dataset /mnt/nfs/ --recursive

    La descarga tarda varios minutos.

  2. Ejecuta el siguiente comando para confirmar que el conjunto de datos se copió correctamente:

    sudo du -sh /mnt/nfs

    El resultado esperado es el siguiente:

    104M    /mnt/nfs

  3. Escribe exit para salir de la instancia de VM on-prem-dataservice-host y volver al símbolo del sistema de Cloud Shell.

Crea un bucket de etapa de pruebas para tu canalización

Vertex AI Pipelines almacena los artefactos de las ejecuciones de tu canalización mediante Cloud Storage. Antes de ejecutar la canalización, debes crear un bucket de Cloud Storage para las ejecuciones de canalizaciones de etapa de pruebas.

En Cloud Shell, crea un bucket de Cloud Storage:

gcloud storage buckets create gs://pipelines-staging-bucket-$projectid --location=us-central1

Crea una cuenta de servicio administrada por el usuario para Vertex AI Workbench

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

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

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

  3. Asigna el rol Administrador de Artifact Registry (artifactregistry.admin).

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

  4. Asigna el rol Administrador de almacenamiento (storage.admin).

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

Crea la aplicación de entrenamiento de Python

En esta sección, crearás una instancia de Vertex AI Workbench y la usarás para crear un paquete de aplicación de entrenamiento personalizado en Python.

Crea una instancia de Vertex AI Workbench

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

    Ir a Vertex AI Workbench

  2. Haz clic en  Crear nueva y haz clic en Opciones avanzadas.

    Se abrirá la página Instancia nueva.

  3. En la página Instancia nueva, en la sección Detalles, proporciona la siguiente información para tu nueva instancia y haz clic en Continuar:

    • Nombre: Ingresa lo siguiente y reemplaza PROJECT_ID por el ID del proyecto:

      pipeline-tutorial-PROJECT_ID

    • Región: selecciona us-central1.

    • Zona: Selecciona us-central1-a.

    • Desmarca la casilla de verificación Habilitar sesiones interactivas sin servidor de Dataproc.

  4. En la sección Entorno, haz clic en Continuar.

  5. En la sección Tipo de máquina, proporciona lo siguiente y, luego, haz clic en Continuar:

    • Tipo de máquina: Elige N1 y, luego, selecciona n1-standard-4 en el menú Tipo de máquina.

    • VM protegida: Selecciona las siguientes casillas de verificación:

      • Inicio seguro
      • Módulo de plataforma segura virtual (vTPM)
      • Supervisión de integridad

  6. En la sección Discos, asegúrate de que Google-managed encryption key esté seleccionado y, luego, haz clic en Continuar:

  7. En la sección Herramientas de redes, proporciona lo siguiente y, luego, haz clic en Continuar:

    • Herramientas de redes: Selecciona Red en este proyecto y completa los siguientes pasos:

      1. En el campo Red, selecciona vertex-networking-vpc.

      2. En el campo Subred, selecciona pipeline-networking-subnet1.

      3. Desmarca la casilla de verificación Asignar dirección IP externa. Si no se asigna una dirección IP externa, se evita que la instancia reciba comunicaciones no solicitadas de Internet o de otras redes de VPC.

      4. Selecciona la casilla de verificación Permitir el acceso mediante proxies.

  8. En la sección IAM y seguridad, proporciona lo siguiente y, luego, haz clic en Continuar:

    • IAM y seguridad: Para otorgar acceso a un solo usuario a la interfaz de JupyterLab de la instancia, completa los siguientes pasos:

      1. Selecciona una cuenta de servicio.
      2. Desmarca la casilla de verificación Usar la cuenta de servicio predeterminada de Compute Engine. Este paso es importante, ya que a la cuenta de servicio predeterminada de Compute Engine (y, por lo tanto, al usuario único que acabas de especificar) podría tener el rol de editor (roles/editor) en tu proyecto.

      3. En el campo Correo electrónico de la cuenta de servicio, ingresa lo siguiente y reemplaza PROJECT_ID por el ID del proyecto:

        workbench-sa@PROJECT_ID.iam.gserviceaccount.com

        (Esta es la dirección de correo electrónico de la cuenta de servicio personalizada que creaste antes). Esta cuenta de servicio tiene permisos limitados.

        Si quieres obtener más información para otorgar acceso, consulta Administra el acceso a una interfaz de JupyterLab de una instancia de Vertex AI Workbench.

    • Opciones de seguridad: Desmarca la siguiente casilla de verificación:

      • Acceso raíz a la instancia

      Selecciona la siguiente casilla de verificación:

      • nbconvert: nbconvert permite a los usuarios exportar y descargar un archivo de notebook como un tipo de archivo diferente, por ejemplo, HTML, PDF o LaTeX. Algunas de las notebooks del repositorio de GitHub de la Google Cloud IA generativa requieren esta configuración.

      Desmarca la siguiente casilla de verificación:

      • Descarga de archivos

      Selecciona la siguiente casilla de verificación, a menos que estés en un entorno de producción:

      • Acceso a la terminal: Esto habilita el acceso a la terminal a tu instancia desde la interfaz de usuario de JupyterLab.

  9. En la sección Estado del sistema, desactiva Actualización automática del entorno y proporciona lo siguiente:

    • En Informes, selecciona las siguientes casillas de verificación:

      • Genera informes sobre el estado del sistema
      • Generar informes sobre las métricas personalizadas en Cloud Monitoring
      • Instalar Cloud Monitoring
      • Informar el estado de DNS de los dominios de Google obligatorios

  10. Haz clic en Crear y espera unos minutos para que se cree la instancia de Vertex AI Workbench.

Ejecuta la aplicación de entrenamiento en la instancia de Vertex AI Workbench

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

    Ir a Vertex AI Workbench

  2. Junto al nombre de la instancia de Vertex AI Workbench (pipeline-tutorial-PROJECT_ID), donde PROJECT_ID es el ID del proyecto, haz clic en Abrir JupyterLab.

    Tu instancia de Vertex AI Workbench abre JupyterLab.

  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:

    projectid=PROJECT_ID

  5. Crea los directorios principales para la aplicación de entrenamiento (aún en la terminal de JupyterLab):

    mkdir fungi_training_package
mkdir fungi_training_package/trainer

  6. En el navegador de archivos , haz doble clic en la carpeta fungi_training_package y, luego, en la carpeta trainer.

  7. En el navegador de archivos , haz clic con el botón derecho en la lista de archivos vacía (debajo del encabezado Nombre) y selecciona Archivo nuevo.

  8. Haz clic con el botón derecho en el archivo nuevo y selecciona Cambiar nombre del archivo.

  9. Cambia el nombre del archivo de untitled.txt a task.py.

  10. Haz doble clic en el archivo task.py para abrirlo.

  11. Copia el siguiente código en task.py:

    # Import the libraries
import tensorflow as tf
from tensorflow.python.client import device_lib
import argparse
import os
import sys
# add parser arguments
parser = argparse.ArgumentParser()
parser.add_argument('--data-dir', dest='dataset_dir', type=str, 
                 help='Dir to access dataset.')
parser.add_argument('--model-dir', dest='model_dir', default=os.getenv("AIP_MODEL_DIR"), type=str,
                 help='Dir to save the model.')
parser.add_argument('--epochs', dest='epochs', default=10, type=int,
                 help='Number of epochs.')
parser.add_argument('--batch-size', dest='batch_size', default=32, type=int,
                 help='Number of images per batch.')
parser.add_argument('--distribute', dest='distribute', default='single', type=str, 
                 help='distributed training strategy.')
args = parser.parse_args()
# print the tf version and config
print('Python Version = {}'.format(sys.version))
print('TensorFlow Version = {}'.format(tf.__version__))
print('TF_CONFIG = {}'.format(os.environ.get('TF_CONFIG', 'Not found')))
print('DEVICES', device_lib.list_local_devices())

# Single Machine, single compute device
if args.distribute == 'single':
    if tf.test.is_gpu_available():
        strategy = tf.distribute.OneDeviceStrategy(device="/gpu:0")
    else:
        strategy = tf.distribute.OneDeviceStrategy(device="/cpu:0")
# Single Machine, multiple compute device
elif args.distribute == 'mirror':
    strategy = tf.distribute.MirroredStrategy()
# Multiple Machine, multiple compute device
elif args.distribute == 'multi':
    strategy = tf.distribute.experimental.MultiWorkerMirroredStrategy()

# Multi-worker configuration
print('num_replicas_in_sync = {}'.format(strategy.num_replicas_in_sync))

# Preparing dataset
BUFFER_SIZE = 1000
IMG_HEIGHT = 224
IMG_WIDTH = 224

def make_datasets_batched(dataset_path, global_batch_size):
    # Configure the training data generator
    train_data_dir = os.path.join(dataset_path,"train/")
    train_ds = tf.keras.utils.image_dataset_from_directory(
                         train_data_dir,
                         seed=36,
                         image_size=(IMG_HEIGHT, IMG_WIDTH),
                         batch_size=global_batch_size
               )
    # Configure the validation data generator
    val_data_dir = os.path.join(dataset_path,"valid/")
    val_ds = tf.keras.utils.image_dataset_from_directory(
                       val_data_dir,
                       seed=36,
                       image_size=(IMG_HEIGHT, IMG_WIDTH),
                       batch_size=global_batch_size
             )
    # get the number of classes in the data
    num_classes = len(train_ds.class_names)

    # Configure the dataset for performance
    AUTOTUNE = tf.data.AUTOTUNE
    train_ds = train_ds.cache().shuffle(BUFFER_SIZE).prefetch(buffer_size=AUTOTUNE)
    val_ds = val_ds.cache().prefetch(buffer_size=AUTOTUNE)
    return train_ds, val_ds, num_classes

# Build the Keras model
def build_and_compile_cnn_model(num_classes):
    # build a CNN model
    model = tf.keras.models.Sequential([
      tf.keras.layers.Rescaling(1./255, input_shape=(IMG_HEIGHT, IMG_WIDTH, 3)),
      tf.keras.layers.Conv2D(16, 3, padding='same', activation='relu'),
      tf.keras.layers.MaxPooling2D(),
      tf.keras.layers.Conv2D(32, 3, padding='same', activation='relu'),
      tf.keras.layers.MaxPooling2D(),
      tf.keras.layers.Conv2D(64, 3, padding='same', activation='relu'),
      tf.keras.layers.MaxPooling2D(),
      tf.keras.layers.Flatten(),
      tf.keras.layers.Dense(128, activation='relu'),
      tf.keras.layers.Dense(num_classes)
    ])
    # compile the CNN model
    model.compile(optimizer='adam',
               loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
               metrics=['accuracy'])
    return model

# Get the strategy data
NUM_WORKERS = strategy.num_replicas_in_sync
# Here the batch size scales up by number of workers
GLOBAL_BATCH_SIZE = args.batch_size * NUM_WORKERS

# Create dataset generator objects
train_ds, val_ds, num_classes = make_datasets_batched(args.dataset_dir, GLOBAL_BATCH_SIZE)
# Compile the model
with strategy.scope():
    # Creation of dataset, and model building/compiling need to be within
    # `strategy.scope()`.
    model = build_and_compile_cnn_model(num_classes)
# fit the model on the data
history = model.fit(train_ds, validation_data=val_ds, epochs=args.epochs)
# save the model to the output dir
model.save(args.model_dir)

  12. Selecciona Archivo > Guardar archivo de Python.

  13. En la terminal de JupyterLab, crea un archivo __init__.py en cada subdirectorio para convertirlo en un paquete:

    touch fungi_training_package/__init__.py
touch fungi_training_package/trainer/__init__.py

  14. En el navegador de archivos , haz doble clic en la nueva carpeta fungi_training_package.

  15. Selecciona File > New > Python file.

  16. Haz clic con el botón derecho en el archivo nuevo y selecciona Cambiar nombre del archivo.

  17. Cambia el nombre del archivo de untitled.py a setup.py.

  18. Haz doble clic en el archivo setup.py para abrirlo.

  19. Copia el siguiente código en 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 fungi-classification.'
)

  20. Selecciona Archivo > Guardar archivo de Python.

  21. En la terminal, navega al directorio fungi_training_package:

    cd fungi_training_package

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

    python setup.py sdist --formats=gztar

  23. Navega al directorio principal:

    cd ..

  24. Verifica que estás en el directorio correcto:

    pwd

    La salida obtenida se verá así:

    /home/jupyter

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

    gcloud storage cp fungi_training_package/dist/trainer-0.1.tar.gz gs://pipelines-staging-bucket-$projectid/training_package/

  26. Verifica que el bucket de etapa de pruebas contenga el paquete:

    gcloud storage ls gs://pipelines-staging-bucket-$projectid/training_package

    El resultado es el siguiente:

    gs://pipelines-staging-bucket-PROJECT_ID/training_package/trainer-0.1.tar.gz

Crea la conexión de Service Networking para Vertex AI Pipelines

En esta sección, crearás una conexión de Service Networking que se usa para establecer servicios de productor conectados a la red de VPC vertex-networking-vpc a través del intercambio de tráfico entre redes de VPC. Para obtener más información, consulta Intercambio de tráfico entre redes de VPC.

  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. Configura un rango de direcciones IP reservado con gcloud compute addresses create:

    gcloud compute addresses create vertex-pipeline-subnet \
    --global \
    --purpose=VPC_PEERING \
    --addresses=192.168.10.0 \
    --prefix-length=24 \
    --description="pipeline subnet" \
    --network=vertex-networking-vpc

  3. Establece una conexión de intercambio de tráfico entre la red de VPC vertex-networking-vpc y las Herramientas de redes de servicios de Google con gcloud services vpc-peerings connect:

    gcloud services vpc-peerings connect \
    --service=servicenetworking.googleapis.com \
    --ranges=vertex-pipeline-subnet \
    --network=vertex-networking-vpc

  4. Actualiza la conexión de intercambio de tráfico de VPC para habilitar la importación y exportación de rutas personalizadas aprendidas:

    gcloud compute networks peerings update servicenetworking-googleapis-com \
    --network=vertex-networking-vpc \
    --import-custom-routes \
    --export-custom-routes

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

    Ir a Cloud Routers

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

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

  4. Haz clic en Agregar una ruta personalizada.

  5. En Fuente, selecciona Rango de IP personalizado.

  6. En Rango de direcciones IP, ingresa el siguiente rango de direcciones IP:

    192.168.10.0/24

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

    Vertex AI Pipelines reserved subnet

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

Crea una plantilla de canalización y súbela a Artifact Registry

En esta sección, crearás y subirás una plantilla de canalización de Kubeflow Pipelines (KFP). Esta plantilla contiene una definición de flujo de trabajo que un solo usuario o varios pueden volver a usar múltiples veces.

Define y compila la canalización

  1. En JupyterLab, en el  Navegador de archivos, haz doble clic en la carpeta de nivel superior.

  2. Select Archivo > Nuevo > Notebook.

  3. En el menú Seleccionar kernel, elige Python 3 (ipykernel) y haz clic en Seleccionar.

  4. En una celda de notebook nueva, ejecuta el siguiente comando para asegurarte de tener la versión más reciente de pip:

    !python -m pip install --upgrade pip

  5. Ejecuta el siguiente comando para instalar el SDK de componentes de canalización de Google Cloud desde el índice de paquetes de Python (PyPI):

    !pip install --upgrade google-cloud-pipeline-components

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

  7. Ejecuta el siguiente código en una celda nueva del notebook para definir la canalización:

    from kfp import dsl
# define the train-deploy pipeline
@dsl.pipeline(name="custom-image-classification-pipeline")
def custom_image_classification_pipeline(
 project: str,
 training_job_display_name: str,
 worker_pool_specs: list,
 base_output_dir: str,
 model_artifact_uri: str,
 prediction_container_uri: str,
 model_display_name: str,
 endpoint_display_name: str,
 network: str = '',
 location: str="us-central1",
 serving_machine_type: str="n1-standard-4",
 serving_min_replica_count: int=1,
 serving_max_replica_count: int=1
 ):
 from google_cloud_pipeline_components.types import artifact_types
 from google_cloud_pipeline_components.v1.custom_job import CustomTrainingJobOp
 from google_cloud_pipeline_components.v1.model import ModelUploadOp
 from google_cloud_pipeline_components.v1.endpoint import (EndpointCreateOp,
                                                           ModelDeployOp)
 from kfp.dsl import importer

 # Train the model task
 custom_job_task = CustomTrainingJobOp(
      project=project,
      display_name=training_job_display_name,
      worker_pool_specs=worker_pool_specs,
      base_output_directory=base_output_dir,
      location=location,
      network=network
      )

 # Import the model task
 import_unmanaged_model_task = importer(
      artifact_uri=model_artifact_uri,
      artifact_class=artifact_types.UnmanagedContainerModel,
      metadata={
         "containerSpec": {
            "imageUri": prediction_container_uri,
            },
         },
         ).after(custom_job_task)
 # Model upload task
 model_upload_op = ModelUploadOp(
      project=project,
      display_name=model_display_name,
      unmanaged_container_model=import_unmanaged_model_task.outputs["artifact"],
      )
 model_upload_op.after(import_unmanaged_model_task)
 # Create Endpoint task
 endpoint_create_op = EndpointCreateOp(
      project=project,
      display_name=endpoint_display_name,
      )
 # Deploy the model to the endpoint
 ModelDeployOp(
      endpoint=endpoint_create_op.outputs["endpoint"],
      model=model_upload_op.outputs["model"],
      dedicated_resources_machine_type=serving_machine_type,
      dedicated_resources_min_replica_count=serving_min_replica_count,
      dedicated_resources_max_replica_count=serving_max_replica_count,
      )

  8. Ejecuta el siguiente código en una celda de notebook nueva para compilar la definición de la canalización:

    from kfp import compiler 
PIPELINE_FILE = "pipeline_config.yaml"
compiler.Compiler().compile(
    pipeline_func=custom_image_classification_pipeline,
    package_path=PIPELINE_FILE,
)

    En el navegador de archivos , aparece un archivo llamado pipeline_config.yaml en la lista de archivos.

Crea un repositorio de Artifact Registry

  1. Ejecuta el siguiente código en una celda de notebook nueva para crear un repositorio de artefactos de tipo KFP:

    REPO_NAME="fungi-repo"
REGION="us-central1"
!gcloud artifacts repositories create $REPO_NAME --location=$REGION --repository-format=KFP

Sube la plantilla de canalización a Artifact Registry

En esta sección, configurarás un cliente de registro del SDK de Kubeflow Pipelines y subirás la plantilla de canalización compilada a Artifact Registry desde tu notebook de JupyterLab.

  1. En tu notebook de JupyterLab, ejecuta el siguiente código para subir la plantilla de la canalización y reemplaza PROJECT_ID por el ID de tu proyecto:

    PROJECT_ID = "PROJECT_ID"
from kfp.registry import RegistryClient
host = f"https://{REGION}-kfp.pkg.dev/{PROJECT_ID}/{REPO_NAME}"
client = RegistryClient(host=host)
TEMPLATE_NAME, VERSION_NAME = client.upload_pipeline(
   file_name=PIPELINE_FILE,
   tags=["v1", "latest"],
   extra_headers={"description":"This is an example pipeline template."})

  2. En la consola de Google Cloud , para verificar que se subió tu plantilla, ve a Plantillas de Vertex AI Pipelines.

    Ir a Canalizaciones

  3. Para abrir el panel Seleccionar repositorio, haz clic en Seleccionar repositorio.

  4. En la lista de repositorios, haz clic en el repositorio que creaste (fungi-repo) y, luego, en Seleccionar.

  5. Verifica que tu canalización (custom-image-classification-pipeline) aparezca en la lista.

Activa una ejecución de canalización de forma local

En esta sección, ahora que la plantilla de la canalización y el paquete de entrenamiento están listos, usarás cURL para activar una ejecución de la canalización desde tu aplicación local.

Proporciona los parámetros de la canalización

  1. En tu notebook de JupyterLab, ejecuta el siguiente comando para verificar el nombre de la plantilla de canalización:

    print (TEMPLATE_NAME)

    El nombre de la plantilla que se devolvió es el siguiente:

    custom-image-classification-pipeline

  2. Ejecuta el siguiente comando para obtener la versión de la plantilla de canalización:

    print (VERSION_NAME)

    El nombre de la versión de la plantilla de canalización devuelta se ve de la siguiente manera:

    sha256:41eea21e0d890460b6e6333c8070d7d23d314afd9c7314c165efd41cddff86c7

    Toma nota de toda la cadena del nombre de la versión.

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

    projectid=PROJECT_ID
gcloud config set project ${projectid}

  4. Accede a la instancia de VM on-prem-dataservice-host:

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

  5. En la instancia de VM on-prem-dataservice-host, usa un editor de texto, como vim o nano para crear el archivo request_body.json, por ejemplo:

    sudo vim request_body.json

  6. Agrega el siguiente texto al archivo request_body.json.

    {
"displayName": "fungi-image-pipeline-job",
"serviceAccount": "onprem-user-managed-sa@PROJECT_ID.iam.gserviceaccount.com",
"runtimeConfig":{
"gcsOutputDirectory":"gs://pipelines-staging-bucket-PROJECT_ID/pipeline_root/",
"parameterValues": {
   "project": "PROJECT_ID",
   "training_job_display_name": "fungi-image-training-job",
   "worker_pool_specs": [{
      "machine_spec": {
         "machine_type": "n1-standard-4"
      },
      "replica_count": 1,
      "python_package_spec":{
         "executor_image_uri":"us-docker.pkg.dev/vertex-ai/training/tf-cpu.2-8.py310:latest", 
         "package_uris": ["gs://pipelines-staging-bucket-PROJECT_ID/training_package/trainer-0.1.tar.gz"],
         "python_module": "trainer.task",
         "args": ["--data-dir","/mnt/nfs/fungi_dataset/", "--epochs", "10"],
         "env": [{"name": "AIP_MODEL_DIR", "value": "gs://pipelines-staging-bucket-PROJECT_ID/model/"}]
      },
      "nfs_mounts": [{
         "server": "FILESTORE_INSTANCE_IP",
         "path": "/vol1",
         "mount_point": "/mnt/nfs/"
      }]
   }],
   "base_output_dir":"gs://pipelines-staging-bucket-PROJECT_ID",
   "model_artifact_uri":"gs://pipelines-staging-bucket-PROJECT_ID/model/",
   "prediction_container_uri":"us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.2-8:latest",
   "model_display_name":"fungi-image-model",
   "endpoint_display_name":"fungi-image-endpoint",
   "location": "us-central1",
   "serving_machine_type":"n1-standard-4",
   "network":"projects/PROJECT_NUMBER/global/networks/vertex-networking-vpc"
     }
},
"templateUri": "https://us-central1-kfp.pkg.dev/PROJECT_ID/fungi-repo/custom-image-classification-pipeline/latest",
"templateMetadata": {
   "version":"VERSION_NAME"
}
}

    Reemplaza los siguientes valores:

    • PROJECT_ID: El ID de tu proyecto
    • PROJECT_NUMBER: Número del proyecto Es diferente del ID del proyecto. Puedes encontrar el número de proyecto en la página Configuración del proyecto del proyecto en laGoogle Cloud consola.
    • FILESTORE_INSTANCE_IP: Es la dirección IP de la instancia de Filestore, por ejemplo, 10.243.208.2. Puedes encontrarlo en la página Instancias de Filestore de tu instancia.
    • VERSION_NAME: El nombre de la versión de la plantilla de canalización (sha256:...) que anotaste en el paso 2.

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

Crea una ejecución de canalización a partir de tu plantilla

  1. En la instancia de VM on-prem-dataservice-host, ejecuta el siguiente comando y reemplaza PROJECT_ID por el ID del proyecto:

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

    El resultado que verás es extenso, pero lo principal que debes buscar es la siguiente línea, que indica que el servicio se está preparando para ejecutar la canalización:

    "state": "PIPELINE_STATE_PENDING"

    La ejecución de toda la canalización tarda entre 45 y 50 minutos.

  2. En la consola de Google Cloud , en la sección Vertex AI, ve a la pestaña Ejecuciones en la página Canalizaciones.

    Ir a Runs

  3. Haz clic en el nombre de la ejecución de tu canalización (custom-image-classification-pipeline).

    Aparecerá la página de ejecución de la canalización y el gráfico del entorno de ejecución de la canalización. El resumen de la canalización aparece en el panel Pipeline run analysis.

    Para obtener ayuda y comprender la información que se muestra en el gráfico de tiempo de ejecución, incluido cómo ver los registros y usar Vertex ML Metadata para obtener más información sobre los artefactos de tu canalización, consulta Visualiza y analiza los resultados de la canalización.