Desplegar una carga de trabajo de aprendizaje automático por lotes

Autopilot Standard

En este tutorial se muestra cómo usar Google Kubernetes Engine (GKE) para gestionar cargas de trabajo por lotes tolerantes a fallos y, al mismo tiempo, mantener los costes bajos. Sigue este tutorial para aprender a usar trabajos y pods esporádicos optimizados para los costes, así como a configurar una cola de trabajos de Redis en un clúster de GKE.

Fondo

Una carga de trabajo por lotes es un proceso que suele tener un punto de inicio y un punto de finalización. Deberías plantearte usar cargas de trabajo por lotes en GKE si tu arquitectura implica ingerir, procesar y generar datos en lugar de usar datos sin procesar. En áreas como el aprendizaje automático, la inteligencia artificial y la computación de alto rendimiento (HPC), se utilizan diferentes tipos de cargas de trabajo por lotes, como el entrenamiento de modelos sin conexión, la predicción por lotes, las analíticas de datos, la simulación de sistemas físicos y el procesamiento de vídeo.

Si diseña cargas de trabajo por lotes en contenedores, puede aprovechar las siguientes ventajas de GKE:

• Un estándar abierto, una comunidad amplia y un servicio gestionado.
• Rentabilidad gracias a la orquestación eficaz de cargas de trabajo e infraestructuras, así como a recursos informáticos especializados.
• Aislamiento y portabilidad de la contenedorización, lo que permite usar la nube como capacidad de desbordamiento y, al mismo tiempo, mantener la seguridad de los datos.
• Disponibilidad de capacidad de ráfaga, seguida de una reducción rápida de la escala de los clústeres de GKE.

Objetivos

Este tutorial está dirigido a ingenieros de aprendizaje automático o científicos de datos que quieran aprender a ejecutar cargas de trabajo de aprendizaje automático por lotes en GKE con la siguiente arquitectura rentable y escalable:

Este tutorial abarca los siguientes pasos:

1. Crea un clúster de Autopilot de GKE. También puedes usar un clúster de GKE Standard en este tutorial.
2. Crea un volumen Filestore NFS.
3. Crea una cola de trabajos de Redis en el clúster.
4. Transfiere los conjuntos de datos al volumen NFS y ponlos en cola para que la carga de trabajo los consuma.
5. Ejecuta una carga de trabajo de aprendizaje automático por lotes de ejemplo en el clúster de GKE.

Costes

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

• Compute Engine
• GKE Autopilot
• Filestore

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.

---

Para seguir las instrucciones paso a paso de esta tarea directamente en la Google Cloud consola, haga clic en Ayúdame:

Guíame

---

Antes de empezar

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, 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.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Compute Engine, GKE, and Filestore 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

In the Google Cloud console, on the project selector page, 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.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Compute Engine, GKE, and Filestore 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

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

Preparar el entorno

1. Clona el repositorio de muestra que se usa en este tutorial:

   git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
   cd kubernetes-engine-samples/batch/aiml-workloads
   

2. Crea un clúster de Autopilot de GKE:

   gcloud container clusters create-auto batch-aiml \
       --location=us-central1
   

   Este paso puede tardar hasta 5 minutos.

Configurar el almacenamiento de conjuntos de datos con un sistema de archivos de red (NFS)

La carga de trabajo de aprendizaje automático requiere una solución de almacenamiento para los conjuntos de datos y los archivos de salida. En esta sección, crearás una instancia de Filestore y proporcionarás acceso a la instancia mediante un PersistentVolume y un PersistentVolumeClaim.

Para obtener más información, consulta cómo diseñar una estrategia de almacenamiento óptima y cómo acceder a instancias de Filestore desde clústeres de GKE.

Crear una instancia de Filestore

1. Crea una instancia de Filestore:

   gcloud filestore instances create batch-aiml-filestore \
       --zone=us-central1-b \
       --tier=BASIC_HDD \
       --file-share=name="NFSVol",capacity=1TB \
       --network=name="default"
   

   Este comando especifica las siguientes opciones:

   • tier: el nivel de servicio de la instancia de Filestore. En este ejemplo se usa el nivel básico. Para obtener información sobre otras opciones, consulta Niveles de servicio.

   • network=name: nombre de la red de nube privada virtual (VPC) de la instancia de Filestore. El clúster de GKE debe estar en la misma red de VPC que la instancia de Filestore.

   • capacity: tamaño deseado del volumen. Especifica el valor de almacenamiento en una de las unidades admitidas que se describen en Cantidades de recursos.

   Nota: Este paso puede tardar hasta 5 minutos en completarse.

2. Comprueba que la instancia de Filestore se ha implementado:

   gcloud filestore instances list \
       --project=PROJECT_ID \
       --zone=us-central1-b
   

   Sustituye PROJECT_ID por el ID de tu proyecto. Google Cloud

   El resultado debería ser similar al siguiente:

   INSTANCE_NAME: batch-aiml-filestore
   LOCATION: us-central1-b
   TIER: BASIC_HDD
   CAPACITY_GB: 1024
   FILE_SHARE_NAME: NFSVol
   IP_ADDRESS: 203.0.113.54
   STATE: READY
   CREATE_TIME: 2022-03-15T18:23:51
   

3. Anota el valor del campo IP_ADDRESS para usarlo en la siguiente sección.

Crear un PersistentVolume

Una especificación de PersistentVolume de Kubernetes permite que el clúster de GKE se conecte a la instancia de Filestore.

1. Actualiza el archivo kubernetes-manifests/persistent-volume.yaml con la dirección IP de la instancia de Filestore:

   sed -i "\
     s/<FILESTORE_IP_ADDRESS>/IP_ADDRESS/g" \
     kubernetes-manifests/persistent-volume.yaml
   

   Sustituye IP_ADDRESS por la dirección IP que has anotado al crear la instancia de Filestore en la sección anterior.

2. Despliega el PersistentVolume:

   kubectl apply -f kubernetes-manifests/persistent-volume.yaml
   

Crear un PersistentVolumeClaim

Un PersistentVolumeClaim de Kubernetes permite que los pods y los trabajos de Kubernetes accedan a los recursos de almacenamiento de un PersistentVolume.

Despliega PersistentVolumeClaim:

kubectl apply -f kubernetes-manifests/persistent-volume-claim.yaml

Consumir PersistentVolumeClaim

Una vez que hayas configurado PersistentVolume y PersistentVolumeClaim en el clúster de GKE, podrás configurar el servidor Redis y los trabajos por lotes para que usen PersistentVolumeClaim. Se muestra como un volumen de almacenamiento montable.

Inspecciona los archivos kubernetes-manifests/redis-pod.yaml y kubernetes-manifests/workload.yaml. Las configuraciones del archivo de manifiesto son similares a las siguientes:

  spec:
  …
  containers:
  - name: workload
    image: "us-central1-docker.pkg.dev/gke-batch-aiml/batch-aiml-docker-repo/workload"
    volumeMounts:
    - mountPath: /mnt/fileserver
      name: workload-pvc
  volumes:
  - name: workload-pvc
    persistentVolumeClaim:
      claimName: fileserver-claim
      readOnly: false

En este manifiesto:

• spec.volumes especifica el PersistentVolumeClaim que se va a consumir.
• spec.containers.volumeMounts especifica la ruta del archivo local donde el pod puede acceder al sistema de archivos compartido de Filestore.

Configurar una cola de trabajos de Redis

La carga de trabajo procesa los datos en lotes para entrenar de forma iterativa un modelo de detección de fraudes. Para gestionar los conjuntos de datos que se están procesando o que aún están en la cola, debes desplegar el servidor Redis en el clúster de GKE.

En este tutorial, iniciarás una sola instancia de Redis. Para desplegar Redis de forma escalable y redundante, consulta el artículo sobre cómo crear una aplicación web multinivel con Redis y PHP.

1. Despliega la especificación del servidor Redis.

   kubectl apply -f kubernetes-manifests/redis-pod.yaml
   

2. Comprueba que el pod se está ejecutando:

   kubectl get pods
   

   El resultado debería ser similar al siguiente:

   NAME           READY   STATUS    RESTARTS   AGE
   redis-leader   1/1     Running   0          118s
   

   El Pod puede tardar hasta dos minutos en empezar a funcionar.

3. Transfiere los archivos que contienen los conjuntos de datos de entrenamiento y de prueba al volumen NFS.

   sh scripts/transfer-datasets.sh
   

   Esta secuencia de comandos copia los archivos del repositorio de código de ejemplo en el directorio /mnt/fileserver/datasets/ del pod redis-leader.

4. Rellena la cola de Redis.

   sh scripts/queue-jobs.sh
   

   Esta secuencia de comandos inserta las rutas de los archivos de los conjuntos de datos de entrenamiento en una lista llamada datasets en la base de datos Redis. La carga de trabajo usará esta cola para localizar el siguiente conjunto de datos que se va a procesar.

5. Despliega el servicio para que el servidor Redis se pueda detectar en el clúster de GKE.

   kubectl apply -f ./kubernetes-manifests/redis-service.yaml
   

Ejecutar la carga de trabajo por lotes

En este punto, has preparado el clúster de GKE, la cola de trabajos de Redis y el recurso compartido de archivos. Ahora puedes ejecutar tu carga de trabajo por lotes.

En esta sección, usarás una imagen de contenedor de una carga de trabajo de ejemplo para entrenar un modelo de detección de fraudes con lotes de datos de transacciones financieras. El proceso de entrenamiento se puede resumir de la siguiente manera:

1. Un cliente de Redis reclama trabajos (rutas de archivo a conjuntos de datos) en la cola de Redis y los elimina de la cola cuando se completan.

2. Una clase de gestor de entrenamiento de modelos, FraudDetectionModelTrainer, carga un nuevo lote de datos y, opcionalmente, un estado guardado de un modelo de aprendizaje automático. El conjunto de datos se usa para perfeccionar el modelo (un proceso conocido como entrenamiento "warm-start").

3. El nuevo estado del modelo y un informe con los detalles y las puntuaciones de rendimiento del lote se guardan en el volumen NFS de Filestore, al que se puede acceder en el clúster de GKE mediante un PersistentVolumeClaim.

Para obtener más información, consulta el código fuente.

Definir la tarea

El siguiente manifiesto describe el trabajo de Kubernetes para la imagen de carga de trabajo por lotes. Un controlador de trabajo de Kubernetes crea uno o varios pods y se asegura de que ejecuten correctamente una tarea específica.

apiVersion: batch/v1
kind: Job
metadata:
  name: workload
spec:
  parallelism: 1
  template:
    metadata:
      name: workload
    spec:
      nodeSelector:
        cloud.google.com/gke-spot: "true"
      containers:
      - name: workload
        image: "us-docker.pkg.dev/google-samples/containers/gke/batch-ml-workload"
        volumeMounts:
        - mountPath: /mnt/fileserver
          name: workload-pvc
      volumes:
      - name: workload-pvc
        persistentVolumeClaim:
          claimName: fileserver-claim
          readOnly: false
      restartPolicy: OnFailure

Nota: Si configuras una carga de trabajo en la que los lotes se pueden ejecutar en paralelo (por ejemplo, clasificando lotes de imágenes, análisis de datos de larga duración, etc.), puedes aumentar el valor de parallelism para permitir que se ejecuten tantos pods como ese valor de forma simultánea hasta que se cumpla la condición de finalización. La especificación nodeSelector indica a GKE que use Pods de tipo Spot.

Desplegar la carga de trabajo

1. Desplegar el trabajo:

   kubectl apply -f ./kubernetes-manifests/workload.yaml
   

2. Comprueba si el estado del workload-XXX Pod es Completed:

   watch kubectl get pods
   

   Este proceso puede tardar unos segundos. Para volver a la línea de comandos, pulsa Ctrl+C.

   El resultado debería ser similar al siguiente:

   NAME             READY   STATUS      RESTARTS   AGE
   redis-leader     1/1     Running     0          16m
   workload-4p55d   0/1     Completed   0          83s
   

3. Consulta los registros de la tarea workload:

   kubectl logs job/workload
   

   El resultado debería ser similar al siguiente:

   Worker with sessionID: b50f9459-ce7f-4da8-9f84-0ab5c3233a72
   Initial queue state: empty=False
   Processing dataset: datasets/training/2018-04-04.pkl
   Processing dataset: datasets/training/2018-04-03.pkl
   Processing dataset: datasets/training/2018-04-02.pkl
   Processing dataset: datasets/training/2018-04-01.pkl
   Queue empty, exiting
   

   Los archivos .pkl son serializaciones de conjuntos de datos que contienen un lote de transacciones con tarjeta de crédito, marcadas como válidas o fraudulentas. El trabajo workload itera sobre estos archivos, descomprime los conjuntos de datos y los usa para entrenar el modelo de aprendizaje automático antes de eliminarlos de la cola de Redis. La carga de trabajo sigue procesando los datos en lotes hasta que se vacía la cola de Redis, antes de salir correctamente.

Explorar el volumen NFS

Durante su funcionamiento, la carga de trabajo crea archivos en el volumen NFS montado, al que pueden acceder otras tareas por lotes o aplicaciones online en todo el clúster.

1. Lista los archivos creados por la carga de trabajo:

   kubectl exec --stdin --tty redis-leader -- /bin/sh -c "ls -1 /mnt/fileserver/output"
   

   La salida debería ser la siguiente:

   model_cpt_2018-04-01.pkl
   model_cpt_2018-04-02.pkl
   model_cpt_2018-04-03.pkl
   model_cpt_2018-04-04.pkl
   report.txt
   

   Se han creado puntos de control del modelo entrenado (nombres de archivo como model_cpt_XXX.pkl) y un informe del rendimiento del modelo (report.txt) en el directorio /mnt/fileserver/output del volumen NFS.

2. Consulta el informe de rendimiento del modelo:

   kubectl exec --stdin --tty redis-leader -- /bin/sh -c "cat /mnt/fileserver/output/report.txt"
   

   A continuación, se muestra un fragmento del resultado:

   Report generated on: 2022-02-09 14:19:42.303619
   Training dataset: 2018-04-04.pkl
   Model checkpoint: model_cpt_2018-04-04.pkl
   ---
   Accuracy on training data: 0.9981112277019937
   Accuracy on testing data: 0.9977204434773599
   

   El archivo contiene entradas que detallan la hora del entrenamiento, el conjunto de datos utilizado, la precisión obtenida y el nombre de archivo del punto de control del modelo asociado al entrenamiento.

Para obtener más información sobre los volúmenes NFS, consulta las guías de Filestore.

Limpieza

Para evitar que los recursos utilizados en este tutorial se cobren en tu cuenta de Google Cloud, elimina el proyecto que contiene los recursos o conserva el proyecto y elimina los recursos.

Quitar recursos concretos

Para eliminar los recursos individuales creados en este tutorial, ejecuta los siguientes comandos.

1. Elimina el clúster:

   gcloud container clusters delete batch-aiml \
       --location=us-central1
   

2. Elimina la instancia de Filestore:

   gcloud filestore instances delete batch-aiml-filestore \
       --zone=us-central1-b
   

Eliminar el proyecto

Precaución: Eliminar un proyecto tiene los siguientes efectos:

• Se elimina todo el contenido del proyecto. Si has usado un proyecto que ya existía para las tareas de este documento, cuando lo elimines, también se eliminará cualquier otro trabajo que hayas realizado en él.
• Se pierden los IDs de proyecto personalizados. Cuando creaste este proyecto, es posible que hayas creado un ID de proyecto personalizado que quieras usar en el futuro. Para conservar las URLs que usan el ID del proyecto, como una URL appspot.com, elimina los recursos seleccionados dentro del proyecto en lugar de eliminar todo el proyecto.

Si tienes previsto consultar varias arquitecturas, tutoriales o guías de inicio rápido, reutilizar los proyectos puede ayudarte a no superar los límites de cuota de proyectos.

1. In the Google Cloud console, go to the Manage resources page.

   Go to Manage resources

2. In the project list, select the project that you want to delete, and then click Delete.
3. In the dialog, type the project ID, and then click Shut down to delete the project.

Siguientes pasos

• Consulta la documentación de GKE.

• Consulta más información sobre los volúmenes persistentes.

• Consulta más información sobre los trabajos en GKE.

• Consulta cómo usar máquinas virtuales de Spot para ejecutar cargas de trabajo tolerantes a fallos.

• Consulta otros tutoriales de Kubernetes Engine.

• Consulta arquitecturas de referencia, diagramas y prácticas recomendadas sobre Google Cloud. Consulta nuestro Centro de arquitectura de Cloud.