Antecedentes
Una carga de trabajo por lotes es un proceso comúnmente diseñado para tener un punto de inicio y de finalización. Te recomendamos considerar las cargas de trabajo por lotes en GKE si tu arquitectura implica la transferencia, el procesamiento y la salida de datos en lugar de usar datos sin procesar. Las áreas como el aprendizaje automático, la inteligencia artificial y la computación de alto rendimiento (HPC) tienen diferentes tipos de cargas de trabajo por lotes, como el entrenamiento de modelos sin conexión, la predicción por lotes, el análisis de datos, la simulación de sistemas físicos y el procesamiento de videos.
Cuando diseñas cargas de trabajo por lotes en contenedores, puedes aprovechar los siguientes beneficios de GKE:
- Un estándar abierto, una comunidad amplia y un servicio administrado.
- Rentabilidad a partir de la organización eficaz de la infraestructura y la carga de trabajo y recursos de procesamiento especializados.
- Aislamiento y portabilidad de la creación de contenedores, lo que permite el uso de la nube como capacidad de desbordamiento y, al mismo tiempo, mantener la seguridad de los datos.
- Disponibilidad de la capacidad de aumento de actividad, seguida de una rápida reducción vertical de la escala de los clústeres de GKE.
Objetivos
Este instructivo va dirigido a ingenieros de aprendizaje automático o científicos de datos que deseen aprender a ejecutar cargas de trabajo de aprendizaje automático por lotes en GKE, en la siguiente arquitectura rentable y escalable:
En este instructivo, se abarcan los siguientes pasos:
- Crear un clúster de GKE con grupos de nodos de VM Standard y Spot.
- Crear un volumen Filestore NFS.
- Crear una cola de trabajos de Redis en el clúster.
- Transferir los conjuntos de datos al volumen de NFS y colocarlos en una cola para que los consuma la carga de trabajo.
- Ejecutar una carga de trabajo de aprendizaje automático por lotes de muestra en el clúster de GKE.
Costos
En este instructivo, se usan los siguientes componentes facturables de Google Cloud:
Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios.
Antes de comenzar
Configura tu proyecto
- Accede a tu cuenta de Google Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.
-
En Google Cloud Console, en la página del selector de proyectos, haz clic en Crear proyecto para comenzar a crear un proyecto de Google Cloud nuevo.
-
Asegúrate de que la facturación esté habilitada para tu proyecto de Cloud. Obtén información sobre cómo verificar si la facturación está habilitada en un proyecto.
-
Habilita las API de Compute Engine, GKE, and Filestore.
-
En Google Cloud Console, en la página del selector de proyectos, haz clic en Crear proyecto para comenzar a crear un proyecto de Google Cloud nuevo.
-
Asegúrate de que la facturación esté habilitada para tu proyecto de Cloud. Obtén información sobre cómo verificar si la facturación está habilitada en un proyecto.
-
Habilita las API de Compute Engine, GKE, and Filestore.
Configure su entorno
En este instructivo, usarás Cloud Shell para administrar recursos alojados en Google Cloud. Cloud Shell viene preinstalado con Docker y la CLI de gcloud y kubectl
.
Sigue estos pasos para configurar tu entorno con Cloud Shell:
En Google Cloud Console, inicia una instancia de Cloud Shell.
Abre Cloud ShellDescarga el código fuente para esta app de ejemplo.
git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples cd kubernetes-engine-samples/batch/aiml-workloads
Actualiza el archivo
scripts/variables.sh
con la información del proyecto:sed -i "\ s/<YOUR_PROJECT_ID>/PROJECT_ID/g; \ s/<YOUR_REGION>/REGION/g; \ s/<YOUR_ZONE>/ZONE/g" \ scripts/variables.sh
Reemplaza lo siguiente:
PROJECT_ID: el ID del proyecto de Google Cloud
REGION: la región de Compute Engine
ZONE: la zona de Compute Engine
Establece las variables de entorno necesarias y los valores predeterminados de
gcloud
.source scripts/variables.sh gcloud config set project ${PROJECT_ID} gcloud config set compute/region ${REGION} gcloud config set compute/zone ${ZONE} gcloud config set filestore/zone ${ZONE}
Cree un clúster de GKE
Crea un clúster de GKE con dos grupos de nodos en los que GKE aloja el volumen persistente y ejecuta la carga de trabajo con la cola de trabajos de Redis.
Crea un clúster de GKE Standard Este clúster inicializa un grupo de nodos con configuraciones predeterminadas.
gcloud container clusters create ${CLUSTER_NAME} \ --machine-type=e2-standard-2 --num-nodes=3
Verifica que el clúster de GKE esté en ejecución:
gcloud container clusters list
El valor de
STATUS
esRUNNING
para el clústerbatch-aiml
.Crea un segundo grupo de nodos en el clúster de GKE que se habilitará con VM Spot:
gcloud beta container node-pools create batch-node-pool \ --cluster=${CLUSTER_NAME} --spot
Implementarás la carga de trabajo por lotes en este grupo de nodos de VM Spot más adelante en el instructivo.
Configura 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 este instructivo, crearás una instancia de Filestore, a la que pueden acceder todos los nodos (operaciones de lectura y escritura) en un clúster de GKE a través de un volumen persistente (PV) y una reclamación de volúmenes persistentes (PVC).
Para obtener más información, consulta cómo diseñar una estrategia de almacenamiento óptima y cómo acceder a archivos compartidos desde clústeres de GKE.
Crea una instancia de Filestore
Crea una instancia de Filestore
gcloud filestore instances create ${FILESTORE_ID} \ --tier=BASIC_HDD \ --file-share=name="NFSVol",capacity=1TB \ --network=name="default"
Donde:
tier
es el nivel de servicio para la instancia de Filestore. En esta muestra se usa la oferta básica, pero puedes obtener información sobre las otras opciones en Niveles de servicio.network=name
es el nombre de la red de nube privada virtual (VPC) de Compute Engine a la que se conecta la instancia. El clúster de GKE debe estar en la misma red de VPC que la instancia de Filestore.capacity
es el tamaño deseado del volumen. Especifica el valor de almacenamiento en una de las unidades compatibles que se describen en Cantidades de recursos.
Verifica que se haya implementado la instancia de Filestore:
gcloud filestore instances list --project=${PROJECT_ID} --zone=${ZONE}
El resultado es similar al siguiente, en el que el valor
STATE
esREADY
para la instanciabatch-aiml-filestore
:INSTANCE_NAME: batch-aiml-filestore LOCATION: us-central1-b TIER: BASIC_HDD CAPACITY_GB: 1024 FILE_SHARE_NAME: NFSVol IP_ADDRESS: 10.152.101.10 STATE: READY CREATE_TIME: 2022-03-15T18:23:51
Toma nota del valor IP_ADDRESS del resultado; se usará en la próxima sección.
Crea un volumen persistente
Una especificación de volumen persistente (PV) de Kubernetes permite que el clúster de GKE se conecte a la instancia de Filestore.
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
Reemplaza IP_ADDRESS con el valor que anotó cuando crea la instancia de Filestore.
Implementa la especificación de PV:
kubectl apply -f kubernetes-manifests/persistent-volume.yaml
Crea una reclamación de volumen persistente
Una especificación de la reclamación de volumen persistente (PVC) de Kubernetes permite que los trabajos y Pods de Kubernetes accedan a los recursos de almacenamiento de un volumen persistente.
Implementa la especificación de PVC:
kubectl apply -f kubernetes-manifests/persistent-volume-claim.yaml
Consume la reclamación de volumen persistente
Una vez que el volumen persistente y la reclamación de volúmenes persistentes estén configurados en el clúster de GKE, puedes configurar el servidor de Redis y los trabajos por lotes para consumir la PVC. Esto aparecerá como un volumen de almacenamiento activable en la VM que ejecuta los recursos de Kubernetes.
Inspecciona los archivos kubernetes-manifests/redis-pod.yaml
y kubernetes-manifests/workload.yaml
.
Las configuraciones del manifiesto son similares a lo siguiente:
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
Donde:
spec.volumes
especifica las reclamaciones de volúmenes persistentes que se consumirán.spec.containers.volumeMounts
especifica la ruta del archivo local en la VM donde se puede acceder al recurso compartido de Filestore.
Configura una cola de trabajos de Redis
La carga de trabajo procesará datos en lotes para entrenar de forma iterativa el modelo de detección de fraudes. Para administrar los conjuntos de datos que se procesan actualmente o que aún se encuentran en la cola, implementa el servidor de Redis en el clúster de GKE.
Para simplificar, inicia una sola instancia de Redis en esta muestra. Para ver un ejemplo de implementación de Redis de manera escalable y redundante, consulta cómo crear un libro de visitas con Redis y PHP.
Implementa la especificación del servidor de Redis.
kubectl apply -f kubernetes-manifests/redis-pod.yaml
Verifica que el Pod esté en ejecución antes de continuar. En el resultado del siguiente comando, el
STATUS
para el Podredis-leader
debe serRunning
.kubectl get pods
El resultado es similar a este:
NAME READY STATUS RESTARTS AGE redis-leader 1/1 Running 0 118s
Transfiere los archivos que contienen los conjuntos de datos de entrenamiento y de prueba al volumen de NFS.
sh scripts/transfer-datasets.sh
Esta secuencia de comandos copia los archivos del repositorio de código de muestra en el directorio
/mnt/fileserver/datasets/
en el Podredis-leader
.Propaga la cola de Redis.
sh scripts/queue-jobs.sh
Esta secuencia de comandos envía las rutas de acceso de los archivos para los conjuntos de datos de entrenamiento a una lista llamada
datasets
en la base de datos de Redis. La carga de trabajo usará esta cola para ubicar el siguiente conjunto de datos que se debe procesar.Implementa el Service para que el servidor de Redis sea detectable dentro del clúster de GKE.
kubectl apply -f ./kubernetes-manifests/redis-service.yaml
Ejecuta la carga de trabajo por lotes
En este punto, preparaste el clúster de GKE, la cola de trabajos de Redis y el recurso compartido. Ahora puedes ejecutar la carga de trabajo por lotes.
En esta sección, usarás una imagen de contenedor de una carga de trabajo de muestra 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:
Un cliente de Redis reclama trabajos (rutas de acceso de archivos a conjuntos de datos) en la cola de Redis y los quita de la cola una vez que se completan.
Una clase de administrador de entrenamiento de modelos,
FraudDetectionModelTrainer
, carga un nuevo lote de datos y, de forma opcional, un estado guardado de un modelo de aprendizaje automático. El conjunto de datos se usa para definir mejor el modelo (un proceso conocido como entrenamiento de “inicio semicaliente”).El estado nuevo del modelo y un informe de los detalles del lote y las puntuaciones de rendimiento se guardan en el volumen de NFS de Filestore, al que se puede acceder en el clúster de GKE a través de una reclamación de volumen persistente.
Para obtener más información, explora el código fuente.
Define el trabajo
En el siguiente manifiesto, se describe la especificación del trabajo por lotes para la imagen de carga de trabajo. Este manifiesto usa el recurso de trabajo de Kubernetes.
Implementa la carga de trabajo
Aplica la especificación para el trabajo por lotes.
kubectl apply -f ./kubernetes-manifests/workload.yaml
Comprueba si el estado del Pod
workload-XXX
está completo.watch kubectl get pods
Este proceso puede tardar unos segundos. Para volver a la línea de comandos, presiona
Ctrl+C
.El resultado es similar a este:
NAME READY STATUS RESTARTS AGE redis-leader 1/1 Running 0 16m workload-4p55d 0/1 Completed 0 83s
Verifica los registros del trabajo
workload
:kubectl logs job/workload
El resultado es similar a este:
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 de tarjetas de crédito, marcadas como válidas o fraudulentas. El trabajoworkload
itera en estos archivos, descomprime los conjuntos de datos y los usa para entrenar el modelo de aprendizaje automático antes de quitarlos de la cola de Redis. La carga de trabajo continúa con el procesamiento de datos en lotes hasta que se vacía la cola de Redis antes de salir con éxito.
Explora el volumen de NFS
Durante su operación, la carga de trabajo crea archivos en el volumen de NFS activado, accesibles en todo el clúster para otros trabajos por lotes o aplicaciones en línea. Para explorar los archivos en el volumen NFS, sigue estos pasos:
Enumera los archivos que creó la carga de trabajo:
kubectl exec --stdin --tty redis-leader -- /bin/sh -c "ls -1 /mnt/fileserver/output"
El resultado debería ser el 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
Los puntos de control para el modelo entrenado (nombres de archivos como
model_cpt_XXX.pkl
) y un informe del rendimiento del modelo (report.txt
) se crearon en el directorio/mnt/fileserver/output
en el volumen de NFS.Inspecciona el informe de rendimiento del modelo:
kubectl exec --stdin --tty redis-leader -- /bin/sh -c "cat /mnt/fileserver/output/report.txt"
El siguiente es 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 describen la hora de entrenamiento, el conjunto de datos usado, la exactitud obtenida y el nombre de archivo del punto de control del modelo asociado con el entrenamiento.
Para obtener más información sobre los volúmenes de NFS, consulta las Guías de Filestore.
Limpia
Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en este instructivo, borra el proyecto que contiene los recursos o conserva el proyecto y borra los recursos individuales.
Para quitar los recursos individuales creados para este instructivo, sigue estos pasos:
sh scripts/cleanup.sh
¿Qué sigue?
Consulta la documentación de GKE.
Explora los volúmenes persistentes con más detalle.
Obtén más información sobre los trabajos en GKE.
Obtén más información sobre cómo usar las VM Spot para ejecutar cargas de trabajo tolerantes a errores.
Obtén más información sobre cómo configurar un entorno de MLOps en Google Cloud.
Explora otros instructivos de Kubernetes Engine.
Explora arquitecturas de referencia, diagramas, instructivos y prácticas recomendadas sobre Google Cloud. Consulta nuestro Cloud Architecture Center.