Implementa cargas de trabajo de GPU en Autopilot

En esta página, se muestra cómo solicitar aceleradores de hardware (GPU) en tus cargas de trabajo de Autopilot de Google Kubernetes Engine (GKE).

Autopilot proporciona la clase de procesamiento Accelerator especializada para ejecutar Pods de GPU. Con esta clase de procesamiento, GKE coloca los Pods en los nodos de GPU, lo que proporciona a los Pods acceso a capacidades avanzadas en la máquina virtual (VM). De manera opcional, puedes ejecutar Pods de GPU sin seleccionar la clase de procesamiento Accelerator. Para obtener más información sobre los beneficios de la clase de procesamiento Accelerator, consulta Cuándo usar clases de procesamiento específicas.

Precios

Autopilot factura de manera diferente según si solicitaste la clase de procesamiento Accelerator para ejecutar tus cargas de trabajo de GPU.

¿Usar la clase de procesamiento Accelerator? Precios Compatibilidad con las funciones de GKE
Se te factura por el hardware de Compute Engine que ejecuta tus cargas de trabajo de GPU, además de un recargo de Autopilot para la administración y escalabilidad automáticas de nodos. Para obtener más información, consulta Precios del modo Autopilot.

Compatible con los siguientes elementos:
Se te factura en función de las solicitudes de recursos del Pod de GPU. Para obtener más detalles, consulta la sección “Pods de GPU” en Precios de Kubernetes Engine.

Compatible con los siguientes elementos:

Antes de comenzar

Antes de comenzar, asegúrate de haber realizado las siguientes tareas:

  • Habilita la API de Google Kubernetes Engine.
    • Habilitar la API de Google Kubernetes Engine
  • Si deseas usar Google Cloud CLI para esta tarea, instala y, luego, inicializa gcloud CLI. Si ya instalaste gcloud CLI, ejecuta gcloud components update para obtener la versión más reciente.

  • Asegúrate de tener un clúster de GKE Autopilot que ejecute una de las siguientes versiones:

    • Clase de procesamiento del acelerador: cualquier versión de parche de 1.28 a partir de 1.28.6-gke.1095000
      • GPU NVIDIA H100 (80 GB): 1.28.6-gke.1369000 o posteriores y 1.29.1-gke.1575000 o versiones posteriores
      • Varios Pods de GPU por VM: 1.29.2-gke.1355000 o superior

    • No hay selección de clases de procesamiento:

      • GPU NVIDIA L4: 1.28.3-gke.1203000 o posteriores
      • GPU NVIDIA A100 (80 GB): 1.27 o posteriores
      • Todas las demás GPU: 1.24.2-gke.1800 o versiones posteriores

  • Asegúrate de que tienes suficientes cuotas de GPU disponibles en tu proyecto. Debes tener suficiente cuota de GPU de Compute Engine para los modelos de GPU que quieras crear en cada región. Si necesitas una cuota de GPU adicional, solicita una cuota de GPU.

Limitaciones

  • Las GPU de tiempo compartido y las GPU de varias instancias están disponibles con Autopilot en la versión 1.29.3-gke.1093000 y posteriores de GKE.
  • La disponibilidad de GPU depende de la región de Google Cloud de tu clúster en modo Autopilot y de tu cuota de GPU. Para encontrar un modelo de GPU por región o zona, consulta Disponibilidad de regiones y zonas de GPU.
  • Para las GPU NVIDIA A100 (80 GB), se te cobra un precio fijo por los SSD locales conectados a los nodos, sin importar si tus pods usan esa capacidad.
  • En las versiones de GKE anteriores a la 1.29.2-gke.1355000, si solicitas de forma explícita un nodo de GPU específico para tu Pod, el Pod debe consumir todos los recursos de GPU en el nodo. Por ejemplo, si el nodo existente tiene 8 GPU y los contenedores del pod solicitan un total de 4 GPU, Autopilot rechaza el Pod.
  • Para la versión 1.29.2-gke.1355000 o posterior de GKE, si deseas que varios Pods de GPU quepan en un solo nodo, la suma de solicitudes de GPU para esos Pods debe ser menor o igual que la cantidad de recursos de GPU adjuntos a ese nodo. Por ejemplo, un nodo con un gke-accelerator-count de 4 puede alojar hasta cuatro pods que soliciten una GPU cada uno.

Colocar varios Pods en un solo nodo de GPU es útil en situaciones como las siguientes:

  • Tienes reservas de capacidad para tipos de máquinas Accelerator grandes y ejecutas cargas de trabajo de una sola GPU, por lo que implementar un Pod por nodo desperdiciaría las otras GPU en esa máquina.
  • Tienes cargas de trabajo de GPU que deben ejecutarse en el mismo host.

En estas situaciones, te recomendamos que uses todas las GPUs en el nodo. Para ello, asegúrate de que la suma de solicitudes de recursos de GPU de Pods en el nodo sea igual a la cantidad de GPU conectadas al nodo.

Solicita GPU en tus contenedores

Si deseas solicitar recursos de GPU para tus contenedores, agrega los siguientes campos a tu especificación de Pods. Según los requisitos de la carga de trabajo, puedes omitir los campos cloud.google.com/compute-class: "Accelerator" y cloud.google.com/gke-accelerator-count de manera opcional.

apiVersion: v1
kind: Pod
metadata:
  name: my-gpu-pod
spec:
  nodeSelector:
    cloud.google.com/compute-class: "Accelerator"
    cloud.google.com/gke-accelerator: GPU_TYPE
    cloud.google.com/gke-accelerator-count: GPU_COUNT
  containers:
  - name: my-gpu-container
    image: nvidia/cuda:11.0.3-runtime-ubuntu20.04
    command: ["/bin/bash", "-c", "--"]
    args: ["while true; do sleep 600; done;"]
    resources:
      limits:
        nvidia.com/gpu: GPU_QUANTITY

Reemplaza lo siguiente:

  • GPU_TYPE: Es el tipo de hardware de GPU. Los valores permitidos son los siguientes:
    • nvidia-h100-80gb: NVIDIA H100 (80 GB) (solo disponible con la clase de procesamiento Accelerator)
    • nvidia-a100-80gb: NVIDIA A100 (80 GB)
    • nvidia-tesla-a100: NVIDIA A100 (40 GB)
    • nvidia-l4: NVIDIA L4
    • nvidia-tesla-t4: NVIDIA T4
  • GPU_COUNT: Es la cantidad total de GPUs disponibles para conectar al nodo. Debe ser mayor o igual que GPU_QUANTITY y una cantidad de GPU compatible para el tipo de GPU que seleccionaste. Si omites este nodeSelector, Autopilot coloca un Pod en cada nodo de GPU.
  • GPU_QUANTITY: Es la cantidad de GPU que se asignará al contenedor. Debe ser menor o igual que GPU_COUNT y una cantidad de GPU compatible para el tipo de GPU que seleccionaste.

Debes especificar el tipo y la cantidad de GPU en la especificación del Pod. Si omites cualquiera de estos valores, Autopilot rechaza tu Pod.

Cuando implementas este manifiesto, Autopilot instala de forma automática los controladores NVIDIA predeterminados para la versión de GKE del nodo. En la versión 1.29.2-gke.1108000 y en versiones posteriores, puedes optar por instalar la última versión del controlador para esa versión de GKE si agregas el siguiente selector de nodos a tu manifiesto:

spec:
  nodeSelector:
    cloud.google.com/gke-gpu-driver-version: "DRIVER_VERSION"

Reemplaza DRIVER_VERSION por uno de los siguientes valores:

  • default: el controlador estable y predeterminado para la versión de GKE de tu nodo. Si omites nodeSelector en tu manifiesto, esta es la opción predeterminada.
  • latest: la última versión del controlador disponible para la versión de GKE de tu nodo.

Solicitudes de CPU y memoria para Pods de GPU de Autopilot

Cuando definas tus Pods de GPU, también debes solicitar recursos de CPU y memoria para que tus contenedores funcionen como se espera. Con Autopilot se aplican mínimos, máximos y valores predeterminados específicos de CPU y memoria según el tipo y la cantidad de GPU. Si ejecutas varios Pods de GPU en un solo nodo, especifica la CPU y la memoria; de lo contrario, se usará de forma predeterminada la capacidad completa del nodo. Para obtener más detalles, consulta Solicitudes de recursos en Autopilot.

La especificación de tu Pod debería ser similar al siguiente ejemplo, que solicita cuatro GPU T4:

apiVersion: v1
kind: Pod
metadata:
  name: t4-pod
spec:
  nodeSelector:
    cloud.google.com/compute-class: "Accelerator"
    cloud.google.com/gke-accelerator: "nvidia-tesla-t4"
  containers:
  - name: t4-container-1
    image: nvidia/cuda:11.0.3-runtime-ubuntu20.04
    command: ["/bin/bash", "-c", "--"]
    args: ["while true; do sleep 600; done;"]
    resources:
      limits:
        nvidia.com/gpu: 3
        cpu: "54"
        memory: "54Gi"
      requests:
        cpu: "54"
        memory: "54Gi"
  - name: t4-container-2
    image: nvidia/cuda:11.0.3-runtime-ubuntu20.04
    command: ["/bin/bash", "-c", "--"]
    args: ["while true; do sleep 600; done;"]
    resources:
      limits:
        nvidia.com/gpu: 1
        cpu: "18"
        memory: "18Gi"
      requests:
        cpu: "18"
        memory: "18Gi"

En este manifiesto, se especifica limits para los recursos de CPU y memoria. Si omites limits para CPU o memoria en la versión 1.29.2-gke.1060000 y posteriores de GKE, GKE otorga a tus pods la clase QoS Burstable y permite que tus pods generen aumentos de actividad en los recursos sin usar de la suma de solicitudes de recursos en el nodo. Para obtener más información, consulta Configura los aumentos de actividad de Pods en GKE.

Solicitudes de almacenamiento efímero para Pods de GPU de Autopilot

También puedes solicitar almacenamiento efímero en Pods que necesiten almacenamiento de corta duración. El almacenamiento efímero máximo disponible y el tipo de hardware de almacenamiento usado dependen del tipo y la cantidad de GPU que solicita el Pod. Puedes usar la SSD local para el almacenamiento efímero si usas GPU NVIDIA L4, la clase de procesamiento Accelerator y ejecutas la versión 1.28.6-gke.1369000 y posteriores del parche de GKE, o 1.29.1- gke.1575000 y posteriores.

Si quieres usar una SSD local para el almacenamiento efímero, agrega nodeSelector cloud.google.com/gke-ephemeral-storage-local-ssd: "true" al manifiesto de la carga de trabajo. Consulta el manifiesto de ejemplo en Usa el almacenamiento efímero respaldado por SSD local con clústeres de Autopilot. Las GPU NVIDIA H100 (80 GB) y NVIDIA A100 (80 GB) siempre usan SSD locales para el almacenamiento efímero, y no puedes especificar este selector de nodos para esas GPU.

Verifica la asignación de GPU

Para verificar que una carga de trabajo de GPU implementada tenga las GPU solicitadas, ejecuta el siguiente comando:

kubectl describe node NODE_NAME

Reemplaza NODE_NAME con el nombre del nodo en el que se programó el pod.

El resultado es similar al siguiente:


apiVersion: v1
kind: Node
metadata:
...
  labels:
    ...
    cloud.google.com/gke-accelerator: nvidia-tesla-t4
    cloud.google.com/gke-accelerator-count: "1"
    cloud.google.com/machine-family: custom-48
    ...
...

Verifica la versión del controlador de GPU

En los clústeres de Autopilot, GKE instala de forma automática los controladores de dispositivos NVIDIA en todos los nodos de GPU. Para encontrar la versión del controlador que GKE instaló en tu clúster, ejecuta el siguiente comando:

kubectl logs --label=k8s-app=nvidia-gpu-device-plugin \
    --container="nvidia-gpu-device-plugin" \
    --tail=-1 \
    --namespace=kube-system | grep Driver

El resultado es similar al siguiente:

I1206 18:37:08.251742    5851 metrics.go:144] nvml initialized successfully. Driver version: 535.104.12

Cómo funciona la asignación de GPU en Autopilot

Después de solicitar un tipo de GPU y una cantidad para los contenedores en un Pod e implementar el Pod, sucede lo siguiente:

  1. Si no existe un nodo de GPU asignable, Autopilot proporciona un nodo de GPU nuevo para programar el Pod. Autopilot instala de forma automática los controladores de NVIDIA para facilitar el hardware.
  2. Autopilot agrega taints de nodos al nodo de GPU y las tolerancias correspondientes al Pod. Esto evita que GKE programe otros Pods en el nodo de GPU.

A través de Autopilot se coloca exactamente un Pod de GPU en cada nodo de GPU, así como cualquier carga de trabajo administrada por GKE que se ejecute en todos los nodos y cualquier DaemonSet que configures para tolerar todos los taints de nodo.

Ejecuta DaemonSets en cada nodo

Se recomienda que ejecutes DaemonSets en cada nodo, incluso con nodos con taints aplicados. Por ejemplo, algunos agentes de registro y supervisión deben ejecutarse en cada nodo del clúster. Puedes configurar esos DaemonSets para ignorar los taints de nodo a fin de que GKE coloque esas cargas de trabajo en cada nodo.

Para ejecutar DaemonSets en cada nodo de tu clúster, incluidos los nodos de GPU, agrega la siguiente tolerancia a tu especificación:

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: logging-agent
spec:
  tolerations:
  - key: ""
    operator: "Exists"
    effect: ""
  containers:
  - name: logging-agent-v1
    image: IMAGE_PATH

Para ejecutar DaemonSets en nodos de GPU específicos en tu clúster, agrega lo siguiente a tu especificación:

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: logging-agent
spec:
  nodeSelector:
    cloud.google.com/gke-accelerator: "GPU_TYPE"
  tolerations:
  - key: ""
    operator: "Exists"
    effect: ""
  containers:
  - name: logging-agent-v1
    image: IMAGE_PATH

Reemplaza GPU_TYPE por el tipo de GPU en tus nodos de destino. Puede ser una de las siguientes:

  • nvidia-h100-80gb: NVIDIA H100 (80 GB) (solo disponible con la clase de procesamiento Accelerator)
  • nvidia-a100-80gb: NVIDIA A100 (80 GB)
  • nvidia-tesla-a100: NVIDIA A100 (40 GB)
  • nvidia-l4: NVIDIA L4
  • nvidia-tesla-t4: NVIDIA T4

Casos de uso de GPU en Autopilot

Puedes asignar GPU a contenedores en Pods de Autopilot para facilitar las cargas de trabajo como las siguientes:

  • Inferencia de aprendizaje automático (AA)
  • Entrenamiento del AA
  • Renderización

Cantidades de GPU admitidas

Cuando solicitas GPU en tu especificación de Pod, debes usar las siguientes cantidades según el tipo de GPU:

Cantidades de GPU
NVIDIA L4
nvidia-l4		 1, 2, 4, 8
NVIDIA T4
nvidia-tesla-t4		 1, 2, 4
NVIDIA A100 (40GB)
nvidia-tesla-a100		 1, 2, 4, 8, 16
NVIDIA A100 (80GB)
nvidia-a100-80gb		 1, 2, 4, 8
NVIDIA H100 de 80 GB
nvidia-h100-80gb		 8

Si solicitas una cantidad de GPU que no es compatible con ese tipo, Autopilot rechaza tu Pod.

Supervisa los nodos de GPU

Si tu clúster de GKE tiene habilitadas las métricas del sistema, las siguientes métricas están disponibles en Cloud Monitoring para supervisar el rendimiento de tu carga de trabajo de GPU:

  • Ciclo de trabajo (container/accelerator/duty_cycle): Porcentaje de tiempo durante el último período de muestra (10 segundos) durante el cual el acelerador se procesaba de forma activa. Entre 1 y 100.
  • Uso de memoria (container/accelerator/memory_used): cantidad de memoria del acelerador asignada en bytes.
  • Capacidad de memoria (container/accelerator/memory_total): Memoria total del acelerador en bytes.

Puedes usar paneles predefinidos para supervisar tus clústeres con nodos de GPU. Para obtener más información, consulta Visualiza métricas de observabilidad. Para obtener información general sobre la supervisión de los clústeres y sus recursos, consulta Observabilidad para GKE.

Visualiza las métricas de uso de las cargas de trabajo

Puedes ver las métricas de uso de GPU de tu carga de trabajo desde el panel de Cargas de trabajo en la consola de Google Cloud.

Para ver el uso de GPU de tu carga de trabajo, realiza los siguientes pasos:

  1. Ve a la página Cargas de trabajo en la consola de Google Cloud.

    Ir a Cargas de trabajo
  2. Selecciona una carga de trabajo.

El panel de las cargas de trabajo muestra los gráficos para el uso y la capacidad de la memoria de GPU y el ciclo de trabajo de GPU.

Visualiza las métricas del administrador de GPU del centro de datos de NVIDIA (DCGM)

Puedes recopilar y visualizar métricas de NVIDIA DCGM a través de Google Cloud Managed Service para Prometheus. Para los clústeres de Standard, debes instalar los controladores NVIDIA. Para los clústeres de Autopilot, GKE instala los controladores.

Para obtener instrucciones sobre cómo implementar DCGM y el exportador de DCGM de Prometheus, consulta Administrador de GPU del centro de datos de NVIDIA (DCGM) en la documentación de Google Cloud Observability.

¿Qué sigue?