Desplegar cargas de trabajo de GPU en Autopilot

En esta página se muestra cómo solicitar GPUs para acelerar las tareas de tus cargas de trabajo de Autopilot de Google Kubernetes Engine (GKE). En esta página también se describe cómo ejecuta Autopilot las GPUs, cómo cambia tu modelo de precios en función de tu versión de GKE, cómo definir solicitudes y límites de recursos de pods, y cómo monitorizar las cargas de trabajo de GPUs.

Esta página está dirigida a administradores y operadores de la plataforma, así como a especialistas en datos e IA que quieran solicitar GPUs para cargas de trabajo que ejecuten tareas como el entrenamiento o la inferencia de aprendizaje automático (ML). Para obtener más información sobre los roles, las responsabilidades y las tareas de ejemplo habituales a los que hacemos referencia en el contenido, consulta Roles y tareas de usuario habituales de GKE. Google Cloud

Antes de continuar, asegúrate de que conoces los siguientes conceptos:

Seleccionar aceleradores en pods

Autopilot usa la clase de computación de acelerador especializada para ejecutar pods de GPU. Con esta clase de computación, GKE coloca los pods en nodos de GPU, lo que les da acceso a funciones avanzadas en la máquina virtual (VM). Para usar esta clase en una carga de trabajo de GPU, lleva a cabo una de las siguientes acciones en función de tu versión de GKE:

  • Versión 1.29.4-gke.1427000 y posteriores: solicita GPUs en el manifiesto de tu carga de trabajo. También puedes usar funciones para compartir la GPU, como el tiempo compartido. GKE no modifica los manifiestos de tu carga de trabajo para añadir un selector de nodos o una anotación para la clase Accelerator.
  • Versión 1.29 hasta la versión 1.29.4-gke.142700 (sin incluir): especifica el selector de nodos cloud.google.com/compute-class: Accelerator en el manifiesto de tu pod y solicita GPUs. Si especificas este selector de nodos, también puedes usar las funciones de uso compartido de la GPU, como el uso compartido por tiempo.
  • Versión 1.28.9-gke.1069000 hasta la versión 1.29 (sin incluir): especifica el selector de nodos cloud.google.com/compute-class: Accelerator en el manifiesto de tu pod junto con los selectores de GPU. Si especificas este selector de nodos, también puedes usar funciones de uso compartido de GPU, como el tiempo compartido.

La clase de computación Accelerator no se admite en versiones anteriores a la 1.28.9-gke.1069000. En su lugar, GKE trata los pods de GPU de esas versiones de forma similar a otros pods de Autopilot y se te factura por las solicitudes de recursos. Para obtener más información, consulta Precios.

Compatibilidad de los aceleradores con las funciones de GKE

En la siguiente tabla se muestran las funciones de GKE compatibles con cada método de selección de aceleradores en Autopilot de GKE:

Accelerator clase de computación seleccionada Compatibilidad con las funciones de GKE

Precios

En la siguiente tabla se describe cómo depende el modelo de facturación que usa GKE de la versión de GKE de tu clúster. Para ver una descripción de los modelos de facturación de Autopilot de GKE, consulta Precios de Autopilot.

Versión de GKE Precios
1.29.4-gke.1427000 y versiones posteriores

Modelo de facturación basado en nodos. Todos los pods de GPU usan la clase de computación Accelerator. Se te cobrará por el hardware de Compute Engine que ejecute tus cargas de trabajo de GPU, además de una prima de Autopilot por la gestión y la escalabilidad de los nodos. Para obtener más información, consulta los precios del modo Autopilot.
Desde la versión 1.29 hasta la 1.29.4-gke.1427000 (sin incluirla)

El modelo de facturación depende de los selectores de nodos que especifiques, como se indica a continuación:

  • cloud.google.com/compute-class: Accelerator: usa el modelo de facturación basado en nodos y la clase de computación Acelerador.
  • No hay selector de clase de computación: se usa el modelo de facturación basado en pods.

Solo puedes usar funciones como las GPUs multiinstancia o el tiempo compartido si especificas explícitamente el selector de nodos cloud.google.com/compute-class: Accelerator.

Para obtener más información, consulta la sección "Pods que tienen requisitos de hardware específicos" de la página Precios de Kubernetes Engine.
Desde la versión 1.28.6-gke.1095000 hasta la versión 1.29 (sin incluirla)

Modelo de facturación basado en nodos, independientemente de si especificas la clase de computación del acelerador en los manifiestos de tu pod.

Solo puedes usar funciones como las GPUs multiinstancia o el tiempo compartido si especificas explícitamente el selector de nodos cloud.google.com/compute-class: Accelerator.

Para obtener más información, consulta la sección "Pods que tienen requisitos de hardware específicos" de la página Precios de Kubernetes Engine.
Versiones anteriores a la 1.28.6-gke.1095000

Modelo de facturación basado en pods. Se te factura en función de las solicitudes de recursos de los pods de GPU. Para obtener más información, consulta la sección "Pods que tienen requisitos de hardware específicos" de la página Precios de Kubernetes Engine.

Ten en cuenta los siguientes aspectos relacionados con los precios de las GPUs de Autopilot:

  • Todos los nodos de GPU A100 (80 GB) usan SSDs locales para los discos de arranque de los nodos con tamaños fijos en función del número de GPUs. Se te facturan por separado las unidades SSD locales conectadas. Estos precios no se aplican a las GPUs A100 (40 GB).

  • Los precios de GKE Sandbox son los mismos que los de Autopilot. Para obtener más información sobre cómo poner en un espacio aislado tus cargas de trabajo de acelerador, consulta GKE Sandbox y cómo empezar a usar GKE Sandbox.

Antes de empezar

Antes de empezar, asegúrate de que has realizado las siguientes tareas:

  • Habilita la API de Google Kubernetes Engine.
    • Habilitar la API de Google Kubernetes Engine
  • Si quieres usar Google Cloud CLI para esta tarea, instálala y, a continuación, inicialízala. Si ya has instalado la gcloud CLI, obtén la versión más reciente ejecutando gcloud components update.

  • Asegúrate de tener un clúster de Autopilot de GKE que ejecute una de las siguientes versiones para usar las siguientes GPUs o funciones:

    • GPUs NVIDIA B200 (180 GB): 1.32.2-gke.1422000 o versiones posteriores
    • GPUs NVIDIA H200 (141 GB): 1.31.4-gke.1183000 o versiones posteriores
    • GPUs NVIDIA H100 Mega (80 GB): 1.28.9-gke.1250000 o versiones posteriores, y 1.29.4-gke.1542000 o versiones posteriores
    • GPUs NVIDIA H100 (80 GB): 1.28.6-gke.1369000 o versiones posteriores, y 1.29.1-gke.1575000 o versiones posteriores
    • Varios pods de GPU por VM: 1.29.2-gke.1355000 o versiones posteriores
    • Otras GPUs: todas las versiones compatibles

Limitaciones

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

Colocar varios pods en un mismo nodo de GPU es útil en situaciones como las siguientes:

  • Tienes reservas de capacidad para tipos de máquinas con aceleradores grandes y ejecutas cargas de trabajo de una sola GPU, por lo que, si implementaras un pod por nodo, se desperdiciarían las otras GPUs de esa máquina.
  • Tienes cargas de trabajo de GPU que deben ejecutarse en el mismo host

En estos casos, te recomendamos que uses todas las GPUs del nodo. Para ello, asegúrate de que la suma de las solicitudes de recursos de GPU de los pods del nodo sea igual al número de GPUs conectadas al nodo.

Solicitar GPUs en tus contenedores

Para solicitar recursos de GPU para tus contenedores, añade los siguientes campos a la especificación de tu pod. En función de los requisitos de tu carga de trabajo, puedes omitir el selector cloud.google.com/gke-accelerator-count.

apiVersion: v1
kind: Pod
metadata:
  name: my-gpu-pod
spec:
  # Optional: Use GKE Sandbox
  # runtimeClassName: gvisor
  nodeSelector:
    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

Haz los cambios siguientes:

  • GPU_TYPE: el tipo de hardware de GPU. Los valores permitidos son los siguientes:

    • nvidia-gb200: NVIDIA GB200 (versión preliminar)
    • nvidia-b200: NVIDIA B200 (180 GB)
    • nvidia-h200-141gb: NVIDIA H200 (141 GB)
    • nvidia-h100-mega-80gb: NVIDIA H100 Mega (80 GB)
    • nvidia-h100-80gb: NVIDIA H100 (80 GB)
    • nvidia-a100-80gb: NVIDIA A100 (80 GB)
    • nvidia-tesla-a100: NVIDIA A100 (40 GB)
    • nvidia-l4: NVIDIA L4
    • nvidia-tesla-t4: NVIDIA T4
    o si usas GKE Sandbox, una de las siguientes opciones:
    • nvidia-gb200: NVIDIA GB200 (versión preliminar)
    • nvidia-b200: NVIDIA B200 (180 GB) (versión preliminar)
    • nvidia-h200-141gb: NVIDIA H200 (141 GB) (vista previa)
    • nvidia-h100-mega-80gb: NVIDIA H100 Mega (80 GB)
    • nvidia-h100-80gb: NVIDIA H100 (80 GB)
    • nvidia-a100-80gb: NVIDIA A100 (80 GB)
    • nvidia-tesla-a100: NVIDIA A100 (40 GB)
    • nvidia-l4: NVIDIA L4
    • nvidia-tesla-t4: NVIDIA T4
    Para obtener más información, consulta la compatibilidad con modelos de GPU.

  • GPU_COUNT: el número total de GPUs disponibles para asociar al nodo. Debe ser mayor o igual que GPU_QUANTITY y una cantidad de GPUs admitida para el tipo de GPU que hayas seleccionado. Si omite este nodeSelector, Autopilot colocará un pod en cada nodo de GPU.

  • GPU_QUANTITY: el número de GPUs que se asignarán al contenedor. Debe ser inferior o igual a GPU_COUNT y una cantidad de GPUs admitida para el tipo de GPU que hayas seleccionado.

  • Opcional runtimeClassname: gvisor: el ajuste que te permite ejecutar este pod en GKE Sandbox. Para usarlo, descomenta esta línea. Para obtener más información, consulta GKE Sandbox.

Para obtener información sobre cómo se te factura el uso de aceleradores en el modo Autopilot, consulta la sección Precios.

Debes especificar tanto el tipo como la cantidad de GPU en la especificación de tu pod. Si omites alguno de estos valores, Autopilot rechazará tu pod.

Cuando despliegues este manifiesto, Autopilot instalará automáticamente los controladores de NVIDIA predeterminados para la versión de GKE del nodo. En la versión 1.29.2-gke.1108000 y posteriores, puedes instalar la versión más reciente del controlador para esa versión de GKE añadiendo el siguiente selector de nodos al manifiesto:

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

Sustituye DRIVER_VERSION por uno de los siguientes valores:

  • default: es el controlador predeterminado y estable de la versión de GKE de tu nodo. Si omites el elemento nodeSelector en tu manifiesto, esta será la opción predeterminada.
  • latest: la versión del controlador más reciente disponible para la versión de GKE de tu nodo.

Solicitar 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 esperas. Autopilot aplica valores mínimos, máximos y predeterminados específicos de CPU y memoria en función del 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 utilizará toda la capacidad del nodo. Para obtener más información, consulta Solicitudes de recursos en Autopilot.

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

apiVersion: v1
kind: Pod
metadata:
  name: t4-pod
spec:
  # Optional: Use GKE Sandbox
  # runtimeClassName: gvisor
  nodeSelector:
    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"
  • Opcional runtimeClassname: gvisor: el ajuste que te permite ejecutar este pod en GKE Sandbox. Para usarlo, descomenta esta línea. Para obtener más información, consulta GKE Sandbox.

Este manifiesto especifica limits para los recursos de CPU y memoria. Si omites limits para la CPU o la memoria en GKE versión 1.29.2-gke.1060000 y versiones posteriores, GKE asigna a tus pods la clase de QoS Burstable y permite que tus pods usen los recursos no utilizados de la suma de las solicitudes de recursos del nodo. Para obtener más información, consulta Configurar el bursting de pods en GKE.

Solicitar 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 utilizado dependen del tipo y la cantidad de GPUs que solicite el pod. Puedes usar SSD local para el almacenamiento efímero si usas GPUs NVIDIA L4, la clase de computación Acelerador y ejecutas la versión de parche 1.28.6-gke.1369000 de GKE o una posterior, o bien la versión 1.29.1-gke.1575000 o una posterior.

Para usar SSD local para el almacenamiento efímero, añade el cloud.google.com/gke-ephemeral-storage-local-ssd: "true" nodeSelector a tu manifiesto de carga de trabajo. Consulta el ejemplo de manifiesto en Usar almacenamiento efímero respaldado por SSD local con clústeres de Autopilot. Las GPUs NVIDIA H100 (80 GB) y NVIDIA A100 (80 GB) siempre usan SSDs locales para el almacenamiento efímero, y no puedes especificar este selector de nodos para esas GPUs.

Verificar la asignación de las GPUs implementadas

Para comprobar que una carga de trabajo de GPU desplegada tiene las GPUs solicitadas, ejecuta el siguiente comando:

kubectl describe node NODE_NAME

Sustituye NODE_NAME por el nombre del nodo en el que se ha programado el pod.

El resultado debería ser 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
    ...
...

Comprobar la versión del controlador de la GPU

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

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

El resultado debería ser 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 GPUs en Autopilot

Cuando solicitas un tipo de GPU y una cantidad para los contenedores de un pod y despliegas el pod, ocurre lo siguiente:

  1. Si no existe ningún nodo de GPU asignable, Autopilot aprovisiona un nuevo nodo de GPU para programar el pod. Autopilot instala automáticamente los controladores de NVIDIA para facilitar el hardware.
  2. Autopilot añade taints de nodo al nodo de GPU y añade las tolerancias correspondientes al pod. De esta forma, se evita que GKE programe otros pods en el nodo de GPU.

Autopilot coloca exactamente un pod de GPU en cada nodo de GPU, así como las cargas de trabajo gestionadas por GKE que se ejecutan en todos los nodos y los DaemonSets que configures para tolerar todos los taints de los nodos.

Ejecutar DaemonSets en todos los nodos

Puede que quieras ejecutar DaemonSets en todos los nodos, incluso en los que tengan taints aplicados. Por ejemplo, algunos agentes de registro y monitorización deben ejecutarse en todos los nodos del clúster. Puedes configurar esos DaemonSets para que ignoren las intolerancias de los nodos de forma que GKE coloque esas cargas de trabajo en todos los nodos.

Para ejecutar DaemonSets en todos los nodos de tu clúster, incluidos los nodos de GPU, añade 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

Sustituye IMAGE_PATH por la ruta a la imagen del contenedor.

Para ejecutar DaemonSets en nodos de GPU específicos de tu clúster, añade 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

Sustituye GPU_TYPE por el tipo de GPU de los nodos de destino. Puede ser una de las siguientes:

  • nvidia-gb200: NVIDIA GB200 (versión preliminar)
  • nvidia-b200: NVIDIA B200 (180 GB)
  • nvidia-h200-141gb: NVIDIA H200 (141 GB)
  • nvidia-h100-mega-80gb: NVIDIA H100 Mega (80 GB)
  • nvidia-h100-80gb: NVIDIA H100 (80 GB)
  • nvidia-a100-80gb: NVIDIA A100 (80 GB)
  • nvidia-tesla-a100: NVIDIA A100 (40 GB)
  • nvidia-l4: NVIDIA L4
  • nvidia-tesla-t4: NVIDIA T4
Si usas GKE Sandbox, puedes hacer lo siguiente:

  • nvidia-gb200: NVIDIA GB200 (versión preliminar)
  • nvidia-b200: NVIDIA B200 (180 GB) (versión preliminar)
  • nvidia-h200-141gb: NVIDIA H200 (141 GB) (vista previa)
  • nvidia-h100-mega-80gb: NVIDIA H100 Mega (80 GB)
  • nvidia-h100-80gb: NVIDIA H100 (80 GB)
  • nvidia-a100-80gb: NVIDIA A100 (80 GB)
  • nvidia-tesla-a100: NVIDIA A100 (40 GB)
  • nvidia-l4: NVIDIA L4
  • nvidia-tesla-t4: NVIDIA T4
Para obtener más información, consulta Compatibilidad con modelos de GPU.

Casos prácticos de GPUs en Autopilot

Puedes asignar GPUs a contenedores en pods de Autopilot para facilitar cargas de trabajo como las siguientes:

  • Inferencia de aprendizaje automático
  • Entrenamiento de aprendizaje automático
  • Renderizado

Cantidades de GPU admitidas

Cuando solicites GPUs en la especificación de tu pod, debes usar las siguientes cantidades en función del tipo de GPU:

Cantidades de GPU
NVIDIA L4
nvidia-l4		 1, 2, 4, 8
NVIDIA T4
nvidia-tesla-t4		 1, 2, 4
NVIDIA A100 (40 GB)
nvidia-tesla-a100		 1, 2, 4, 8, 16
NVIDIA A100 (80 GB)
nvidia-a100-80gb		 1, 2, 4, 8
NVIDIA H100 (80 GB)
nvidia-h100-80gb		 1, 2, 4, 8
NVIDIA H100 Mega (80 GB)
nvidia-h100-mega-80gb		 8
NVIDIA H200 (141 GB)
nvidia-h200-141gb		 8
NVIDIA B200 (180 GB)
nvidia-b200		 8

Monitorizar el rendimiento de la carga de trabajo de los nodos de GPU

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

  • Ciclo de trabajo (container/accelerator/duty_cycle): Porcentaje del tiempo durante el último periodo de muestreo (10 segundos) en el que el acelerador ha estado procesando activamente. 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.

Estas métricas se aplican a nivel de contenedor (container/accelerator) y no se recogen en los contenedores programados en una GPU que usa el tiempo compartido de la GPU o NVIDIA MPS.

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

Ver métricas de uso de cargas de trabajo

Puedes ver las métricas de uso de GPU de tus cargas de trabajo en el panel de control Cargas de trabajo de la Google Cloud consola.

Para ver el uso de GPU de tu carga de trabajo, sigue estos pasos:

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

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

En el panel de control Cargas de trabajo se muestran gráficos sobre el uso y la capacidad de la memoria de la GPU, así como el ciclo de actividad de la GPU.

Ver métricas de NVIDIA Data Center GPU Manager (DCGM)

Puedes recoger y visualizar métricas de NVIDIA DCGM mediante Google Cloud Managed Service para Prometheus. En el caso de los clústeres de Autopilot, GKE instala los controladores. En los clústeres estándar, debes instalar los controladores de NVIDIA.

Para obtener instrucciones sobre cómo implementar el paquete DCGM gestionado por GKE, consulta el artículo Recoger y ver métricas de NVIDIA Data Center GPU Manager (DCGM).

Siguientes pasos