Ejecuta GPU en grupos de nodos de GKE Standard

Estándar

En esta página, se muestra cómo ejecutar y optimizar tus cargas de trabajo intensivas en procesamiento, como la inteligencia artificial (IA) y el procesamiento de gráficos, conectando y usando aceleradores de hardware de unidad de procesamiento gráfico (GPU) de NVIDIA® en los nodes de tus clústeres estándar de Google Kubernetes Engine (GKE).

Si, en cambio, usas Pods de Autopilot, 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. En modo GKE Standard, puedes conectar hardware de GPU a nodos en tus clústeres y, luego, asignar recursos de GPU a cargas de trabajo alojadas en contenedores que se ejecutan en esos nodos.

Para obtener más información sobre los casos de uso de GPU, consulta la página GPUs de Google Cloud. Para obtener más información sobre las GPUs en GKE y las diferencias entre el modo estándar y el modo Autopilot, consulta Información sobre las GPUs en GKE.

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.
Nota: Para las instalaciones de gcloud CLI existentes, asegúrate de configurar las propiedades compute/region y compute/zone. Cuando configuras las ubicaciones predeterminadas, puedes evitar errores en la CLI de gcloud como el siguiente: One of [--zone, --region] must be supplied: Please specify location.

Requisitos para las GPUs en GKE

Las GPU en GKE tienen los siguientes requisitos:

Versión de Kubernetes: Las versiones disponibles dependen de la imagen de nodo que usan las GPUs:
- Container-Optimized OS: Versión 1.9 o superior de GKE
- Ubuntu: GKE versión 1.11.3 o posterior
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 recibirá de forma automática la cuota después de enviar la solicitud de cuota.

De forma predeterminada, las cuentas de prueba gratuita no reciben cuota de GPU.
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 GPUs A100 solo son compatibles con los tipos de máquinas A2. Debes asegurarte de tener suficiente cuota para que el tipo de máquina A2 subyacente pueda usar la GPU A100.
GPUs en nodos de Ubuntu: Si usas GPUs con nodos de Ubuntu, se aplican los siguientes requisitos de controladores.
GPUs L4 y GPUs H100: Controlador NVIDIA versión 535 o posterior

Si una versión de controlador requerida o una versión posterior no es la versión predeterminada en tu versión de GKE, debes instalar de forma manual un controlador compatible en tus nodos.

Práctica recomendada:

Usa Container-Optimized OS para los nodos de GPU. Container-Optimized OS incluye los controladores necesarios para admitir la versión específica de GKE para nodos de GPU.

Limitaciones del uso de GPUs en GKE

Antes de usar las GPUs 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:
- Serie de máquinas A3: GPU H100.
- Serie de máquinas A2: GPU A100.
- Serie de máquinas G2: GPU L4.
- Serie de máquinas N1: Todas las GPU, excepto A100 y L4.
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.
Si usas GPUs H100 y deseas usar SSDs locales en tus Pods, debes especificar de forma explícita la cantidad exacta de SSDs locales que deseas conectar a la VM A3 subyacente. Especifica el número con 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 no agregas una de estas marcas, no podrás usar las SSDs locales en tus Pods.

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

Disponibilidad de GPUs por regiones y zonas

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.

Asegúrate de que la cuota de GPU sea suficiente

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 de GPUs por nodo multiplicado por la cantidad máxima de nodos de tu clúster.

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:

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

Ir a Cuotas
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.
En la lista de cuotas de GPU, selecciona la que deseas cambiar.
Haz clic en Editar cuotas. Se abrirá un formulario de solicitud.
Completa el campo Nuevo límite de cuota para cada solicitud de cuotas.
Completa el campo Descripción de la solicitud con los detalles sobre tu solicitud.
Haz clic en Siguiente.
En el cuadro de diálogo Confirmación de anulación, haz clic en Confirmar.
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.
Haz clic en Enviar solicitud.
Recibirás un correo electrónico de confirmación para realizar un seguimiento del cambio de cuota.

Ejecuta GPUs en clústeres de GKE Standard

Para ejecutar GPUs en clústeres de GKE Standard, crea un grupo de nodos con GPUs conectadas.

Práctica recomendada:

Para mejorar la rentabilidad, la confiabilidad y la disponibilidad de las GPUs en GKE, realiza 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 GPUs 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.
Configura 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.

Como se describe en las siguientes secciones, GKE usa taints y tolerancias de nodos para garantizar que los Pods no se programen en nodos inapropiados.

Taint de forma automática un grupo de nodos de GPU para evitar programarlo de forma inadecuada

Un taint de nodo te permite marcar un nodo a fin de que el programador evite o impida su uso para ciertos pods. 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

GKE solo agrega este taint si hay un grupo de nodos sin GPU en el clúster. Si agregas un grupo de nodos de GPU a un clúster en el que todos los grupos de nodos existentes son grupos de nodos de GPU, o si creas un clúster nuevo en el que el grupo de nodos predeterminado tenga GPU conectadas, el taint anterior no se agregará a los nodos de GPU.

Si agregas un grupo de nodos de GPU al clúster en el futuro, GKE no aplica este taint de forma retroactiva a los nodos de GPU existentes.

Restringe automáticamente la programación con una tolerancia

Las tolerancias te permiten designar Pods que se pueden usar en nodos “tainted”. GKE aplica automáticamente una tolerancia para que solo los Pods que soliciten GPUs se programen en nodos de GPU. Esto permite que el ajuste de escala automático sea más eficaz, ya que tus nodos de GPU pueden escalar con rapidez si no hay suficientes Pods que soliciten GPUs. Para ello, GKE ejecuta el controlador de admisión ExtendedResourceToleration.

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.

En la versión 1.30.1-gke.1156000 y posteriores del plano de control de GKE, GKE instala automáticamente la versión predeterminada del controlador de NVIDIA para la versión de tu nodo de GKE. De manera opcional, puedes elegir la versión más reciente del controlador disponible o inhabilitar de forma explícita la instalación automática del controlador. En versiones anteriores a la 1.30.1-gke.1156000, GKE no instala un controlador de forma predeterminada si no especificas una versión de controlador cuando creas o actualizas 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] \
  [--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. Un ejemplo es 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 de nodos. En la versión 1.30.1-gke.1156000 de GKE y versiones posteriores, si omites la marca gpu-driver-version, esta es la opción predeterminada. En versiones anteriores, GKE no instala un controlador si omites esta marca.
- 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. En las versiones de GKE anteriores a la 1.30.1-gke.1156000, esta es la opción predeterminada.
La opción gpu-driver-version solo está disponible para GKE 1.27.2-gke.1200 y versiones posteriores. En versiones anteriores, omite esta marca y, luego, instala un controlador de forma manual después de crear el grupo de nodos. Si actualizas un clúster o grupo de nodos existente a esta versión o una posterior, GKE instala de forma automática la versión de controlador predeterminada que corresponde a la versión de GKE, a menos que especifiques algo diferente cuando inicies la actualización.

Nota: Para crear un grupo de nodos con nodos Ubuntu y GPUs NVIDIA L4 o NVIDIA H100, y para instalar automáticamente la versión predeterminada del controlador de NVIDIA, debes usar una versión mínima de parche de GKE o una posterior. En versiones anteriores, debes especificar gpu-driver-version=disabled e instalar el controlador de NVIDIA de forma manual.
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:
- GPUs NVIDIA H100 de 80 GB (correspondientes al tipo de acelerador nvidia-h100-80gb y al tipo de máquina A3 High) o GPUs NVIDIA H100 Mega de 80 GB (correspondientes al tipo de acelerador nvidia-h100-mega-80gb y al tipo de máquina A3 Mega). Para obtener más información, consulta la serie de máquinas A3 en la documentación de Compute Engine.
- GPUs NVIDIA A100 de 40 GB (correspondientes al tipo de acelerador nvidia-tesla-a100 y al tipo de máquina A2 estándar) o GPUs NVIDIA A100 de 80 GB (correspondientes al tipo de acelerador nvidia-a100-80gb y al tipo de máquina A2 Ultra). Para obtener más información, consulta la serie de máquinas A2 en la documentación de Compute Engine.
- GPU NVIDIA L4 (que corresponden al tipo de acelerador nvidia-l4 y a la serie de máquinas G2)
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

Console

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

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

Ir a Google Kubernetes Engine
En la lista de clústeres, haz clic en el nombre del clúster que deseas modificar.
Haz clic en Agregar grupo de nodos.
De forma opcional, en la página Detalles del grupo de nodos, selecciona la casilla de verificación Habilitar ajuste de escala automático.
Configura tu grupo de nodos como desees.
Desde el panel de navegación, selecciona Nodos.
En Configuración de la máquina, haz clic en GPU.
Selecciona un Tipo de GPU y una Cantidad de GPU que se ejecutará en cada nodo.
Lee la advertencia y selecciona Comprendo las limitaciones.
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.
Haz clic en Crear.

Terraform

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

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. Un ejemplo es 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 GPUs. En las versiones de GKE anteriores a la 1.30.1-gke.1156000, esta es la opción predeterminada si omites este campo.
  - DEFAULT: Instala de forma automática la versión de controlador predeterminada para la versión del sistema operativo del nodo. En la versión 1.30.1-gke.1156000 de GKE y versiones posteriores, si omites este campo, esta es la opción predeterminada. En versiones anteriores, GKE no instala un controlador si omites este campo.
  - LATEST: Instala de forma automática la última versión del controlador disponible para tu versión del SO del nodo. Disponible solo para los nodos que usan Container-Optimized OS.
  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:
  - GPUs NVIDIA H100 de 80 GB (correspondientes al tipo de acelerador nvidia-h100-80gb y al tipo de máquina A3 High) o GPUs NVIDIA H100 Mega de 80 GB (correspondientes al tipo de acelerador nvidia-h100-mega-80gb y al tipo de máquina A3 Mega). Para obtener más información, consulta la serie de máquinas A3 en la documentación de Compute Engine.
  - GPUs NVIDIA A100 de 40 GB (correspondientes al tipo de acelerador nvidia-tesla-a100 y al tipo de máquina A2 estándar) o GPUs NVIDIA A100 de 80 GB (correspondientes al tipo de acelerador nvidia-a100-80gb y al tipo de máquina A2 Ultra). Para obtener más información, consulta la serie de máquinas A2 en la documentación de Compute Engine.
  - GPU NVIDIA L4 (que corresponden al tipo de acelerador nvidia-l4 y a la serie de máquinas G2)
  Esta marca es opcional para todas las demás GPU.

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 en terraform.io.

Práctica recomendada:

Para evitar incurrir en más costos, quita todos los recursos definidos en el archivo de configuración con el comando terraform destroy.

Práctica recomendada: 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

Para instalar los controladores de GPU de NVIDIA de forma manual en tus nodos, debes implementar un DaemonSet de instalación en esos nodos. Usa la instalación manual en las siguientes situaciones:

Eliges inhabilitar la instalación automática del controlador de dispositivos cuando creaste un grupo de nodos de GPU.
Si usas una versión de GKE anterior a la versión mínima compatible para la instalación automática
Tu carga de trabajo requiere una versión específica del controlador de NVIDIA que no está disponible como el controlador predeterminado o el más reciente con instalación automática.

Práctica recomendada:

Usa la instalación automática de controladores siempre que 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.

Para ejecutar el DaemonSet de instalación, el grupo de nodos de GPU requiere el permisohttps://www.googleapis.com/auth/devstorage.read_only para comunicarse con Cloud Storage. Sin este permiso, fallará la descarga del manifiesto de DaemonSet de instalación. Este permiso es uno de los permisos predeterminados, que por lo general se agrega cuando creas el clúster.

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:

Versiones de controladores de NVIDIA de GKE
1.30	R535 (predeterminado) o R550
1.29	R535 (predeterminado) o R550
1.28	R535 (predeterminado) o R550
1.27	R470 (predeterminado), R525, R535, or R550
1.26	R470 (predeterminado), R525, R535, or R550

Ubuntu

El DaemonSet de instalación que implementes depende del tipo de GPU y de la versión del nodo de GKE, como se describe a continuación:

Para todas las GPUs, excepto las GPUs NVIDIA L4 y NVIDIA H100, ejecuta el siguiente comando:

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

Para las GPUs NVIDIA L4 o H100 que ejecutan versiones de nodos de la versión 2024-R05 o posteriores, instala el controlador R535:

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

Para las GPUs NVIDIA L4 o H100 que ejecutan versiones de nodos de versiones anteriores a la versión 2024-R05 o posteriores, instala el controlador R525:

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:

Controladores de GPU de Ubuntu y versiones de GKE
1.30	R470 o R535
1.29	R470 o R535
1.28	R470 o R535
1.27	R470 o R535
1.26	R470 o R535

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
  }

Instala controladores con el aprovisionamiento automático de nodos con GPUs

De forma predeterminada, cuando usas el aprovisionamiento automático de nodos con GPUs, los grupos de nodos aprovisionados automáticamente no tienen permisos suficientes 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

alpha.kubernetes.io/nvidia-gpu no se admite como nombre de recurso en GKE. Usa nvidia.com/gpu como el nombre del recurso en su lugar.

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. Un ejemplo es 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 requiere 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, puedes compilar y usar tu propia imagen. Para ello, incluye los siguientes valores en la variable de entorno LD_LIBRARY_PATH en la especificación de tu contenedor:

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

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.
/usr/local/nvidia/lib64: la ubicación de los controladores del dispositivo NVIDIA.

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 GPUs 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 el rendimiento de la carga de trabajo de tu nodo 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:

Ve a la página Cargas de trabajo en la consola de Google Cloud.
Ir a Cargas de trabajo
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 Autopilot, GKE instala los controladores. Para los clústeres de Standard, debes instalar los controladores NVIDIA.

Para obtener instrucciones sobre cómo implementar el paquete de DCGM administrado por GKE, consulta Recopila y visualiza métricas del administrador de GPU del centro de datos de NVIDIA (DCGM).

Configura la finalización correcta de los nodos 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.

Para configurar GKE para finalizar tus cargas de trabajo de forma ordenada en el plazo de este período de notificación, sigue los pasos que se indican en Administra la interrupción de nodos de GKE para GPUs y TPUs.

Ejecuta GPU en grupos de nodos de GKE Standard

Descripción general

Antes de comenzar

Requisitos para las GPUs en GKE

Limitaciones del uso de GPUs en GKE

Disponibilidad de GPUs por regiones y zonas

Precios

Asegúrate de que la cuota de GPU sea suficiente

Solicita la cuota de GPU

Ejecuta GPUs en clústeres de GKE Standard

Taint de forma automática un grupo de nodos de GPU para evitar programarlo de forma inadecuada

Restringe automáticamente la programación con una tolerancia

Crea un grupo de nodos de GPU

gcloud

Console

Terraform

Instala de forma manual los controladores de GPU de NVIDIA

COS

Ubuntu

Terraform

Instala controladores con el aprovisionamiento automático de nodos con GPUs

Configura pods para consumir las GPU

Consume varios tipos de GPU

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

Acerca de las bibliotecas de NVIDIA CUDA-X

Supervisa el rendimiento de la carga de trabajo de tu nodo de GPU

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

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

Configura la finalización correcta de los nodos de GPU

¿Qué sigue?