Usar Private Service Connect para acceder a las canalizaciones de entrenamiento desde un entorno local

Vertex AI Pipelines es un servicio gestionado que te ayuda a crear, desplegar y gestionar flujos de trabajo de aprendizaje automático (ML) integrales en la plataforma Google Cloud. Proporciona un entorno sin servidor para ejecutar tus canalizaciones, por lo que no tienes que preocuparte de gestionar la infraestructura.

En este tutorial, usarás Vertex AI Pipelines para ejecutar un trabajo de entrenamiento personalizado y desplegar 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 tutorial está dirigido a administradores de redes empresariales, científicos de datos e investigadores que estén familiarizados con Vertex AI, la nube privada virtual (VPC), la consola de Google Cloud y Cloud Shell. Familiarizarse 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.

Objetivos

  • Crea dos redes de nube privada virtual (VPC):
    • Una (vertex-networking-vpc) es para usar la API Vertex AI Pipelines para crear y alojar una plantilla de flujo de procesamiento para entrenar un modelo de aprendizaje automático y desplegarlo en un endpoint.
    • El otro (onprem-dataservice-vpc) representa una red local.
  • Conecta las dos redes de VPC de la siguiente manera:
    • Implementa pasarelas de VPN de alta disponibilidad, túneles de Cloud VPN y Cloud Routers para conectar vertex-networking-vpc y onprem-dataservice-vpc.
    • Crea un endpoint de Private Service Connect (PSC) para reenviar solicitudes privadas a la API REST de Vertex AI Pipelines.
    • Configura un anuncio de ruta personalizada de Cloud Router en vertex-networking-vpc para anunciar rutas del punto final de Private Service Connect a onprem-dataservice-vpc.
  • Crea una instancia de Filestore en la red onprem-dataservice-vpc de VPC y añádele datos de entrenamiento en un recurso compartido NFS.
  • Crea una aplicación de paquete de Python para la tarea de entrenamiento.
  • Crea una plantilla de tarea de Vertex AI Pipelines para hacer lo siguiente:
    • Crea y ejecuta el trabajo de entrenamiento con los datos del recurso compartido de NFS.
    • Importa el modelo entrenado y súbelo a Vertex AI Model Registry.
    • Crea un endpoint de Vertex AI para las predicciones online.
    • Despliega el modelo en el endpoint.
  • Sube la plantilla de la canalización a un repositorio de Artifact Registry.
  • Usa la API REST de Vertex AI Pipelines para activar una ejecución de un flujo de trabajo desde un host de servicio de datos local (on-prem-dataservice-host).

Costes

En este documento, se utilizan los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costes basada en el uso previsto, utiliza la calculadora de precios.

Los usuarios nuevos Google Cloud pueden disfrutar de una prueba gratuita.

Cuando termines las tareas que se describen en este documento, puedes evitar que se te siga facturando eliminando los recursos que has creado. Para obtener más información, consulta la sección Limpiar.

Antes de empezar

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

    Go to project selector

  2. Select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

  3. Verify that billing is enabled for your Google Cloud project.

  4. Abre Cloud Shell para ejecutar los comandos que se indican en este tutorial. Cloud Shell es un entorno de shell interactivo para Google Cloud que te permite gestionar tus proyectos y recursos desde el navegador web.
  5. En Cloud Shell, define el proyecto actual como tu Google Cloud ID de proyecto y almacena el mismo ID de proyecto en la variable de shell projectid: 
      projectid="PROJECT_ID"
  gcloud config set project ${projectid}
     Sustituye PROJECT_ID por el ID de tu proyecto. Si es necesario, puedes encontrar el ID de tu proyecto en la Google Cloud consola. Para obtener más información, consulta Buscar el ID de un proyecto.
  6. Si no eres el propietario del proyecto, pídele que te conceda el rol Administrador de gestión de identidades y accesos de proyectos (roles/resourcemanager.projectIamAdmin). Debes tener este rol para conceder roles de gestión de identidades y accesos en el siguiente paso.

  7. Make sure that you have the following role or roles on the project: roles/artifactregistry.admin, roles/artifactregistry.repoAdmin, roles/compute.instanceAdmin.v1, roles/compute.networkAdmin, roles/compute.securityAdmin, roles/dns.admin, roles/file.editor, roles/logging.viewer, roles/logging.admin, roles/notebooks.admin, roles/iam.serviceAccountAdmin, roles/iam.serviceAccountUser, roles/servicedirectory.editor, roles/servicemanagement.quotaAdmin, roles/serviceusage.serviceUsageAdmin, roles/storage.admin, roles/storage.objectAdmin, roles/aiplatform.admin, roles/aiplatform.user, roles/aiplatform.viewer, roles/iap.admin, roles/iap.tunnelResourceAccessor, roles/resourcemanager.projectIamAdmin

    Check for the roles

    1. In the Google Cloud console, go to the IAM page.

      Go to IAM
    2. Select the project.

    3. In the Principal column, find all rows that identify you or a group that you're included in. To learn which groups you're included in, contact your administrator.

    4. For all rows that specify or include you, check the Role column to see whether the list of roles includes the required roles.

    Grant the roles

    1. In the Google Cloud console, go to the IAM page.

      Ir a IAM
    2. Selecciona el proyecto.
    3. Haz clic en Conceder acceso.

    4. En el campo Nuevos principales, introduce tu identificador de usuario. Normalmente, se trata de la dirección de correo de una cuenta de Google.

    5. En la lista Selecciona un rol, elige un rol.
    6. Para conceder más roles, haz clic en Añadir otro rol y añade cada rol adicional.
    7. Haz clic en Guardar.

  8. Enable the DNS, Artifact Registry, IAM, Compute Engine, Cloud Logging, Network Connectivity, Notebooks, Cloud Filestore, Service Networking, Service Usage, and Vertex AI APIs.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the APIs

Crear las redes de VPC

En esta sección, crearás dos redes VPC: una para acceder a las APIs de Google para Vertex AI Pipelines y otra para simular una red local. En cada una de las dos redes de VPC, crea un router de Cloud Router y una pasarela de Cloud NAT. Una pasarela Cloud NAT proporciona conectividad saliente a las instancias de máquina virtual (VM) de Compute Engine sin direcciones IP externas.

  1. En Cloud Shell, ejecuta los siguientes comandos y sustituye PROJECT_ID por el ID de tu proyecto:

    projectid=PROJECT_ID
gcloud config set project ${projectid}

  2. Crea la vertex-networking-vpcred de 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 intervalo 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 intervalo 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

Verificar que las redes VPC estén configuradas correctamente

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

    Ir a redes de VPC

  2. En la lista de redes de VPC, comprueba 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, comprueba que se hayan creado las subredes pipeline-networking-subnet1 y onprem-dataservice-vpc-subnet1.

Configurar la conectividad híbrida

En esta sección, creará dos pasarelas de VPN de alta disponibilidad que estarán conectadas entre sí. Una de ellas se encuentra en la red de vertex-networking-vpcVPC. La otra se encuentra en la red de VPC onprem-dataservice-vpc. Cada pasarela contiene un Cloud Router y un par de túneles VPN.

Crear las pasarelas de VPN de alta disponibilidad

  1. En Cloud Shell, crea la pasarela de VPN de 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 pasarela de VPN de alta disponibilidad para la red VPC onprem-dataservice-vpc:

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

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

    Ir a VPN

  4. Verifica que se hayan creado las dos pasarelas (vertex-networking-vpn-gw1 y onprem-vpn-gw1) y que cada una tenga dos direcciones IP de interfaz.

Crear routers de Cloud Router y pasarelas de Cloud NAT

En cada una de las dos redes de VPC, crea dos routers de Cloud Router: uno para usar con Cloud NAT y otro para gestionar las sesiones de BGP de la VPN de alta disponibilidad.

  1. En Cloud Shell, crea un Cloud Router para la red de VPC vertex-networking-vpc que se usará en 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á en 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-vpcque se usará en Cloud NAT:

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

  4. Configura una pasarela de Cloud NAT en 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 onprem-dataservice-vpc VPC que se usará en Cloud NAT:

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

  6. Configura una pasarela de Cloud NAT en 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 Google Cloud consola, ve a la página Cloud Routers.

    Ir a Cloud Routers

  8. En la lista Cloud Routers (Routers de Cloud), comprueba 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

    Puede que tengas que actualizar la pestaña del navegador de la consola para ver los nuevos valores. Google Cloud

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

  10. En la página Detalles del router, comprueba que se ha creado la pasarela cloud-nat-us-central1 Cloud NAT.

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

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

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

Crear túneles de 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 Google Cloud consola, ve a la página VPN.

    Ir a VPN

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

Establecer sesiones de BGP

Cloud Router usa el protocolo de pasarela fronteriza (BGP) para intercambiar rutas entre tu red de VPC (en este caso, vertex-networking-vpc) y tu red on‐premise (representada por onprem-dataservice-vpc). En Cloud Router, configura una interfaz y un par BGP para tu router on‐premise. La interfaz y la configuración del par de BGP 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.

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

Establecer sesiones de BGP para vertex-networking-vpc

  1. En Cloud Shell, en la red vertex-networking-vpc, crea una interfaz 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 peer 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 peer 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

Establecer 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 peer 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 peer 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

Validar la creación de la sesión de BGP

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

    Ir a VPN

  2. En la lista de túneles VPN, comprueba que el valor de la columna Estado de la sesión de BGP de cada túnel haya cambiado de Configurar sesión de BGP a BGP establecido. Puede que tengas que actualizar la pestaña del navegador de la consola para ver los nuevos valores. Google Cloud

Validar las onprem-dataservice-vpc rutas aprendidas

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

    Ir a 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 Intervalo de IP de destino, comprueba que el intervalo de IP de subred pipeline-networking-subnet1 (10.0.0.0/24) aparece dos veces.

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

Validar las vertex-networking-vpc rutas aprendidas

  1. Haz clic en la flecha hacia atrás para volver 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 Intervalo de IP de destino, comprueba que el intervalo de IP de la subred (172.16.10.0/24) aparece dos veces.onprem-dataservice-vpc-subnet1

Crear un punto final de Private Service Connect para las APIs de Google

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

  1. En Cloud Shell, reserva una dirección IP de endpoint de 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 punto final a las APIs y los servicios de Google.

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

Crear anuncios de ruta personalizados para vertex-networking-vpc

En esta sección, creará un anuncio de ruta personalizada para vertex-networking-vpc-router1 (el Cloud Router de vertex-networking-vpc) para anunciar la dirección IP del endpoint de PSC a la red de VPC onprem-dataservice-vpc.

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

    Ir a Cloud Routers

  2. En la lista de Cloud Routers, haga clic en vertex-networking-vpc-router1.

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

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

  5. Marca la casilla Anunciar todas las subredes que pueda ver el router de Cloud Router para seguir anunciando las subredes disponibles para el router de Cloud Router. Si habilita esta opción, se imitará el comportamiento de Cloud Router en el modo de anuncio predeterminado.

  6. Haz clic en Añadir una ruta personalizada.

  7. En Origen, selecciona Intervalo de IP personalizado.

  8. En Intervalo de direcciones IP, introduce la siguiente dirección IP:

    192.168.0.1

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

    Custom route to advertise Private Service Connect endpoint IP address

  10. Haz clic en Hecho y, a continuación, en Guardar.

Validar que onprem-dataservice-vpc ha aprendido las rutas anunciadas

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

    Ir a Rutas

  2. En la pestaña Rutas eficaces, 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, comprueba que haya dos entradas cuyos nombres empiecen por onprem-dataservice-vpc-router1-bgp-vertex-networking-vpc-tunnel0 y dos que empiecen por onprem-dataservice-vpc-router1-bgp-vertex-networking-vpc-tunnel1.

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

    5. Comprueba que dos de las entradas tengan un intervalo de IP de destino de 192.168.0.1/32 y que otras dos tengan un intervalo 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 las prácticas recomendadas de Compute Engine e IAM, esta VM usa una cuenta de servicio gestionada por el usuario en lugar de la cuenta de servicio predeterminada de Compute Engine.

Crear la cuenta de servicio gestionada por el usuario para la instancia de VM

  1. En Cloud Shell, ejecuta los siguientes comandos y sustituye PROJECT_ID por el ID de tu 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 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 Lector 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 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 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 Storage (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 Administrador de almacenamiento de registros (roles/logging.admin):

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

Crear la instancia de VM de 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 administrativo a la VM, utiliza 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 cortafuegos 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 endpoint de PSC

En esta sección, se añade una línea al archivo /etc/hosts que hace que las solicitudes enviadas al endpoint del servicio público (us-central1-aiplatform.googleapis.com) se redirijan al endpoint de PSC (192.168.0.1).

  1. En Cloud Shell, inicia sesión en 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. Añade la siguiente línea al archivo:

    192.168.0.1 us-central1-aiplatform.googleapis.com

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

    El archivo editado debería tener este aspecto:

    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, pulsa la tecla Esc y, a continuación, escribe :wq para guardar el archivo y salir.
    • Si usas nano, escribe Control+O y pulsa Enter para guardar el archivo. A continuación, escribe Control+X para salir.

  5. Hacer ping al endpoint de la 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 endpoint 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 prompt de Cloud Shell.

Configurar la red de una instancia de Filestore

En esta sección, habilitarás el acceso a servicios privados en tu red de VPC para preparar la creación de una instancia de Filestore y montarla como un recurso compartido de Network File System (NFS). Para saber qué vas a hacer en esta sección y en la siguiente, consulta Montar un recurso compartido NFS para el entrenamiento personalizado y Configurar el emparejamiento entre redes de VPC.

Habilitar el acceso privado a servicios en una red de VPC

En esta sección, creará una conexión de Service Networking y la usará para habilitar el acceso a servicios privados a la red de VPC onprem-dataservice-vpc mediante el emparejamiento de redes de VPC.

  1. En Cloud Shell, define un intervalo de direcciones IP reservado 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 emparejamiento entre la red de VPC onprem-dataservice-vpc y Service Networking de Google mediante gcloud services vpc-peerings connect:

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

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

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

  4. En la Google Cloud consola, ve a la página Peering de redes de VPC.

    Ir al emparejamiento entre redes VPC

  5. En la lista de emparejamientos de VPC, comprueba que haya una entrada para el emparejamiento entre servicenetworking.googleapis.com y la red de VPC onprem-dataservice-vpc.

Crear anuncios de ruta personalizados para filestore-subnet

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

    Ir a Cloud Routers

  2. En la lista de Cloud Routers, haga clic en onprem-dataservice-vpc-router1.

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

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

  5. Marca la casilla Anunciar todas las subredes que pueda ver el router de Cloud Router para seguir anunciando las subredes disponibles para el router de Cloud Router. Si habilita esta opción, se imitará el comportamiento de Cloud Router en el modo de anuncio predeterminado.

  6. Haz clic en Añadir una ruta personalizada.

  7. En Origen, selecciona Intervalo de IP personalizado.

  8. En Intervalo de direcciones IP, introduzca el siguiente intervalo de direcciones IP:

    10.243.208.0/24

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

    Filestore reserved IP address range

  10. Haz clic en Hecho y, a continuación, en Guardar.

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

Después de habilitar el acceso a servicios privados en tu red de VPC, crea una instancia de Filestore y monta la instancia como un recurso compartido NFS para tu trabajo de entrenamiento personalizado. De esta forma, tus trabajos de entrenamiento pueden acceder a archivos remotos como si fueran locales, lo que permite obtener un alto rendimiento y una latencia baja.

Crear la instancia de Filestore

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

    Ir a instancias de Filestore

  2. Haga clic en Crear instancia y configure la instancia de la siguiente manera:

    • Asigna el siguiente valor a ID de instancia:

      image-data-instance

    • En Tipo de instancia, seleccione Básico.

    • En Tipo de almacenamiento, selecciona HDD.

    • Asigna el valor 1 TiB a Asignar capacidad.

    • Asigna a Región el valor us-central1 y a Zona el valor us-central1-c.

    • Defina Red de VPC como onprem-dataservice-vpc.

    • En Intervalo de IPs asignado, selecciona Usar un intervalo de IPs asignado y elige filestore-subnet.

    • Asigna el siguiente valor a Nombre del sistema de archivos compartidos:

      vol1

    • En Controles de acceso, selecciona Conceder acceso a todos los clientes de la red VPC.

  3. Haz clic en Crear.

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

Montar el sistema de archivos compartido de Filestore

  1. En Cloud Shell, ejecuta los siguientes comandos y sustituye PROJECT_ID por el ID de tu proyecto:

    projectid=PROJECT_ID
gcloud config set project ${projectid}

  2. Inicia sesión en la on-prem-dataservice-host instancia de VM:

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

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

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

  4. Crea un directorio de montaje para el recurso compartido de archivos de Filestore:

    sudo mkdir -p /mnt/nfs
    trabajo de entrenamiento personalizado.

  5. Activa el sistema de archivos compartidos. Para ello, sustituye FILESTORE_INSTANCE_IP por la dirección IP de tu instancia de Filestore:

    sudo mount FILESTORE_INSTANCE_IP:/vol1 /mnt/nfs

    Si la conexión se agota, compruebe que está proporcionando la dirección IP correcta de la instancia de Filestore.

  6. Valida que el montaje de NFS se haya realizado correctamente ejecutando el siguiente comando:

    df -h

    Comprueba que el recurso compartido de archivos /mnt/nfs aparezca 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 que se pueda acceder al recurso compartido de archivos:

    sudo chmod go+rw /mnt/nfs
    .

Descargar el conjunto de datos en el recurso compartido de archivos

  1. En la instancia de VM on-prem-dataservice-host, descarga el conjunto de datos en el archivo compartido:

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

    La descarga tarda varios minutos.

  2. Para confirmar que el conjunto de datos se ha copiado correctamente, ejecuta el siguiente comando:

    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 prompt de Cloud Shell.

Crea un segmento de almacenamiento provisional para tu flujo de procesamiento

Vertex AI Pipelines almacena los artefactos de las ejecuciones de tu flujo de procesamiento mediante Cloud Storage. Antes de ejecutar la canalización, debes crear un segmento de Cloud Storage para las ejecuciones de la canalización de staging.

En Cloud Shell, crea un segmento de Cloud Storage:

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

Crear una cuenta de servicio gestionada 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 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"

Crear 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 de Python.

Crear una instancia de Vertex AI Workbench

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

    Ir a Vertex AI Workbench

  2. Haz clic en  Crear y, a continuación, en Opciones avanzadas.

    Se abrirá la página Nueva instancia.

  3. En la página Nueva instancia, en la sección Detalles, proporciona la siguiente información sobre la nueva instancia y, a continuación, haz clic en Continuar:

    • Nombre: introduce lo siguiente y sustituye PROJECT_ID por el ID del proyecto:

      pipeline-tutorial-PROJECT_ID

    • Región: seleccione us-central1.

    • Zona: selecciona us-central1-a.

    • Desmarca la casilla Habilitar sesiones interactivas de Dataproc Serverless.

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

  5. En la sección Tipo de máquina, proporcione la siguiente información y, a continuación, haga clic en Continuar:

    • Tipo de máquina: elige N1 y, a continuación, selecciona n1-standard-4 en el menú Tipo de máquina.

    • Máquina virtual blindada: marca las siguientes casillas:

      • Arranque seguro
      • Módulo de plataforma segura virtual (vTPM)
      • Monitorización de integridad

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

  7. En la sección Redes, proporcione la siguiente información y, a continuación, haga clic en Continuar:

    • Redes: selecciona Red en este proyecto y sigue estos pasos:

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

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

      3. Desmarca la casilla Asignar dirección IP externa. Si no asignas una dirección IP externa, la instancia no podrá recibir comunicaciones no solicitadas de Internet ni de otras redes VPC.

      4. Selecciona la casilla Permitir acceso proxy.

  8. En la sección IAM y seguridad, proporcione lo siguiente y, a continuación, haga clic en Continuar:

    • IAM y seguridad: para conceder acceso a un solo usuario a la interfaz de JupyterLab de la instancia, sigue estos pasos:

      1. Selecciona Service account (Cuenta de servicio).
      2. Desmarca la casilla Usar la cuenta de servicio predeterminada de Compute Engine. Este paso es importante porque la cuenta de servicio predeterminada de Compute Engine (y, por lo tanto, el usuario único que acabas de especificar) podría tener el rol Editor (roles/editor) en tu proyecto.

      3. En el campo Correo de la cuenta de servicio, introduce lo siguiente y sustituye PROJECT_ID por el ID del proyecto:

        workbench-sa@PROJECT_ID.iam.gserviceaccount.com

        (Esta es la dirección de correo de la cuenta de servicio personalizada que has creado antes). Esta cuenta de servicio tiene permisos limitados.

        Para obtener más información sobre cómo conceder acceso, consulta Gestionar el acceso a la interfaz de JupyterLab de una instancia de Vertex AI Workbench.

    • Opciones de seguridad: desmarca la siguiente casilla:

      • Acceso de superusuario a la instancia

      Marca la siguiente casilla:

      • nbconvert: nbconvert permite a los usuarios exportar y descargar un archivo de cuaderno como otro tipo de archivo, como HTML, PDF o LaTeX. Algunos de los cuadernos del repositorio de GitHub Google Cloud Generative AI requieren este ajuste.

      Desmarca la siguiente casilla:

      • Descarga de archivos

      Marca la siguiente casilla, a menos que te encuentres en un entorno de producción:

      • Acceso al terminal: permite acceder al terminal de tu instancia desde la interfaz de usuario de JupyterLab.

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

    • En Informes, marque las siguientes casillas:

      • Informar del estado del sistema
      • Enviar métricas personalizadas a Cloud Monitoring
      • Instalar Cloud Monitoring
      • Informar del estado del DNS de los dominios de Google obligatorios

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

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

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

    Ir a Vertex AI Workbench

  2. Junto al nombre de tu 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 se abre en JupyterLab.

  3. Selecciona Archivo > Nuevo > Terminal.

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

    projectid=PROJECT_ID

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

    mkdir fungi_training_package
mkdir fungi_training_package/trainer

  6. En el  Explorador de archivos, haz doble clic en la carpeta fungi_training_package y, a continuación, en la carpeta trainer.

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

  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. Copie 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  Explorador de archivos, haz doble clic en la carpeta fungi_training_package.

  15. Selecciona Archivo > Nuevo > Archivo de Python.

  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. Copie 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 el terminal, ve al directorio fungi_training_package:

    cd fungi_training_package

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

    python setup.py sdist --formats=gztar

  23. Ve al directorio superior:

    cd ..

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

    pwd

    La salida tiene este aspecto:

    /home/jupyter

  25. Copia el paquete de Python en el bucket de almacenamiento provisional:

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

  26. Verifica que el paquete se encuentra en el bucket de almacenamiento provisional:

    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

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

En esta sección, creará una conexión de Service Networking que se usará para establecer servicios de productor conectados a la red de VPC vertex-networking-vpc mediante el emparejamiento entre redes de VPC. Para obtener más información, consulta Emparejamiento entre redes de VPC.

  1. En Cloud Shell, ejecuta los siguientes comandos y sustituye PROJECT_ID por el ID de tu proyecto:

    projectid=PROJECT_ID
gcloud config set project ${projectid}

  2. Para definir un intervalo de direcciones IP reservadas, usa 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 emparejamiento entre la red de VPC vertex-networking-vpc y Service Networking de Google mediante 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 emparejamiento de VPC para habilitar la importación y exportación de rutas aprendidas personalizadas:

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

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

    Ir a Cloud Routers

  2. En la lista de Cloud Routers, haga clic en vertex-networking-vpc-router1.

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

  4. Haz clic en Añadir una ruta personalizada.

  5. En Origen, selecciona Intervalo de IP personalizado.

  6. En Intervalo de direcciones IP, introduzca el siguiente intervalo de direcciones IP:

    192.168.10.0/24

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

    Vertex AI Pipelines reserved subnet

  8. Haz clic en Hecho y, a continuación, en Guardar.

Crea una plantilla de flujo de procesamiento y súbela a Artifact Registry

En esta sección, crearás y subirás una plantilla de flujo de procesamiento de Kubeflow Pipelines (KFP). Esta plantilla contiene una definición de flujo de trabajo que puede reutilizarse varias veces, ya sea por un solo usuario o por varios.

Definir y compilar el flujo de procesamiento

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

  2. Selecciona Archivo > Nuevo > Cuaderno.

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

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

    !python -m pip install --upgrade pip

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

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

  6. Cuando se complete la instalación, selecciona Kernel > Reiniciar kernel para reiniciar el kernel y asegurarte de que la biblioteca esté disponible para importarla.

  7. Ejecuta el siguiente código en una celda de cuaderno nueva 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 cuaderno 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  Explorador de archivos, aparece un archivo llamado pipeline_config.yaml en la lista de archivos.

Crear un repositorio de Artifact Registry

  1. Ejecuta el siguiente código en una celda de cuaderno 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

Subir la plantilla de flujo de trabajo a Artifact Registry

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

  1. En tu cuaderno de JupyterLab, ejecuta el siguiente código para subir la plantilla de la canalización. Sustituye 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 Google Cloud consola, para verificar que se ha subido tu plantilla, ve a Plantillas de Vertex AI Pipelines.

    Ir a Pipelines

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

  4. En la lista de repositorios, haz clic en el que has creado (fungi-repo) y, a continuación, en Seleccionar.

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

Activar una ejecución de flujo de procesamiento desde un entorno on-premise

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

Proporciona los parámetros de la canalización

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

    print (TEMPLATE_NAME)

    El nombre de la plantilla devuelta es:

    custom-image-classification-pipeline

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

    print (VERSION_NAME)

    El nombre de la versión de la plantilla de flujo de procesamiento devuelta tiene este formato:

    sha256:41eea21e0d890460b6e6333c8070d7d23d314afd9c7314c165efd41cddff86c7

    Anota toda la cadena del nombre de la versión.

  3. En Cloud Shell, ejecuta los siguientes comandos y sustituye PROJECT_ID por el ID de tu proyecto:

    projectid=PROJECT_ID
gcloud config set project ${projectid}

  4. Inicia sesión en la on-prem-dataservice-host instancia de VM:

    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. Añade 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"
}
}

    Sustituye los siguientes valores:

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

  7. Guarda el archivo de la siguiente manera:

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

Enviar una ejecución de flujo de procesamiento desde tu plantilla

  1. En la instancia de VM on-prem-dataservice-host, ejecuta el siguiente comando, sustituyendo PROJECT_ID por el ID de tu 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

    La salida que verás es larga, 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 Google Cloud consola, en la sección Vertex AI, ve a la pestaña Ejecuciones de la página Pipelines.

    Ir a Carreras

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

    Se muestra la página de ejecución de la canalización y el gráfico de tiempo de ejecución de la canalización. El resumen de la canalización aparece en el panel Análisis de la ejecución del flujo de procesamiento.

    Para obtener ayuda sobre 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 Visualizar y analizar los resultados de la canalización.

Limpieza

Para evitar que se apliquen cargos en tu Google Cloud cuenta por los recursos utilizados en este tutorial, puedes eliminar el proyecto que contiene los recursos o conservar el proyecto y eliminar los recursos.

Para eliminar los recursos de un proyecto, sigue estos pasos:

  1. Elimina todas las ejecuciones de la canalización de la siguiente manera:

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

      Ir a Carreras

    2. Selecciona las ejecuciones de la canalización que quieras eliminar y haz clic en Eliminar.

  2. Elimina la plantilla de flujo de la siguiente manera:

    1. En la sección Vertex AI, ve a la pestaña Tus plantillas de la página Pipelines.

      Ir a Pipelines

    2. Junto a la plantilla de canalización custom-image-classification-pipeline, haz clic en Acciones y selecciona Eliminar.

  3. Elimina el repositorio de Artifact Registry de la siguiente manera:

    1. En la página Artifact Registry, vaya a la pestaña Repositorios.

      Ir a Repositorios

    2. Selecciona el repositorio fungi-repo y haz clic en Eliminar.

  4. Para anular el despliegue del modelo en el endpoint, sigue estos pasos:

    1. En la sección Vertex AI, ve a la pestaña Endpoints de la página Predicciones online.

      Ir a Endpoints

    2. Haz clic en fungi-image-endpoint para ir a la página de detalles del endpoint.

    3. En la fila de tu modelo, fungi-image-model, haz clic en Acciones y selecciona Retirar modelo del endpoint.

    4. En el cuadro de diálogo Anular despliegue de modelo de punto final, haz clic en Anular despliegue.

  5. Elimina el endpoint de la siguiente manera:

    1. En la sección Vertex AI, ve a la pestaña Endpoints de la página Predicciones online.

      Ir a Endpoints

    2. Selecciona fungi-image-endpoint y haz clic en Eliminar.

  6. Elimina el modelo de la siguiente manera:

    1. Ve a la página Registro de modelos.

      Ir a Modelos

    2. En la fila de tu modelo, fungi-image-model, haz clic en Acciones y selecciona Eliminar modelo.

  7. Elimina el segmento de almacenamiento provisional de la siguiente manera:

    1. Ve a la página Cloud Storage.

      Ir a Cloud Storage

    2. Selecciona pipelines-staging-bucket-PROJECT_ID, donde PROJECT_ID es el ID del proyecto, y haz clic en Eliminar.

  8. Elimina la instancia de Vertex AI Workbench de la siguiente manera:

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

      Ir a Vertex AI Workbench

    2. Selecciona la instancia de pipeline-tutorial-PROJECT_ID Vertex AI Workbench, donde PROJECT_ID es el ID del proyecto, y haz clic en Eliminar.

  9. Elimina la instancia de VM de Compute Engine de la siguiente manera:

    1. Ve a la página Compute Engine.

      Ir a Compute Engine

    2. Selecciona la instancia de VM on-prem-dataservice-host y haz clic en Eliminar.

  10. Elimina los túneles VPN de la siguiente manera:

    1. Ve a la página VPN.

      Ir a VPN

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

    3. En la lista de túneles VPN, selecciona los cuatro túneles VPN que has creado en este tutorial y haz clic en Eliminar.

  11. Elimina las pasarelas de VPN de alta disponibilidad de la siguiente manera:

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

      Ir a Pasarelas de Cloud VPN

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

    3. En la página Detalles de la pasarela VPN de Cloud, haz clic en Eliminar pasarela VPN .

    4. Haz clic en la flecha hacia atrás si es necesario para volver a la lista de pasarelas VPN y, a continuación, haz clic en vertex-networking-vpn-gw1.

    5. En la página Detalles de la pasarela VPN de Cloud, haz clic en Eliminar pasarela VPN .

  12. Elimina los routers de Cloud de la siguiente manera:

    1. Ve a la página Routers de Cloud Router.

      Ir a Cloud Routers

    2. En la lista de routers de Cloud Router, selecciona los cuatro routers que has creado en este tutorial.

    3. Para eliminar los routers, haz clic en Eliminar.

      También se eliminarán las dos pasarelas de Cloud NAT conectadas a los Cloud Routers.

  13. Elimina las conexiones de Service Networking a las redes de VPC vertex-networking-vpc y onprem-dataservice-vpc de la siguiente manera:

    1. Ve a la página Emparejamiento entre redes de VPC.

      Ir a Emparejamiento entre redes de VPC

    2. Selecciona servicenetworking-googleapis-com.

    3. Para eliminar las conexiones, haz clic en Eliminar.

  14. Elimina la regla de reenvío pscvertex de la red de VPC vertex-networking-vpc de la siguiente manera:

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

      Ir a Frontends

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

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

  15. Elimina la instancia de Filestore de la siguiente manera:

    1. Ve a la página Filestore.

      Ir a Filestore

    2. Selecciona la instancia image-data-instance.

    3. Para eliminar la instancia, haga clic en Acciones y, a continuación, en Eliminar instancia.

  16. Elimina las redes de VPC de la siguiente manera:

    1. Ve a la página Redes de VPC.

      Ir a redes de VPC

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

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

      Si eliminas una red, también se eliminan sus reglas de cortafuegos, rutas y subredes.

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

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

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

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

      Ir a Cuentas de servicio

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

Siguientes pasos