Ejecuta GPU de varias instancias

En esta página, se proporcionan instrucciones para particionar una unidad de procesamiento de gráficos (GPU) de NVIDIA A100 o H100 para compartir una sola GPU en varios contenedores en Google Kubernetes Engine (GKE).

En esta página, se da por sentado que estás familiarizado con los conceptos de Kubernetes, como pods, nodos, implementaciones, y espacios de nombres, y estás familiarizado con los conceptos de GKE como grupos de nodos, ajuste de escala automático y aprovisionamiento automático.

Introducción

Kubernetes asigna una GPU completa por contenedor, incluso si el contenedor solo necesita una fracción de la GPU para su carga de trabajo, lo que puede generar recursos desperdiciados y costos excesivos, sobre todo si usas GPU potentes de última generación. Para mejorar el uso de la GPU, las GPU de varias instancias te permiten particionar una sola GPU en hasta siete porciones. Cada porción se puede asignar a un contenedor en el nodo de forma independiente, para un máximo de siete contenedores por GPU. Las GPU de varias instancias proporcionan aislamiento de hardware entre las cargas de trabajo, y QoS coherente y predecible para todos los contenedores que se ejecutan en la GPU.

En el caso de las aplicaciones CUDA®, las GPU de varias instancias son muy transparentes. Cada partición de GPU aparece como un recurso de GPU normal, y el modelo de programación permanece sin cambios.

Para obtener más información sobre las GPU de varias instancias, consulta la guía del usuario de GPU de varias instancias de NVIDIA.

GPU compatibles

Los siguientes tipos de GPU admiten GPU de varias instancias:

  • NVIDIA A100 (40 GB)
  • NVIDIA A100 (80 GB)

  • NVIDIA H100 (80 GB)

Particiones de GPU de varias instancias

Las GPU A100 y H100 constan de siete unidades de procesamiento y ocho unidades de memoria, que se pueden particionar en instancias de GPU de diferentes tamaños. Los tamaños de partición de GPU usan la siguiente sintaxis: [compute]g.[memory]gb. Por ejemplo, un tamaño de partición de GPU de 1g.5gb hace referencia a una instancia de GPU con una unidad de procesamiento (1/7 de multiprocesadores de transmisión en la GPU) y una unidad de memoria (5 GB). El tamaño de la partición para las GPUs se puede especificar cuando implementas una carga de trabajo de Autopilot o cuando creas un clúster de Standard.

En la tabla de particiones de la guía del usuario de GPU de varias instancias de NVIDIA, se enumeran todos los diferentes tamaños de partición de GPU, junto con la cantidad de recursos de procesamiento y memoria disponibles en cada partición de GPU. En la tabla también se muestra la cantidad de instancias de GPU por cada tamaño de partición que se puede crear en la GPU.

En la siguiente tabla, se enumeran los tamaños de partición que admite GKE:

Tamaño de partición Instancias de GPU
GPU: NVIDIA A100 (40GB) (nvidia-tesla-a100)
1g.5gb 7
2g.10gb 3
3g.20gb 2
7g.40gb 1
GPU: NVIDIA A100 (80GB) (nvidia-a100-80gb)
1g.10gb 7
2g.20gb 3
3g.40gb 2
7g.80gb 1
GPU: NVIDIA H100 (80 GB) (nvidia-h100-80gb)
1g.10gb 7
1g.20gb 4
2g.20gb 3
3g.40gb 2
7g.80gb 1

Cada GPU en cada nodo dentro de un grupo de nodos se particiona de la misma manera. Por ejemplo, considera un grupo de nodos con dos nodos, cuatro GPU en cada nodo, y un tamaño de partición de 1g.5gb. GKE crea siete particiones de tamaño 1g.5gb en cada GPU. Debido a que hay cuatro GPU en cada nodo, habrá 28 particiones de GPU de 1g.5gb disponibles en cada nodo. Debido a que hay dos nodos en el grupo de nodos, un total de 56 particiones de GPU de 1g.5gb están disponibles en todo el grupo de nodos.

Para crear un clúster de GKE Standard con más de un tipo de partición de GPU, debes crear múltiples grupos de nodos. Por ejemplo, si quieres nodos con particiones de GPU de 1g.5gb y 3g.20gb en un clúster, debes crear dos grupos de nodos: uno con el tamaño de partición de GPU establecido en 1g.5gb y otro en 3g.20gb.

Un clúster de Autopilot de GKE crea nodos de forma automática con la configuración de partición correcta cuando creas cargas de trabajo que requieren diferentes tamaños de partición.

Cada nodo está etiquetado con el tamaño de las particiones de GPU disponibles en el nodo. Este etiquetado permite que las cargas de trabajo se orienten a los nodos con el tamaño de partición de GPU necesario. Por ejemplo, en un nodo con instancias de GPU de 1g.5gb, el nodo se etiqueta de la siguiente manera:

cloud.google.com/gke-gpu-partition-size=1g.5gb

Cómo funciona

Para usar GPU de varias instancias, realizas las siguientes tareas:

  1. Crea un clúster con GPU de varias instancias habilitadas.
  2. Instala controladores de forma manual.
  3. Verifica cuántos recursos de GPU hay en el nodo.
  4. Implementa contenedores con GPUs de varias instancias.

Precios

Las GPU de varias instancias son exclusivas de las GPU A100 y H100, y están sujetas a los precios correspondientes de las GPU, además de cualquier otro producto que se use para ejecutar tus cargas de trabajo. Solo puedes conectar GPU completas a los nodos de tu clúster para la partición. Para obtener información sobre los precios de GPU, consulta la página Precios de GPU.

Limitaciones

  • No se recomienda usar particiones de GPU de varias instancias con GKE para cargas de trabajo no confiables.
  • El ajuste de escala automático y el aprovisionamiento automático de las particiones de GPU son totalmente compatibles con la versión 1.20.7-gke.400 o posterior de GKE. En versiones anteriores, solo los grupos de nodos con al menos un nodo se pueden escalar de forma automática en función de la demanda para tamaños de partición de GPU específicos de cargas de trabajo.
  • Las métricas de uso de GPU (por ejemplo, duty_cycle) no están disponibles para instancias de GPU.
  • Las instancias múltiples dividen una GPU física en instancias discretas, cada una de las cuales está aislada de las demás en el nivel de hardware. Un contenedor que usa una instancia de GPU de varias instancias solo puede acceder a los recursos de CPU y memoria disponibles para esa instancia.
  • Un pod solo puede consumir hasta una instancia de GPU de varias instancias.

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.
  • En Autopilot, las GPUs de varias instancias son compatibles con GKE versión 1.29.3-gke.1093000 y versiones posteriores.
  • Debes tener suficiente cuota de GPU de NVIDIA A100. Consulta Solicita un aumento de la cuota.
  • Si deseas usar GPU de varias instancias con Autopilot, puedes obtener más información sobre el uso de GPU con Autopilot en Implementa cargas de trabajo de GPU en Autopilot.
  • GKE asigna la clase de procesamiento Accelerator a todas las cargas de trabajo de GPU de varias instancias en clústeres de Autopilot.

Crea un clúster con GPU de varias instancias habilitadas

Si usas GKE Standard, debes habilitar las GPU de varias instancias en el clúster. Los clústeres de Autopilot que ejecutan la versión 1.29.3-gke.1093000 y, luego, habilitan las GPU de varias instancias de forma predeterminada. Para usar GPU de varias instancias en Autopilot, en este documento, consulta la sección Implementa contenedores con GPU de varias instancias.

Cuando creas un clúster Standard con GPU de varias instancias, debes especificar gpuPartitionSize junto con acceleratorType y acceleratorCount. El acceleratorType debe ser nvidia-tesla-a100, nvidia-a100-80gb o nvidia-h100-80gb.

En el siguiente ejemplo, se muestra cómo crear un clúster de GKE con un nodo y siete particiones de GPU de tamaño 1g.5gb en el nodo. En los demás pasos de esta página, se usa un tamaño de partición de GPU de 1g.5gb, que crea siete particiones en cada GPU. También puedes usar cualquiera de los tamaños de partición de GPU admitidos mencionados anteriormente.

Puedes usar Google Cloud CLI o Terraform.

gcloud

Crea un clúster con GPU de varias instancias habilitadas:

gcloud container clusters create CLUSTER_NAME  \
    --project=PROJECT_ID  \
    --zone ZONE  \
    --cluster-version=CLUSTER_VERSION  \
    --accelerator type=nvidia-tesla-a100,count=1,gpu-partition-size=1g.5gb,gpu-driver-version=DRIVER_VERSION  \
    --machine-type=a2-highgpu-1g  \
    --num-nodes=1

Reemplaza lo siguiente:

  • CLUSTER_NAME: Es el nombre del clúster nuevo.
  • PROJECT_ID: El ID del proyecto de Google Cloud.
  • ZONE: Es la zona de procesamiento del plano de control del clúster.
  • CLUSTER_VERSION: La versión debe ser 1.19.7-gke.2503 o posterior.
  • DRIVER_VERSION: Es la versión del controlador NVIDIA que se instalará. Puede ser uno de los datos siguientes:
    • default: Instala la versión predeterminada del controlador para tu versión de GKE.
    • latest: Instala la última versión del controlador disponible para tu versión de GKE. Disponible solo para los nodos que usan Container-Optimized OS.
    • disabled: Omite la instalación automática del controlador. Debes instalar un controlador de forma manual después de crear el clúster. Si omites gpu-driver-version, esta es la opción predeterminada.

Terraform

Para crear un clúster con GPU de varias instancias habilitadas mediante Terraform, consulta el siguiente ejemplo:

resource "google_container_cluster" "default" {
  name               = "gke-standard-zonal-gpu"
  location           = "us-central1-a"
  initial_node_count = 1

  node_config {
    guest_accelerator {
      type  = "nvidia-tesla-t4"
      count = 1
      gpu_driver_installation_config {
        gpu_driver_version = "LATEST"
      }
    }
    machine_type = "n1-standard-2"
  }

  # Set `deletion_protection` to `true` will ensure that one cannot
  # accidentally delete this instance by use of Terraform.
  deletion_protection = false
}

Si deseas obtener más información sobre el uso de Terraform, consulta Compatibilidad con Terraform para GKE.

Conéctate al clúster

Configura kubectl para conectarte al clúster recién creado:

gcloud container clusters get-credentials CLUSTER_NAME

Instalar controladores

Si decides inhabilitar la instalación automática del controlador cuando creas el clúster o si ejecutas una versión de GKE anterior a la 1.27.2-gke.1200, debes instalar de forma manual un controlador NVIDIA compatible una vez que se completa la creación. Las GPU de varias instancias requieren una versión de controlador NVIDIA 450.80.02 o posterior.

Después de instalar el controlador, se habilitará el modo de GPU de varias instancias. Si instalaste controladores de forma automática, tus nodos se reiniciarán cuando el complemento del dispositivo de GPU comience a crear particiones de GPU. Si instalaste controladores de forma manual, tus nodos se reiniciarán cuando se complete la instalación del controlador. Es probable que el reinicio demore unos minutos en completarse.

Verifica cuántos recursos de GPU hay en el nodo

Ejecuta el siguiente comando para verificar que la capacidad y el recuento asignable de los recursos nvidia.com/gpu sean 7:

kubectl describe nodes

Aquí hay un resultado de ejemplo del comando:

...
Capacity:
  ...
  nvidia.com/gpu:             7
Allocatable:
  ...
  nvidia.com/gpu:             7

Implementa contenedores con GPU de varias instancias

Puedes implementar hasta un contenedor por dispositivo de GPU de varias instancias en el nodo. En este ejemplo, con un tamaño de partición de 1g.5gb, hay siete particiones de GPU de varias instancias disponibles en el nodo. Como resultado, puedes implementar hasta siete contenedores que soliciten GPU en este nodo.

  1. Este es un ejemplo que inicia el contenedor cuda:11.0.3-base-ubi7 y ejecuta nvidia-smi para imprimir el UUID de la GPU dentro del contenedor. En este ejemplo, hay siete contenedores y cada contenedor recibe una partición de GPU. En este ejemplo, también se establece el selector de nodos de cloud.google.com/gke-gpu-partition-size para orientar los nodos con particiones de GPU de 1g.5gb.

    Autopilot

          cat <<EOF | kubectl apply -f -
      apiVersion: apps/v1
      kind: Deployment
      metadata:
        name: cuda-simple
      spec:
        replicas: 7
        selector:
          matchLabels:
            app: cuda-simple
        template:
          metadata:
            labels:
              app: cuda-simple
          spec:
            nodeSelector:
              cloud.google.com/gke-gpu-partition-size: 1g.5gb
              cloud.google.com/gke-accelerator: nvidia-tesla-a100
              cloud.google.com/gke-accelerator-count: "1"
            containers:
            - name: cuda-simple
              image: nvidia/cuda:11.0.3-base-ubi7
              command:
              - bash
              - -c
              - |
                /usr/local/nvidia/bin/nvidia-smi -L; sleep 300
              resources:
                limits:
                  nvidia.com/gpu: 1
      EOF

    Este manifiesto hace lo siguiente:

    • Solicita el tipo de GPU nvidia-tesla-a100 mediante la configuración del selector de nodos cloud.google.com/gke-accelerator.
    • Divide la GPU en el tamaño de partición 1g.5gb.
    • Conecta una sola GPU al nodo mediante la configuración del selector de nodos cloud.google.com/gke-accelerator-count.

    Estándar

          cat <<EOF | kubectl apply -f -
      apiVersion: apps/v1
      kind: Deployment
      metadata:
        name: cuda-simple
      spec:
        replicas: 7
        selector:
          matchLabels:
            app: cuda-simple
        template:
          metadata:
            labels:
              app: cuda-simple
          spec:
            nodeSelector:
              cloud.google.com/gke-gpu-partition-size: 1g.5gb
            containers:
            - name: cuda-simple
              image: nvidia/cuda:11.0.3-base-ubi7
              command:
              - bash
              - -c
              - |
                /usr/local/nvidia/bin/nvidia-smi -L; sleep 300
              resources:
                limits:
                  nvidia.com/gpu: 1
      EOF

    Este manifiesto hace lo siguiente:

    • Solicita una sola GPU con un tamaño de partición de 1g.5gb.

  2. Verifica que los siete Pods estén en ejecución:

    kubectl get pods

    Aquí hay un resultado de ejemplo del comando:

    NAME                           READY   STATUS    RESTARTS   AGE
cuda-simple-849c47f6f6-4twr2   1/1     Running   0          7s
cuda-simple-849c47f6f6-8cjrb   1/1     Running   0          7s
cuda-simple-849c47f6f6-cfp2s   1/1     Running   0          7s
cuda-simple-849c47f6f6-dts6g   1/1     Running   0          7s
cuda-simple-849c47f6f6-fk2bs   1/1     Running   0          7s
cuda-simple-849c47f6f6-kcv52   1/1     Running   0          7s
cuda-simple-849c47f6f6-pjljc   1/1     Running   0          7s

  3. Visualiza los registros para ver el UUID de la GPU con el nombre de un pod del comando anterior:

    kubectl logs cuda-simple-849c47f6f6-4twr2

    Aquí hay un resultado de ejemplo del comando:

    GPU 0: A100-SXM4-40GB (UUID: GPU-45eafa61-be49-c331-f8a2-282736687ab1)
  MIG 1g.5gb Device 0: (UUID: MIG-GPU-45eafa61-be49-c331-f8a2-282736687ab1/11/0)

¿Qué sigue?