Ejecuta GPU en grupos de nodos de GKE Standard


En esta página, se muestra cómo usar aceleradores de hardware de unidad de procesamiento de gráficos (GPU) de NVIDIA® en los nodos de tus clústeres de Google Kubernetes Engine (GKE). Para obtener más información sobre las GPU en GKE, consulta Acerca de las GPU en GKE.

También puedes usar las GPU directamente en tus Pods de Autopilot. Para obtener instrucciones, consulta Implementa cargas de trabajo de GPU en Autopilot.

Descripción general

Con GKE, puedes creargrupos de nodos equipados con GPU NVIDIA Tesla® K80, P100, P4, V100, T4, L4 y A100. Las GPU brindan potencia de procesamiento para impulsar tareas de aprendizaje profundo, como reconocimiento de imágenes, procesamiento de lenguaje natural y otras tareas con gran demanda de procesamiento, como la transcodificación de videos y el procesamiento de imágenes.

También puedes usar las GPU con VM Spot si tus cargas de trabajo pueden tolerar interrupciones frecuentes en los nodos. Usar las Spot VM reduce el precio de la ejecución de GPU. Para obtener más información, consulta Cómo usar VMs Spot con grupos de nodos de GPU.

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 la CLI de gcloud. Si ya instalaste la CLI de gcloud, ejecuta gcloud components update para obtener la versión más reciente.

Requisitos

Las GPU en GKE tienen los siguientes requisitos:

  • Versión de Kubernetes: Para los grupos de nodos que usan la imagen de nodo Container-Optimized OS, los nodos de GPU están disponibles en la versión 1.9 o superior de GKE. Para los grupos de nodos que usan la imagen de nodo de Ubuntu, los nodos de GPU están disponibles en GKE versión 1.11.3 o superior.
  • Cuota de GPU: Debes tener Cuota de GPU de Compute Engine en la zona deseada antes de poder crear nodos de GPU. A fin de asegurarte de que cuentas con suficiente cuota de GPU para tu proyecto, consulta Cuotas en la consola de Google Cloud.

    Si necesitas una cuota de GPU adicional, debes solicitar una cuota de GPU en la consola de Google Cloud. Si tienes una cuenta de facturación establecida, tu proyecto debería recibir de forma automática la cuota después de enviar la solicitud de esta.

  • Controladores de GPU de NVIDIA: Cuando creas un clúster o un grupo de nodos, puedes indicarle a GKE que instale de forma automática una versión de controlador basada en tu versión de GKE. Si no le indicas a GKE que instale de forma automática los controladores de GPU, debes instalar los controladores de forma manual.

  • GPU A100: Las GPU A100 solo son compatibles con los tipos de máquinas A2 y requieren la versión 1.18.6-gke.3504 de GKE o alguna posterior. Debes asegurarte de tener suficiente cuota para que el tipo de máquina A2 subyacente pueda usar la GPU A100.

  • GPU L4:

    • No se admiten versiones de GKE anteriores a 1.22.17-gke.5400.
    • La versión de GKE que elijas debe incluir la versión 525 o posterior del controlador NVIDIA en Container-Optimized OS. Si la versión del controlador 525 o posterior no es la versión predeterminada o más reciente en tu versión de GKE, debes instalar de forma manual un controlador compatible en tus nodos.

Limitaciones

Antes de usar las GPU en GKE, ten en cuenta las siguientes limitaciones:

  • No puedes agregar las GPU a grupos de nodos existentes.
  • Los nodos de GPU no se pueden migrar en vivo durante los eventos de mantenimiento.
  • El tipo de GPU que puedes usar depende de la serie de máquinas, de la siguiente manera:

    Debes asegurarte de tener suficiente cuota en tu proyecto para la serie de máquinas que corresponda al tipo y la cantidad de GPU seleccionados.

  • Las GPU no son compatibles con los grupos de nodos de Windows Server.

  • En las versiones 1.22 a 1.25 de GKE, el escalador automático del clúster solo admite el escalamiento vertical básico de nodos con GPU L4. Esta limitación no se aplica a la versión 1.26 de GKE y posteriores.

Disponibilidad

Las GPU están disponibles en regiones y zonas específicas. Cuando solicites cuota de GPU, debes tener en cuenta las regiones en las que quieres ejecutar tus clústeres.

Para obtener una lista completa de las regiones y zonas aplicables, consulta GPU en Compute Engine.

También puedes ver las GPU disponibles en tu zona mediante la CLI de Google Cloud. Para obtener una lista de todos los tipos de aceleradores de GPU compatibles en cada zona, ejecuta el siguiente comando:

gcloud compute accelerator-types list

Precios

Para obtener información sobre los precios de GPU, consulta la tabla de precios en la página de GPU de Google Cloud.

Cuota de GPU

Tu cuota de GPU es la cantidad total de GPU que puedes ejecutar en tu proyecto de Google Cloud. Para crear clústeres con GPU, tu proyecto debe contar con una cuota de GPU suficiente.

Tu cuota de GPU debe ser, al menos, equivalente a la cantidad total de GPU que quieres ejecutar en tu clúster. Si habilitas el ajuste de escala automático del clúster, debes solicitar una cuota de GPU que sea, al menos, equivalente a la cantidad máxima de nodos de tu clúster multiplicado por la cantidad de GPU por nodo.

Por ejemplo, si creas un clúster con tres nodos que ejecutan dos GPU por nodo, tu proyecto necesita, al menos, seis cuotas de GPU.

Solicita la cuota de GPU

Para solicitar una cuota de GPU, usa la consola de Google Cloud. Para obtener más información sobre cómo solicitar cuotas, consulta las cuotas de GPU en la documentación de Compute Engine.

Para buscar una cuota de GPU y enviar una solicitud de cuota, usa la consola de Google Cloud:

  1. Ve a la página IAM y administración en la consola de Google Cloud.

    Ir a Cuotas

  2. En la casilla Filtro, haz lo siguiente:

    1. Selecciona la propiedad de Cuota, ingresa el nombre del modelo de GPU y presiona Intro.
    2. (Opcional) Para aplicar filtros más avanzados para limitar los resultados, selecciona la propiedad Dimensiones (p. ej., ubicaciones), agrega el nombre de la región o zona que usas y presiona Intro.
  3. En la lista de cuotas de GPU, selecciona la que deseas cambiar.

  4. Haz clic en Editar cuotas. Se abrirá un formulario de solicitud.

  5. Completa el campo Nuevo límite de cuota para cada solicitud de cuotas.

  6. Completa el campo Descripción de la solicitud con los detalles sobre tu solicitud.

  7. Haz clic en Siguiente.

  8. En el cuadro de diálogo Confirmación de anulación, haz clic en Confirmar.

  9. En la pantalla Detalles de contacto, ingresa tu nombre y un número de teléfono que los responsables de aprobación podrán usar para completar la solicitud de cambio de cuota.

  10. Haz clic en Enviar solicitud.

  11. Recibirás un correo electrónico de confirmación para realizar un seguimiento del cambio de cuota.

Ejecuta GPU

Para ejecutar GPUs en clústeres de GKE Standard, crea un grupo de nodos con GPUs conectadas. Cuando agregas un grupo de nodos de GPU a un clúster existente que ya ejecuta un grupo de nodos sin GPU, GKE ejecuta taints de forma automática en los nodos de GPU con el siguiente taint de nodo:

  • Clave: nvidia.com/gpu
  • Efecto: NoSchedule

Además, GKE aplica de forma automática las tolerancias correspondientes a los pods que solicitan GPU mediante la ejecución del controlador de admisión ExtendedResourceToleration.

Esto provoca que en los nodos de GPU se programen solo los pods que solicitan GPU, lo que permite que el ajuste de escala automático sea más eficaz: tus nodos de GPU pueden escalar con rapidez si no hay suficientes pods que soliciten GPU.

Para mejorar la rentabilidad, la confiabilidad y la disponibilidad de las GPU en GKE, recomendamos las siguientes acciones:

  • Crea grupos de nodos de GPU independientes. En cada grupo de nodos, limita la ubicación del nodo a las zonas en las que están disponibles las GPU.
  • Habilita el ajuste de escala automático en cada grupo de nodos.
  • Usa clústeres regionales para mejorar la disponibilidad mediante la replicación del plano de control de Kubernetes en las zonas de la región.
  • Indica a GKE que instale de forma automática los controladores de GPU predeterminados o más recientes en los grupos de nodos para que no tengas que instalar y administrar las versiones de los controladores de forma manual.

Crea un grupo de nodos de GPU

Para crear un grupo de nodos de GPU diferente en un clúster existente, puedes usar la consola de Google Cloud o la CLI de Google Cloud. También puedes usar Terraform para aprovisionar tus clústeres de GKE y el grupo de nodos de GPU.

Si usas la CLI de gcloud o Terraform, puedes indicar a GKE que instale de forma automática la versión de controlador de NVIDIA predeterminada o más reciente que corresponda a la versión de Container-Optimized OS. Si usas la consola de Google Cloud, debes instalar los controladores de forma manual después de crear el grupo de nodos.

gcloud

Para crear un grupo de nodos con GPU en un clúster, ejecuta el siguiente comando:

gcloud container node-pools create POOL_NAME \
  --accelerator type=GPU_TYPE,count=AMOUNT,gpu-driver-version=DRIVER_VERSION \
  [--machine-type MACHINE_TYPE] \
  --region COMPUTE_REGION --cluster CLUSTER_NAME \
  --node-locations COMPUTE_ZONE1[,COMPUTE_ZONE2] \
  [--num-nodes NUM_NODES] \
  [--enable-autoscaling \
   --min-nodes MIN_NODES \
   --max-nodes MAX_NODES]

Reemplaza lo siguiente:

  • POOL_NAME: Es el nombre que eliges para el grupo de nodos.
  • GPU_TYPE es el tipo de GPU. Puede ser uno de los siguientes:
    • nvidia-tesla-k80
    • nvidia-tesla-p100
    • nvidia-tesla-p4
    • nvidia-tesla-v100
    • nvidia-tesla-t4
    • nvidia-tesla-a100
    • nvidia-a100-80gb
    • nvidia-l4
  • DRIVER_VERSION: Es la versión del controlador NVIDIA que se instalará. Puede ser una de los 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 grupo de nodos. Si omites gpu-driver-version, esta es la opción predeterminada.
  • AMOUNT: Es la cantidad de GPU que se deben adjuntar a los nodos del grupo de nodos.

  • MACHINE_TYPE: es el tipo de máquina de Compute Engine para tus nodos. Obligatorio si GPU_TYPE es nvidia-tesla-a100 o nvidia-a100-80gb, que solo puede usar un tipo de máquina A2 o si GPU_TYPE es nvidia-l4, que solo puede usar un tipo de máquina G2. Para todas las demás GPU, esta marca es opcional.

  • COMPUTE_REGION: Es la región de Compute Engine del clúster, como us-central1. Elige una región que tenga al menos una zona en la que estén disponibles las GPU solicitadas.

  • CLUSTER_NAME: Es el nombre del clúster en el que se debe crear el grupo de nodos.

  • COMPUTE_ZONE1,COMPUTE_ZONE2,[...]: Las zonas específicas en las que GKE crea los nodos de GPU. Las zonas deben estar en la misma región que el clúster, especificada por la marca --region. Los tipos de GPU que definas deben estar disponibles en cada zona seleccionada. Te recomendamos que siempre uses la marca --node-locations cuando crees el grupo de nodos para especificar la zona o las zonas que contienen las GPU solicitadas.

  • NUM_NODES: la cantidad inicial de nodos que se crearán.

  • MIN_NODES: la cantidad mínima de nodos para cada zona en el grupo de nodos en cualquier momento. Este valor es relevante solo si se usa la marca --enable-autoscaling.

  • MAX_NODES: la cantidad máxima de nodos para cada zona en el grupo de nodos en cualquier momento. Este valor es relevante solo si se usa la marca --enable-autoscaling.

Por ejemplo, con el siguiente comando, se crea un grupo de nodos con ajuste de escala automático con alta disponibilidad, p100, con dos GPU P100 para cada nodo, en el clúster regional p100-cluster. GKE instala de forma automática los controladores predeterminados en esos nodos.

gcloud container node-pools create p100 \
  --accelerator type=nvidia-tesla-p100,count=2,gpu-driver-version=default \
  --region us-central1 --cluster p100-cluster \
  --node-locations us-central1-c \
  --num-nodes 3 --min-nodes 0 --max-nodes 5 --enable-autoscaling

Consola

Para crear un grupo de nodos con GPU, sigue estos pasos:

  1. Ve a la página de Google Kubernetes Engine en la consola de Google Cloud.

    Ir a Google Kubernetes Engine

  2. En la lista de clústeres, haz clic en el nombre del clúster que deseas modificar.

  3. Haz clic en Agregar grupo de nodos.

  4. De forma opcional, en la página Detalles del grupo de nodos, selecciona la casilla de verificación Habilitar ajuste de escala automático.

  5. Configura tu grupo de nodos como desees.

  6. Desde el panel de navegación, selecciona Nodos.

  7. En Configuración de la máquina, haz clic en GPU.

  8. Selecciona un Tipo de GPU y una Cantidad de GPU que se ejecutará en cada nodo.

  9. Lee la advertencia y selecciona Comprendo las limitaciones.

  10. Haz clic en Crear.

Debes instalar los controladores de GPU de forma manual después de crear el grupo de nodos. En este documento, consulta Instala controladores de GPU de NVIDIA de forma manual.

Terraform

Puedes crear un clúster regional con Terraform mediante GPU mediante un módulo de Terraform.

  1. Para configurar las variables de Terraform, incluye el siguiente bloque en el archivo variables.tf:

    variable "project_id" {
      default     = PROJECT_ID
      description = "the gcp_name_short project where GKE creates the cluster"
    }
    
    variable "region" {
      default     = CLUSTER_REGION
      description = "the gcp_name_short region where GKE creates the cluster"
    }
    
    variable "zone" {
      default     = "COMPUTE_ZONE1,COMPUTE_ZONE2"
      description = "the GPU nodes zone"
    }
    
    variable "cluster_name" {
      default     = "CLUSTER_NAME"
      description = "the name of the cluster"
    }
    
    variable "gpu_type" {
      default     = "GPU_TYPE"
      description = "the GPU accelerator type"
    }
    
    variable "gpu_driver_version" {
      default = "DRIVER_VERSION"
      description = "the NVIDIA driver version to install"
    }
    

    Reemplaza lo siguiente:

    • PROJECT_ID: el ID de tu proyecto
    • CLUSTER_NAME: el nombre del clúster de GKE.
    • CLUSTER_REGION: es la región de procesamiento para el clúster.
    • COMPUTE_ZONE1,COMPUTE_ZONE2,[...]: Las zonas específicas en las que GKE crea los nodos de GPU. Las zonas deben estar en la misma región que especifica la variable region. Estas zonas deben tener los tipos de GPU que definiste disponibles. Para saber qué zonas cuentan con GPU, consulta Disponibilidad. Debes usar la variable node_locations cuando crees el grupo de nodos de GPU para especificar la zona o las zonas que contienen las GPUs solicitadas.
    • GPU_TYPE es el tipo de GPU. Puede ser uno de los siguientes:

      • nvidia-tesla-k80
      • nvidia-tesla-p100
      • nvidia-tesla-p4
      • nvidia-tesla-v100
      • nvidia-tesla-t4
      • nvidia-tesla-a100
      • nvidia-a100-80gb
      • nvidia-l4
    • DRIVER_VERSION: es la versión del controlador de GPU para que GKE se instale de forma automática. Este campo es opcional. Se admiten los siguientes valores:

      • INSTALLATION_DISABLED: inhabilita la instalación automática del controlador de GPU. Debes instalar controladores de forma manual para ejecutar tus GPU.
      • DEFAULT: Instala de forma automática la versión de controlador predeterminada para la versión del sistema operativo del nodo.
      • LATEST: Instala de forma automática la última versión del controlador disponible para tu versión del SO del nodo.

    Si omites este campo, GKE no instala de forma automática un controlador. Este campo no es compatible con los grupos de nodos que usan el suministro automático de nodos. Para instalar un controlador de forma manual, consulta Instala controladores de GPU de NVIDIA de forma manual en este documento.

  2. Agrega el siguiente bloque a la configuración de Terraform:

    provider "google" {
      project = var.project_id
      region  = var.region
    }
    
    resource "google_container_cluster" "ml_cluster" {
      name     = var.cluster_name
      location = var.region
      node_locations = [var.zone]
    }
    
    resource "google_container_node_pool" "gpu_pool" {
      name       = google_container_cluster.ml_cluster.name
      location   = var.region
      cluster    = google_container_cluster.ml_cluster.name
      node_count = 3
    
      autoscaling {
        total_min_node_count = "1"
        total_max_node_count = "5"
      }
    
      management {
        auto_repair  = "true"
        auto_upgrade = "true"
      }
    
      node_config {
        oauth_scopes = [
          "https://www.googleapis.com/auth/logging.write",
          "https://www.googleapis.com/auth/monitoring",
          "https://www.googleapis.com/auth/devstorage.read_only",
          "https://www.googleapis.com/auth/trace.append",
          "https://www.googleapis.com/auth/service.management.readonly",
          "https://www.googleapis.com/auth/servicecontrol",
        ]
    
        labels = {
          env = var.project_id
        }
    
        guest_accelerator {
          type  = var.gpu_type
          count = 1
          gpu_driver_installation_config {
            gpu_driver_version = var.gpu_driver_version
          }
        }
    
        image_type   = "cos_containerd"
        machine_type = "n1-standard-1"
        tags         = ["gke-node", "${var.project_id}-gke"]
    
        disk_size_gb = "30"
        disk_type    = "pd-standard"
    
        metadata = {
          disable-legacy-endpoints = "true"
        }
      }
    }
    

Terraform llama a las APIs de Google Cloud para configurar un clúster nuevo con un grupo de nodos que use GPU. En un principio, el grupo de nodos tiene tres nodos y el ajuste de escala automático está habilitado. Para obtener más información sobre Terraform, consulta las especificaciones del recurso google_container_node_pool.

También puedes crear un clúster nuevo con GPU y especificar zonas con la marca --node-locations. Sin embargo, te recomendamos crear un grupo de nodos de GPU independiente en un clúster existente, como se muestra en esta sección.

Instala los controladores de GPU de NVIDIA de forma manual

Si elegiste inhabilitar la instalación automática del controlador de dispositivos cuando creaste un grupo de nodos de GPU o si usas una versión de GKE anterior a la versión mínima compatible para la instalación automática, debes instalar de forma manual un controlador de GPU de NVIDIA compatible en los nodos. Google proporciona un DaemonSet que puedes aplicar para instalar los controladores. En los nodos de GPU que usan Container-Optimized OS, también tienes la opción de seleccionar entre la versión predeterminada del controlador de GPU o una versión más reciente.

Te recomendamos que uses la instalación automática del controlador cuando sea posible; para ello, especifica la opción gpu-driver-version en la marca --accelerator cuando crees tu clúster de Standard. Si usaste el DaemonSet de instalación para instalar controladores de GPU de forma manual el 25 de enero de 2023 o antes, es posible que debas volver a aplicar el DaemonSet para obtener una versión que ignore los nodos que usan la instalación automática de controladores.

En las siguientes instrucciones, se muestra cómo instalar los controladores en Container-Optimized OS (COS) y nodos Ubuntu, y usar Terraform.

COS

Para implementar la instalación de DaemonSet y, luego, instalar la versión predeterminada del controlador de GPU, ejecuta el siguiente comando:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml

Como alternativa, ejecuta el siguiente comando para instalar la versión más reciente del controlador de GPU (consulta la tabla que aparece a continuación):

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded-latest.yaml

La instalación tarda varios segundos en completarse. Una vez instalado, el complemento del dispositivo de NVIDIA muestra la capacidad de la GPU a través de las API de Kubernetes.

Cada versión de la imagen de Container-Optimized OS tiene al menos una versión compatible del controlador de GPU de NVIDIA. Consulta las notas de la versión de los principales eventos importantes de LTS de Container-Optimized OS para conocer la versión predeterminada.

En la siguiente tabla, se muestran las versiones de controlador disponibles en cada versión de GKE:

Versión de GKE Controlador de NVIDIA
1.26 R470(predeterminado), R510 o R525
1.25 R470(predeterminado), R510 o R525
1.24 R470(predeterminado), R510 o R525
1.23 R450(predeterminado), R470, R510, o R525
1.22 R450(predeterminado), R470, R510, o R525
1.21 R450(predeterminado), R470 o R510
1.20 R450 (predeterminado), R470

Ubuntu

Para implementar la instalación de DaemonSet en todas las GPU, excepto las GPU de NVIDIA L4, ejecuta el siguiente comando:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/ubuntu/daemonset-preloaded.yaml

La instalación tarda varios segundos en completarse. Una vez instalado, el complemento del dispositivo de NVIDIA muestra la capacidad de la GPU a través de las API de Kubernetes.

Para las GPU NVIDIA L4, instala el controlador R525 con el siguiente comando:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/ubuntu/daemonset-preloaded-R525.yaml

En la siguiente tabla, se muestran las versiones de controlador disponibles en cada versión de GKE:

Versión de GKE Controlador de NVIDIA
1.27 R470
1.26 R470
1.25 R470
1.24 R470
1.23 R470
1.22 R450
1.21 R450
1.20 R450

Terraform

Puedes usar Terraform para instalar la versión predeterminada del controlador de GPU según el tipo de nodos. En ambos casos, debes configurar el tipo de recurso kubectl_manifest de Terraform.

  • Para instalar DaemonSet en COS, agrega el siguiente bloque en la configuración de Terraform:

      data "http" "nvidia_driver_installer_manifest" {
        url = "https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml"
      }
    
      resource "kubectl_manifest" "nvidia_driver_installer" {
        yaml_body = data.http.nvidia_driver_installer_manifest.body
      }
    
  • Para instalar DaemonSet en Ubuntu, agrega el siguiente bloque en la configuración de Terraform:

      data "http" "nvidia_driver_installer_manifest" {
        url = "https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/ubuntu/daemonset-preloaded.yaml"
      }
    
      resource "kubectl_manifest" "nvidia_driver_installer" {
        yaml_body = data.http.nvidia_driver_installer_manifest.body
      }
    

Usa el aprovisionamiento automático de nodos con GPU

De forma predeterminada, cuando usas el aprovisionamiento automático de nodos con GPUs, los grupos de nodos suministrados automáticamente no tienen suficientes permisos para instalar los controladores. Para otorgar los permisos necesarios, modifica los alcances predeterminados del suministro automático de nodos a fin de agregar logging.write, monitoring, devstorage.read_only y compute, como en el ejemplo siguiente:

gcloud container clusters update CLUSTER_NAME --enable-autoprovisioning \
    --min-cpu=1 --max-cpu=10 --min-memory=1 --max-memory=32 \
    --autoprovisioning-scopes=https://www.googleapis.com/auth/logging.write,https://www.googleapis.com/auth/monitoring,https://www.googleapis.com/auth/devstorage.read_only,https://www.googleapis.com/auth/compute

Para obtener más información sobre el suministro automático, consulta Usa el suministro automático de nodos.

Configura pods para consumir las GPU

Usa un límite de recursos a fin de configurar la cantidad de GPU que consumen los pods. Debes especificar un límite de recursos en una especificación de pod con los pares clave-valor siguientes:

  • Clave: nvidia.com/gpu
  • Valor: cantidad de GPU que se consumirán

A continuación, se muestra un ejemplo de una especificación de pod que consume GPU:

apiVersion: v1
kind: Pod
metadata:
  name: my-gpu-pod
spec:
  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: 2

Consume varios tipos de GPU

Si deseas usar varios tipos de aceleradores de GPU por clúster, debes crear varios grupos de nodos, cada uno con su propio tipo de acelerador. GKE conecta un selector de nodo único a los nodos de GPU para ayudar a colocar las cargas de trabajo de GPU en los nodos con tipos de GPU específicos:

  • Clave: cloud.google.com/gke-accelerator
  • Valor: nvidia-tesla-k80, nvidia-tesla-p100, nvidia-tesla-p4, nvidia-tesla-v100, nvidia-tesla-t4, nvidia-tesla-a100, nvidia-a100-80gb o nvidia-l4.

Puedes especificar tipos de GPU determinados si agregas este selector de nodo a la especificación de pod de tu carga de trabajo. Por ejemplo:

apiVersion: v1
kind: Pod
metadata:
  name: my-gpu-pod
spec:
  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: 2
  nodeSelector:
    cloud.google.com/gke-accelerator: nvidia-tesla-k80

Acerca de las bibliotecas de NVIDIA CUDA-X

CUDA es una plataforma de procesamiento paralela de NVIDIA y un modelo de programación para las GPU. Para usar aplicaciones CUDA, la imagen que uses debe tener las bibliotecas. Para agregar las bibliotecas NVIDIA CUDA-X, usa cualquiera de los siguientes métodos:

  • Recomendado: usa una imagen con las bibliotecas NVIDIA CUDA-X preinstaladas. Por ejemplo, puedes usar contenedores de aprendizaje profundo. Estos contenedores instalan previamente los frameworks de ciencia de datos clave, las bibliotecas y las herramientas NVIDIA CUDA-X. Como alternativa, la imagen CUDA de NVIDIA contiene solo las bibliotecas NVIDIA CUDA-X.
  • Compila y usa tu propia imagen. En este caso, incluye los siguientes valores en la variable de entorno LD_LIBRARY_PATH en la especificación de tu contenedor:
    1. /usr/local/cuda-CUDA_VERSION/lib64: la ubicación de las bibliotecas NVIDIA CUDA-X en el nodo. Reemplaza CUDA_VERSION por la versión con imágenes CUDA-X que usaste. Algunas versiones también contienen utilidades de depuración en /usr/local/nvidia/bin. Para obtener más información, consulta la imagen CUDA de NVIDIA en DockerHub.
    2. /usr/local/nvidia/lib64: la ubicación de los controladores del dispositivo NVIDIA.

Si deseas verificar el controlador de GPU mínimo necesario para tu versión de CUDA, consulta el kit de herramientas CUDA y las versiones de controladores compatibles. Asegúrate de que la versión del parche de GKE que se ejecuta en tus nodos incluya una versión del controlador de GPU compatible con la versión de CUDA elegida. Para obtener una lista de las versiones del controlador de GPU asociadas con la versión de GKE, consulta la página de Container-Optimized OS correspondiente vinculada en la tabla de versiones actuales de GKE.

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.

Para obtener más información sobre cómo supervisar tus clústeres y sus recursos, consulta Supervisión.

Visualiza las métricas de uso

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.

¿Qué sigue?