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 acerca de las GPU en GKE, consulta Información sobre 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 crear grupos de nodos equipados con GPU. 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.

Para obtener más información sobre los casos de uso de GPU, consulta la página GPUs de Google Cloud.

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.

A partir de la versión 1.29.2-gke.1108000, puedes crear grupos de nodos de GPU en GKE Sandbox. Para obtener más información, consulta GKE Sandbox y Configuración de GKE Sandbox.

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.

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 seleccionada 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 indicar a GKE que instale automáticamente una versión de controlador basada en la versión de GKE. Si no le indicas a GKE que instale los controladores de GPU de forma automática, 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.

  • Los clústeres de GKE Standard que ejecutan la versión 1.28.2-gke.1098000 o una anterior no son compatibles con el aprovisionamiento automático de nodos a través de la creación de grupos de nodos con GPU L4. Sin embargo, los clústeres que ejecutan versiones anteriores admiten el escalamiento del escalador automático del clúster para los grupos de nodos existentes.

  • En el caso de las GPU H100, para usar SSD locales para el almacenamiento de Pods, debes especificar de forma explícita la cantidad exacta de SSD locales para conectar a la VM A3 subyacente usando la marca --ephemeral-storage-local-ssd=count=SSD_COUNT para el almacenamiento efímero o la marca --local-nvme-ssd-block=count=SSD_COUNT para el acceso al bloque. Si omites esta marca, no podrás usar las SSD locales en tus Pods. Estas marcas solo son necesarias si deseas usar SSD local para el acceso a los datos.

    El tamaño de la máquina admitido en GKE es a3-highgpu-8g, y el recuento de SSD locales correspondiente es 16.

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 obtener una mejor rentabilidad, confiabilidad y disponibilidad de las GPU en GKE, te recomendamos las siguientes acciones:

  • Crea grupos de nodos de GPU separados. Para cada grupo de nodos, limita la ubicación del nodo a las zonas en las que están disponibles las GPU que deseas.
  • 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 automáticamente los controladores de GPU predeterminados o más recientes en los grupos de nodos para que no tengas que instalar y administrar de forma manual tus versiones de controladores.

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.

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.

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] \
  [--enable-autoscaling \
   --min-nodes MIN_NODES \
   --max-nodes MAX_NODES] \
  [--ephemeral-storage-local-ssd=count=SSD_COUNT]

Reemplaza lo siguiente:

  • POOL_NAME: Es el nombre que eliges para el grupo de nodos.
  • GPU_TYPE: el tipo de acelerador de GPU que usas. Por ejemplo, nvidia-tesla-t4.

  • DRIVER_VERSION: Es la versión del controlador NVIDIA que se instalará. Puede ser una de las 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, GKE no instala automáticamente un controlador.

  • 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 para los siguientes tipos de GPU:

    Esta marca es opcional para todas las demás GPU.

  • 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, especificado 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.

  • 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.

  • SSD_COUNT: Es la cantidad de SSD locales que se conectarán para el almacenamiento efímero. Esta marca es necesaria para usar SSD locales en tipos de máquinas A3 con GPU H100.

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 automáticamente 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 \
  --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. En la sección GPU Driver installation, selecciona uno de los siguientes métodos:

    • Administrada por Google: GKE instala un controlador de forma automática. Si seleccionas esta opción, elige una de las siguientes opciones del menú desplegable Versión:
      • Predeterminada: Instala la versión predeterminada del controlador.
      • Más reciente: Instala la versión más reciente del controlador disponible.
    • Administrada por el cliente: GKE no instala un controlador. Debes instalar un controlador compatible de forma manual con las instrucciones que se indican en Instala controladores de dispositivos de GPU de NVIDIA.

  11. Haz clic en Crear.

Terraform

Puedes crear un clúster regional con Terraform con GPU mediante el uso de 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"
}

variable "machine_type" {
  default = "MACHINE_TYPE"
  description = "The Compute Engine machine type for the VM"
}

    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 disponibles los tipos de GPU que definiste. 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: el tipo de acelerador de GPU que usas. Por ejemplo, nvidia-tesla-t4.

    • 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. * MACHINE_TYPE: Es el tipo de máquina de Compute Engine para tus nodos. Obligatorio para los siguientes tipos de GPU:

    Esta marca es opcional para todas las demás GPU.

  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 = var.machine_type
    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 GPUs y especificar zonas con la marca --node-locations. Sin embargo, te recomendamos que crees un grupo de nodos de GPU separado en un clúster existente, como se muestra en esta sección.

Instala de forma manual los controladores de GPU de NVIDIA

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 GPU de NVIDIA usa la API de Kubernetes para que la capacidad de la GPU de NVIDIA esté disponible.

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 GPU de NVIDIA usa la API de Kubernetes para que la capacidad de la GPU de NVIDIA esté disponible.

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 a tu 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

En la versión 1.29.2-gke.1108000 y posteriores de GKE, puedes seleccionar una versión del controlador de GPU para que GKE la instale automáticamente en los nodos de GPU aprovisionados de forma automática. Agrega el siguiente campo 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.

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

El siguiente manifiesto es 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: el tipo de acelerador de GPU que usas. Por ejemplo, nvidia-tesla-t4.

Puedes especificar tipos de GPU determinados si agregas este selector de nodo a la especificación del Pod de 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-t4

Actualiza los grupos de nodos mediante aceleradores (GPU y TPU)

GKE actualiza de forma automática los clústeres de Standard, incluidos los grupos de nodos. También puedes actualizar manualmente los grupos de nodos si deseas que los nodos se usen en una versión posterior antes. Para controlar cómo funcionan las actualizaciones de tu clúster, usa canales de versiones, períodos de mantenimiento y exclusiones, y secuenciación de lanzamientos.

También puedes configurar una estrategia de actualización de nodos para tu grupo de nodos, como actualizaciones de aumento o actualizaciones azul-verde. Si configuras estas estrategias, puedes asegurarte de que los grupos de nodos se actualicen de una manera que logre el equilibrio óptimo entre velocidad e interrupción de tu entorno. Para los grupos de nodos de porción de TPU de varios hosts, en lugar de usar la estrategia de actualización de nodos configurada, GKE vuelve a crear de forma atómica todo el grupo de nodos en un solo paso. Para obtener más información, consulta la definición de atomicidad en Terminología relacionada con la TPU en GKE.

El uso de una estrategia de actualización de nodos requerirá que GKE aprovisione de forma temporal recursos adicionales, según la configuración. Si Google Cloud tiene una capacidad limitada para los recursos de tu grupo de nodos, por ejemplo, si ves errores de disponibilidad de recursos cuando intentas crear más nodos con GPU o TPU, consulta Actualiza en un entorno con recursos restringidos.

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.

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 observabilidad de Google Cloud.

Configurar la finalización correcta del nodo de GPU

En los clústeres de GKE con el plano de control que ejecuta 1.29.1-gke.1425000 o una versión posterior, los nodos de GPU admiten las señales SIGTERM que alertan al nodo de un cierre inminente. La notificación de cierre inminente se puede configurar hasta 60 minutos en los nodos de GPU.

Puedes configurar GKE para finalizar tus cargas de trabajo de forma correcta en el plazo de este período de notificación. En el manifiesto de tu Pod, establece el campo spec.terminationGracePeriodSeconds en un valor de hasta 60 minutos (3600 segundos). Por ejemplo, para obtener un tiempo de notificación de 10 minutos, en el manifiesto de tu Pod, configura el campo spec.terminationGracePeriodSeconds como 600 segundos de la siguiente manera:

  spec:
    terminationGracePeriodSeconds: 600

GKE hace su mejor esfuerzo para finalizar estos Pods de manera correcta y ejecutar la acción de finalización que definiste, por ejemplo, con el guardado de un estado de entrenamiento.

¿Qué sigue?