Ejecuta GPU en grupos de nodos de GKE Standard

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 nodos de tus clústeres estándar de Google Kubernetes Engine (GKE). Si usas Pods de Autopilot, consulta Implementa cargas de trabajo de GPU en Autopilot.

Si deseas implementar clústeres con GPU NVIDIA B200 o NVIDIA H200 de 141 GB, consulta los siguientes recursos:

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 las GPU, consulta la página de GPU 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 el comando gcloud components update para obtener la versión más reciente. Es posible que las versiones anteriores de gcloud CLI no admitan la ejecución de los comandos que se describen en este documento.

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:

  • 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 Google Cloud consola.

    Si necesitas una cuota de GPU adicional, debes solicitar una cuota de GPU en la Google Cloud consola. 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.

  • Serie de máquinas: 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.

  • GPU en nodos de Ubuntu: Si usas GPU con nodos de Ubuntu, se aplican los siguientes requisitos:

    • Compatibilidad con el conductor:

      • GPUs L4 y GPUs H100: Versión 535 o posterior del controlador de NVIDIA

      • GPUs H200: Versión 550 o posterior del controlador de NVIDIA

      • GPUs B200: Versión 570 o posterior del controlador de NVIDIA

      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.

    • Compatibilidad de versiones:

      Cuando usas la serie de máquinas A4 en grupos de nodos de Ubuntu, debes usar una versión de GKE que incluya la imagen ubuntu-gke-2404-1-32-amd64-v20250730 o una versión posterior de la imagen de nodo. Estas son las versiones mínimas de GKE:

      • 1.32.7-gke.1067000 o posterior para la versión 1.32 de GKE
      • 1.33.3-gke.1247000 o posterior para la versión 1.33 de GKE
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 los 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 GPUs a grupos de nodos existentes.
  • Los nodos de GPU no se pueden migrar en vivo durante los eventos de mantenimiento.
  • 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.

Disponibilidad de GPU 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 Google Cloud página de GPU.

Asegúrate de tener suficiente cuota de GPU

Tu cuota de GPU es la cantidad total de GPU que puedes ejecutar en tu proyecto.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 GPU por nodo multiplicada 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 Google Cloud consola. 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 Google Cloud consola:

  1. Ve a la página Cuotas de 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 (por ejemplo, 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 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.

Aplica un taint a un grupo de nodos de GPU para evitar que se programe 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. Según las siguientes situaciones, GKE agrega automáticamente marcas de exclusión, o bien puedes agregarlas de forma manual:

  • 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 al menos un grupo de nodos sin GPU en el clúster.

  • Cuando agregas un grupo de nodos de GPU a un clúster que solo tiene grupos de nodos de GPU, o si creas un clúster nuevo en el que el grupo de nodos predeterminado tenga GPU conectadas, puedes establecer manualmente taints en el grupo de nodos nuevo con los siguientes valores:

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

  • Cuando agregues un grupo de nodos sin GPU al clúster en el futuro, GKE no aplicará este taint de forma retroactiva a los nodos de GPU existentes. Debes establecer manualmente taints en el grupo de nodos nuevo.

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 independiente en un clúster existente, puedes usar laGoogle Cloud consola o Google Cloud CLI. También puedes usar Terraform para aprovisionar tus clústeres de GKE y el grupo de nodos de GPU.

GKE admite la instalación automática de controladores de NVIDIA en los siguientes casos:

  • En los clústeres de GKE con la versión 1.32.2-gke.1297000 y posteriores del plano de control, GKE instala automáticamente la versión predeterminada del controlador de NVIDIA para todos los nodos de GPU, incluidos los que se crearon con el aprovisionamiento automático de nodos.
  • En los clústeres de GKE con versiones del plano de control de 1.30.1-gke.1156000 a 1.32.2-gke.1297000, GKE instala automáticamente la versión predeterminada del controlador de NVIDIA para los nodos que no se crearon con el aprovisionamiento automático de nodos.
  • De manera opcional, puedes elegir la versión del controlador más reciente disponible o inhabilitar explícitamente 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 \
  --cluster CLUSTER_NAME \
  --location CONTROL_PLANE_LOCATION \
  --node-locations COMPUTE_ZONE1[,COMPUTE_ZONE2] \
  [--sandbox=type=gvisor]
  [--enable-autoscaling \
   --min-nodes MIN_NODES \
   --max-nodes MAX_NODES] \
  [--scopes=SCOPES] \
  [--service-account=SERVICE_ACCOUNT] \
  [--reservation-affinity=specific --reservation=RESERVATION_NAME]

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.
  • AMOUNT: Es la cantidad de GPU que se deben adjuntar a los nodos del grupo de nodos.

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

  • MACHINE_TYPE: es el tipo de máquina de Compute Engine para tus nodos. Obligatorio para los siguientes tipos de GPU:

    • GPU NVIDIA B200 (correspondiente al tipo de acelerador nvidia-b200 y a la serie de máquinas A4)
    • GPUs NVIDIA H200 de 141 GB (que corresponden al tipo de acelerador nvidia-h200-141gb y al tipo de máquina A3 Ultra), GPUs NVIDIA H100 de 80 GB (que corresponden al tipo de acelerador nvidia-h100-80gb y al tipo de máquina A3 High) o GPUs NVIDIA H100 Mega de 80 GB (que corresponden 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.
    • GPU NVIDIA A100 de 40 GB (que corresponden al tipo de acelerador nvidia-tesla-a100 y al tipo de máquina A2 estándar) o GPU NVIDIA A100 de 80 GB (que corresponden 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 (correspondientes al tipo de acelerador nvidia-l4 y a la serie de máquinas G2)

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

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

  • CONTROL_PLANE_LOCATION: Es la ubicación de Compute Engine del plano de control de tu clúster. Proporciona una región para los clústeres regionales o una zona para los clústeres zonales.

  • 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 --location. Los tipos de GPU que definas deben estar disponibles en cada zona seleccionada. Si usas una reserva, debes especificar las zonas en las que tiene capacidad. 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 GPUs solicitadas.

  • De manera opcional, puedes crear grupos de nodos para ejecutar cargas de trabajo en zona de pruebas con gVisor. Para obtener más información, consulta GKE Sandbox.

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

  • De manera opcional, puedes crear el grupo de nodos de GPU con una cuenta de servicio personalizada agregando las siguientes marcas. Si se omite, el grupo de nodos usa la cuenta de servicio predeterminada de Compute Engine:

    • SERVICE_ACCOUNT: Es el nombre de la cuenta de servicio de IAM que usan tus nodos.
    • SCOPES: Es una lista separada por comas de los permisos de acceso que se otorgarán. Asegúrate de que uno de los alcances sea storage-ro o https://www.googleapis.com/auth/devstorage.read_only. Para obtener más información sobre los permisos, consulta Cómo configurar permisos de acceso. Si omites la marca scope, se producirá un error en la creación del grupo de nodos de GPU con el error AccessDenied failed to download gpu_driver_versions.bin from GCS bucket.

  • RESERVATION_NAME: Es el nombre de la reserva de GPU que se usará. Especifica la marca --reservation con --reservation-affinity=specific para usar la capacidad de GPU de una reserva específica. Para obtener más información, consulta Consume una reserva específica de un solo proyecto.

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 \
  --cluster p100-cluster \
  --location us-central1 \
  --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:

  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_ZONE"
  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_ZONE: La zona específica en la que GKE crea los nodos de GPU. La zona debe estar en la misma región que especifica la variable region. Estas zonas deben tener disponibles los tipos de GPU que definiste. Para obtener más información, consulta Disponibilidad de GPUs por regiones y zonas.
    • 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 y posteriores de GKE, si omites este campo, esta será 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:

      • GPU NVIDIA B200 (correspondientes al tipo de acelerador nvidia-b200 y a la serie de máquinas A4)
      • GPUs NVIDIA H200 de 141 GB (que corresponden al tipo de acelerador nvidia-h200-141gb y al tipo de máquina A3 Ultra), GPUs NVIDIA H100 de 80 GB (que corresponden al tipo de acelerador nvidia-h100-80gb y al tipo de máquina A3 High) o GPUs NVIDIA H100 Mega de 80 GB (que corresponden 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.
      • GPU NVIDIA A100 de 40 GB (que corresponden al tipo de acelerador nvidia-tesla-a100 y al tipo de máquina A2 Standard) o GPU NVIDIA A100 de 80 GB (que corresponden 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 (correspondientes al tipo de acelerador nvidia-l4 y a la serie de máquinas G2)

      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
  initial_node_count = 1
}

resource "google_container_node_pool" "gpu_pool" {
  name           = google_container_cluster.ml_cluster.name
  location       = var.region
  node_locations = [var.zones]
  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 GPUs. 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

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

  • Elegiste inhabilitar la instalación automática del controlador de dispositivos cuando creaste un grupo de nodos de GPU.
  • 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. Por ejemplo, usar GPUs con Confidential GKE Nodes
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

  • Para instalar una versión más reciente del controlador de GPU desde la tabla de versiones de controladores que se incluye en esta sección, ejecuta el siguiente comando:

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

  • Para instalar una versión del controlador de GPU que admita ejecutar cargas de trabajo de GPU en Confidential GKE Nodes, ejecuta el siguiente comando:

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

La instalación tarda varios segundos en completarse. Una vez que se completa la instalación, 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 Container-Optimized OS tiene al menos una versión compatible del controlador de GPU de NVIDIA. Para obtener más información sobre la asignación de la versión del controlador de GPU a la versión de GKE, puedes realizar cualquiera de las siguientes acciones:

Versiones del controlador NVIDIA de GKE
1.33 R535 (predeterminado), R570, R575 o R580
1.32 R535 (predeterminado), R570, R575 o R580
1.31 R535 (predeterminado), R570, R575 o R580
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, de la siguiente manera:

  • Para todas las GPU excepto las GPU NVIDIA H200, 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 H200, instala el controlador R550:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/refs/heads/master/nvidia-driver-installer/ubuntu/daemonset-preloaded-R550.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.

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.33 R535 (predeterminado)
1.32 R535 (predeterminado)
1.31 R535 (predeterminado)
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
  }

Asigna la versión de GKE y la versión de imagen de nodo de Container-Optimized OS a la versión del controlador de GPU

Para encontrar las versiones del controlador de GPU que se asignan a las versiones de GKE y a las versiones de imagen de nodo de Container-Optimized OS, sigue estos pasos:
  1. Asigna versiones de imagen de nodo de Container-Optimized OS a versiones de parche de GKE para la versión específica de GKE en la que deseas encontrar la versión del controlador de GPU. Por ejemplo, 1.33.0-gke.1552000 usa cos-121-18867-90-4.
  2. Elige el hito de la versión de la imagen del nodo de Container-Optimized OS en las notas de la versión de Container-Optimized OS. Por ejemplo, elige el hito 121 para cos-121-18867-90-4.
  3. En la página de notas de la versión del evento importante específico, busca la nota de la versión correspondiente a la versión específica de la imagen del nodo de Container-Optimized OS. Por ejemplo, en Container-Optimized OS Release Notes: Milestone 121, consulta cos-121-18867-90-4. En la tabla de la columna Controladores de GPU, haz clic en Ver lista para ver la información de la versión del controlador de GPU.

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

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

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 los clústeres que ejecutan la versión 1.32.2-gke.1297000 y versiones posteriores de GKE, GKE instala automáticamente la versión predeterminada del controlador de NVIDIA para todos los nodos de GPU, incluidos los que se crearon con el aprovisionamiento automático de nodos. Puedes omitir las siguientes instrucciones para los clústeres que ejecutan la versión 1.32.2-gke.1297000 de GKE y versiones posteriores.

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: Es el controlador estable y predeterminado para la versión de GKE de tu nodo.
  • latest: Es la versión más reciente del controlador disponible para la versión de GKE de tu nodo.
  • disabled: inhabilita la instalación automática del controlador de GPU. Si seleccionas este valor, debes instalar manualmente los controladores para ejecutar tus GPUs. En las versiones de GKE anteriores a la 1.32.2-gke.1297000, esta es la opción predeterminada si omites el selector de nodos.

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:
  # Optional: Use GKE Sandbox
  # runtimeClassName: gvisor
  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, actualizaciones azul-verde o actualizaciones de corta duración. 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 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/nvidia/lib64: la ubicación de los controladores del dispositivo NVIDIA.
  • /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.

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 más información sobre cómo asignar la versión del controlador de GPU a la versión de GKE, consulta Cómo asignar la versión de GKE y la versión de imagen de nodo de Container-Optimized OS a la versión del controlador de GPU.

Supervisa el rendimiento de las cargas de trabajo del nodo de GPU

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

  • Ciclo de trabajo (container/accelerator/duty_cycle): es el porcentaje de tiempo del ú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): es la cantidad de memoria del acelerador asignada expresada en bytes.
  • Capacidad de memoria (container/accelerator/memory_total): es la memoria total del acelerador expresada en bytes.

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

Puedes usar paneles predefinidos para supervisar los 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 las cargas de trabajo en el panel Cargas de trabajo de la consola de Google Cloud .

Para ver el uso de GPU de las cargas de trabajo, sigue los siguientes pasos:

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

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

En el panel de las cargas de trabajo, se muestran los gráficos del 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 (DCGM) de NVIDIA

Puedes recopilar y visualizar las métricas del DCGM de NVIDIA con Google Cloud Managed Service para Prometheus. Para los clústeres en modo Autopilot, GKE instala los controladores. Para los clústeres estándar, 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.

¿Qué sigue?