Ejecutar GPUs en grupos de nodos estándar de GKE

En esta página se explica cómo ejecutar y optimizar tus cargas de trabajo que requieren muchos recursos de computación, como la inteligencia artificial (IA) y el procesamiento de gráficos, adjuntando 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 el artículo Desplegar cargas de trabajo de GPUs en Autopilot.

Si quieres desplegar clústeres con GPUs NVIDIA B200 o NVIDIA H200 de 141 GB, consulta los siguientes recursos:

Información general

Con GKE, puedes crear grupos de nodos equipados con GPUs. Las GPUs proporcionan potencia de cálculo para llevar a cabo tareas de aprendizaje profundo, como el reconocimiento de imágenes y el procesamiento del lenguaje natural, así como otras tareas que requieren muchos recursos de computación, como la transcodificación de vídeo y el procesamiento de imágenes. En el modo Estándar de GKE, puedes conectar hardware de GPU a los nodos de tus clústeres y, a continuación, asignar recursos de GPU a las cargas de trabajo en contenedores que se ejecutan en esos nodos.

Para obtener más información sobre los casos prácticos de las GPUs, 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 el artículo Acerca de las GPUs en GKE.

También puedes usar GPUs con máquinas virtuales de Spot si tus cargas de trabajo pueden tolerar interrupciones frecuentes de los nodos. Si usas máquinas virtuales de acceso puntual, se reduce el precio de ejecutar GPUs. Para obtener más información, consulta el artículo Usar VMs de acceso puntual con grupos de nodos de GPU.

Desde la versión 1.29.2-gke.1108000, ahora 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 empezar

Antes de empezar, asegúrate de que has realizado las siguientes tareas:

  • Habilita la API de Google Kubernetes Engine.
    • Habilitar la API de Google Kubernetes Engine
  • Si quieres usar Google Cloud CLI para esta tarea, instálala y, a continuación, inicialízala. Si ya has instalado la gcloud CLI, obtén la versión más reciente ejecutando gcloud components update.

Requisitos de las GPUs en GKE

Las GPUs en GKE tienen los siguientes requisitos:

  • Versión de Kubernetes: las versiones disponibles dependen de la imagen de nodo que usen las GPUs:

  • Cuota de GPUs: debes tener cuota de GPUs de Compute Engine en la zona seleccionada para poder crear nodos de GPU. Para asegurarte de que tienes suficiente cuota de GPU en tu proyecto, consulta Cuotas en la consola de Google Cloud .

    Si necesitas más cuota de GPU, debes solicitarla en la consola de Google Cloud . Si tienes una cuenta de facturación, tu proyecto recibirá automáticamente la cuota después de enviar la solicitud.

    De forma predeterminada, las cuentas de prueba gratuitas no reciben cuota de GPU.

  • Controladores de GPU NVIDIA: al crear un clúster o un grupo de nodos, puedes indicar a GKE que instale automáticamente una versión de controlador basada en tu versión de GKE. Si no le indicas a GKE que instale automáticamente los controladores de las GPU, debes instalar los controladores manualmente.

  • Serie de máquinas: el tipo de GPU que puedes usar depende de la serie de máquinas, como se indica a continuación:

    Debes asegurarte de que tu proyecto tenga suficiente cuota para la serie de máquinas que corresponda al tipo y la cantidad de GPU que hayas seleccionado.

  • GPUs en nodos de Ubuntu: si usas GPUs con nodos de Ubuntu, se aplican los siguientes requisitos:

    • Compatibilidad con controladores:

      • 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 la versión de controlador obligatoria o una versión posterior no es la predeterminada en tu versión de GKE, debes instalar manualmente un controlador compatible en tus nodos.

    • Compatibilidad de versiones:

      Cuando uses 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. Las versiones mínimas de GKE son las siguientes:

      • 1.32.7-gke.1067000 o una versión posterior para GKE 1.32
      • 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 nodos de GPU.

Limitaciones del uso de GPUs en GKE

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

  • No puedes añadir GPUs a grupos de nodos que ya tengas.
  • Los nodos de GPU no se pueden migrar automáticamente durante los eventos de mantenimiento.
  • Las GPUs no son compatibles con los grupos de nodos de Windows Server.
  • Los clústeres estándar de GKE que ejecutan la versión 1.28.2-gke.1098000 o una anterior no admiten el aprovisionamiento automático de nodos para crear grupos de nodos con GPUs L4. Sin embargo, los clústeres que ejecutan versiones anteriores admiten el escalado de escalador automático de clústeres en grupos de nodos ya creados.

Disponibilidad de GPUs por regiones y zonas

Las GPUs están disponibles en regiones y zonas concretas. Cuando solicites cuota de GPU, ten en cuenta las regiones en las que quieras ejecutar tus clústeres.

Para ver una lista completa de las regiones y zonas aplicables, consulta el artículo GPUs en Compute Engine.

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

gcloud compute accelerator-types list

Precios

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

Asegúrate de que tienes suficiente cuota de GPU

Tu cuota de GPU es el número total de GPUs que pueden ejecutarse en tu Google Cloud proyecto. Para crear clústeres con GPUs, tu proyecto debe tener suficiente cuota de GPUs.

Tu cuota de GPU debe ser al menos equivalente al número total de GPUs que quieras ejecutar en tu clúster. Si habilitas el autoescalado de clústeres, debes solicitar una cuota de GPU que sea al menos equivalente al número de GPUs por nodo multiplicado por el número máximo de nodos de tu clúster.

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

Solicitar cuota de GPUs

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

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

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

    Ir a Cuotas

  2. En el cuadro Filtro, haz lo siguiente:

    1. Seleccione la propiedad Quota (Cuota), introduzca el nombre del modelo de GPU y pulse Intro.
    2. (Opcional) Para aplicar filtros más avanzados y acotar los resultados, seleccione la propiedad Dimensiones (por ejemplo, ubicaciones), añada el nombre de la región o zona que esté usando y pulse Intro.

  3. En la lista de cuotas de GPU, selecciona la que quieras cambiar.

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

  5. Rellena el campo Nuevo límite de cuota de cada solicitud de cuota.

  6. Rellena el campo Descripción de la solicitud con los detalles de 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 Información de contacto, introduce tu nombre y un número de teléfono que los aprobadores puedan usar para completar tu solicitud de cambio de cuota.

  10. Haz clic en Enviar solicitud.

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

Ejecutar GPUs en clústeres de GKE Standard

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

Práctica recomendada:

Para mejorar la rentabilidad, la fiabilidad y la disponibilidad de las GPUs en GKE, siga estos pasos:

  • Crea grupos de nodos de GPU independientes. En cada grupo de nodos, limita la ubicación de los nodos a las zonas en las que estén disponibles las GPUs que quieras.
  • Habilita el autoescalado en cada grupo de nodos.
  • Usa clústeres regionales para mejorar la disponibilidad replicando el plano de control de Kubernetes en las zonas de la región.
  • Configura GKE para que instale automáticamente los controladores de GPU predeterminados o los más recientes en los grupos de nodos. De esta forma, no tendrás que instalar ni gestionar manualmente las versiones de los controladores.

Como se describe en las secciones siguientes, GKE usa etiquetas y tolerancias de nodos para asegurarse de que los pods no se programen en nodos inadecuados.

Taint un grupo de nodos de GPU para evitar que se programe de forma inadecuada

Una intolerancia de nodo te permite marcar un nodo para que el programador evite o impida usarlo para determinados pods. En función de las siguientes situaciones, GKE añade automáticamente los taints o puedes añadirlos manualmente:

  • Cuando añades un grupo de nodos con GPU a un clúster que ya tiene un grupo de nodos sin GPU, GKE contamina automáticamente los nodos con GPU con la siguiente contaminación de nodos:

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

    GKE solo añade este taint si hay al menos un grupo de nodos que no sea de GPU en el clúster.

  • Cuando añades un grupo de nodos con GPU a un clúster que solo tiene grupos de nodos con GPU, o si creas un clúster en el que el grupo de nodos predeterminado tiene GPUs vinculadas, puedes configurar manualmente los taints del nuevo grupo de nodos con los siguientes valores:

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

  • Si añades un grupo de nodos sin GPU al clúster más adelante, GKE no aplicará este taint de forma retroactiva a los nodos con GPU que ya haya. Debes definir manualmente los taints del nuevo grupo de nodos.

Restringir automáticamente la programación con una tolerancia

Las tolerancias le permiten designar pods que se pueden usar en nodos "contaminados". GKE aplica automáticamente una tolerancia para que solo los pods que soliciten GPUs se programen en nodos de GPU. Esto permite un autoescalado más eficiente, ya que los nodos de GPU se pueden reducir rápidamente si no hay suficientes pods que soliciten GPUs. Para ello, GKE ejecuta el controlador de admisión ExtendedResourceToleration.

Crear un grupo de nodos de GPU

Para crear un grupo de nodos de GPU independiente en un clúster, puedes usar laGoogle Cloud consola o la CLI de Google Cloud. También puedes usar Terraform para aprovisionar tus clústeres de GKE y tu pool 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 o posterior del plano de control, GKE instala automáticamente la versión predeterminada del controlador NVIDIA en todos los nodos de GPU, incluidos los creados con el aprovisionamiento automático de nodos.
  • En los clústeres de GKE con la versión 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 en los nodos que no se hayan creado con el aprovisionamiento automático de nodos.
  • También puedes elegir la última versión del controlador disponible o inhabilitar explícitamente la instalación automática de controladores. En versiones anteriores a la 1.30.1-gke.1156000, GKE no instala un controlador de forma predeterminada si no especificas una versión del controlador al crear o actualizar el grupo de nodos.

gcloud

Para crear un grupo de nodos con GPUs 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]

Haz los cambios siguientes:

  • POOL_NAME: el nombre que elijas para el grupo de nodos.
  • GPU_TYPE: el tipo de acelerador de GPU que usas. Por ejemplo, nvidia-tesla-t4.
  • AMOUNT: número de GPUs que se van a asociar a los nodos del grupo de nodos.

  • DRIVER_VERSION: la versión del controlador de NVIDIA que se va a instalar. Se puede definir lo siguiente:

    • default: instala la versión predeterminada del controlador para tu versión de GKE del nodo. En GKE 1.30.1-gke.1156000 y versiones posteriores, si omite 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 versión más reciente del controlador disponible para tu versión de GKE. Solo está disponible para los nodos que usan Container-Optimized OS.
    • disabled: omite la instalación automática de controladores. Debes instalar manualmente un controlador 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 en GKE 1.27.2-gke.1200 y versiones posteriores. En versiones anteriores, omite esta marca y instala un controlador manualmente después de crear el grupo de nodos. Si actualizas un clúster o un grupo de nodos a esta versión o una posterior, GKE instalará automáticamente la versión predeterminada del controlador que corresponda a la versión de GKE, a menos que especifiques otra cosa al iniciar la actualización.

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

    • GPUs NVIDIA B200 (correspondientes al nvidia-b200tipo de acelerador y a la serie de máquinas A4)
    • GPUs NVIDIA H200 de 141 GB (correspondientes al nvidia-h200-141gbtipo de acelerador y al tipo de máquina A3 Ultra ), 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 de 80 GB Mega (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 de la documentación de Compute Engine.
    • GPUs NVIDIA A100 de 40 GB (que corresponden al tipo de acelerador nvidia-tesla-a100 y al tipo de máquina A2 estándar) o GPUs 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.
    • GPUs NVIDIA L4 (correspondientes al nvidia-l4 tipo de acelerador y a la serie de máquinas G2).

    En el resto de las GPUs, esta marca es opcional.

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

  • CONTROL_PLANE_LOCATION: 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, especificada por la marca --location. Los tipos de GPU que definas deben estar disponibles en cada zona seleccionada. Si utilizas una reserva, debes especificar las zonas en las que tiene capacidad. Te recomendamos que utilices siempre la marca --node-locations al crear el grupo de nodos para especificar la zona o las zonas que contienen las GPUs solicitadas.

  • También puedes crear grupos de nodos para ejecutar cargas de trabajo en entornos aislados con gVisor. Para obtener más información, consulta los detalles en GKE Sandbox.

  • MIN_NODES: el número mínimo de nodos de cada zona del grupo de nodos en cualquier momento. Este valor solo es relevante si se usa la marca --enable-autoscaling.

  • MAX_NODES: el número máximo de nodos de cada zona del grupo de nodos en cualquier momento. Este valor solo es relevante si se usa la marca --enable-autoscaling.

  • También puedes crear el grupo de nodos de GPU con una cuenta de servicio personalizada añadiendo las siguientes marcas. Si se omite, el grupo de nodos usa la cuenta de servicio predeterminada de Compute Engine:

    • SERVICE_ACCOUNT: el nombre de la cuenta de servicio de gestión de identidades y accesos que usan tus nodos.
    • SCOPES: lista separada por comas de los ámbitos de acceso que se van a conceder. Asegúrate de que uno de los ámbitos sea storage-ro o https://www.googleapis.com/auth/devstorage.read_only. Para obtener más información sobre los permisos, consulte Configurar permisos de acceso. Si omite la marca scope, se producirá un error AccessDenied al crear el grupo de nodos de GPU failed to download gpu_driver_versions.bin from GCS bucket.

  • RESERVATION_NAME: el nombre de la reserva de GPU que se va a 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 Consumir una reserva de un solo proyecto específica.

Por ejemplo, el siguiente comando crea un grupo de nodos con autoescalado de alta disponibilidad, p100, con dos GPUs P100 por 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

Consola

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

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

    Ir a Google Kubernetes Engine

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

  3. Haz clic en Añadir grupo de nodos.

  4. Opcionalmente, en la página Detalles del grupo de nodos, marque la casilla Habilitar autoescalado.

  5. Configura el grupo de nodos como quieras.

  6. En 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 el número de GPUs que se ejecutarán en cada nodo.

  9. Lee la advertencia y selecciona Entiendo las limitaciones.

  10. En la sección Instalación del controlador de GPU, selecciona uno de los siguientes métodos:

    • Gestionado por Google: GKE instala automáticamente un controlador. Si seleccionas esta opción, elige una de las siguientes en el menú desplegable Versión:
      • Predeterminado: instala la versión predeterminada del controlador.
      • Más reciente: instala la última versión del controlador disponible.
    • Gestionado por el cliente: GKE no instala ningún controlador. Debes instalar manualmente un controlador compatible siguiendo las instrucciones que se indican en el artículo Instalar controladores de dispositivos de GPU NVIDIA.

  11. Haz clic en Crear.

Terraform

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

  1. Define las variables de Terraform incluyendo 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"
}

    Haz los cambios siguientes:

    • PROJECT_ID: tu ID de proyecto.
    • CLUSTER_NAME: el nombre del clúster de GKE.
    • CLUSTER_REGION: la región de cálculo del 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 especificada por la variable region. Estas zonas deben tener disponibles los tipos de GPU que hayas definido. Para obtener más información, consulta Disponibilidad de GPUs por regiones y zonas.
    • GPU_TYPE: el tipo de acelerador de GPU que usas. Por ejemplo, nvidia-tesla-t4.

    • DRIVER_VERSION: la versión del controlador de la GPU que GKE debe instalar automáticamente. Este campo es opcional. Se admiten los siguientes valores:

      • INSTALLATION_DISABLED: inhabilita la instalación automática de controladores de GPU. Debes instalar manualmente los controladores 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 automáticamente la versión predeterminada del controlador para la versión del sistema operativo de tu nodo. En la versión 1.30.1-gke.1156000 de GKE y versiones posteriores, si omites este campo, esta será la opción predeterminada. En versiones anteriores, GKE no instala un controlador si omite este campo.
      • LATEST: instala automáticamente la versión más reciente del controlador disponible para la versión del SO de tu nodo. Solo disponible para los nodos que usan Container-Optimized OS.

      Si omite este campo, GKE no instalará automáticamente un controlador. Este campo no se admite en grupos de nodos que usan el aprovisionamiento automático de nodos. Para instalar un controlador manualmente, consulta la sección Instalar manualmente los controladores de GPU NVIDIA de este documento.

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

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

      En el resto de las GPUs, esta marca es opcional.

  2. Añade el siguiente bloque a tu 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 para crear un clúster con un grupo de nodos que usa GPUs. Google Cloud El grupo de nodos tiene inicialmente tres nodos y el autoescalado está habilitado. Para obtener más información sobre Terraform, consulta la especificación de recursos google_container_node_pool en terraform.io.

Práctica recomendada:

Para evitar que se te apliquen más costes, elimina 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 con GPUs y especificar zonas con la marca --node-locations. Sin embargo, te recomendamos que crees un grupo de nodos de GPU independiente en un clúster ya creado, como se muestra en esta sección.

Instalar manualmente los controladores de las GPU NVIDIA

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

  • Has inhabilitado la instalación automática de controladores de dispositivos al crear un grupo de nodos de GPU.
  • Usas una versión de GKE anterior a la versión mínima admitida 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 controlador predeterminado o más reciente con instalación automática. Por ejemplo, usar GPUs con nodos de GKE confidenciales.
Práctica recomendada:

Utiliza la instalación automática de controladores siempre que sea posible. Para ello, especifica la opción gpu-driver-version en la marca --accelerator al crear el clúster estándar. Si has usado el DaemonSet de instalación para instalar manualmente los controladores de GPU antes del 25 de enero del 2023 (inclusive), es posible que tengas que volver a aplicar el DaemonSet para obtener una versión que ignore los nodos que usen la instalación automática de controladores.

Para ejecutar el DaemonSet de instalación, el grupo de nodos de GPU requiere el permiso https://www.googleapis.com/auth/devstorage.read_only para comunicarse con Cloud Storage. Sin este ámbito, no se podrá descargar el manifiesto de DaemonSet de instalación. Este ámbito es uno de los ámbitos predeterminados, que se suele añadir al crear el clúster.

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

COS

  • Para desplegar el DaemonSet de instalación e 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 la GPU de la tabla de versiones de controladores de 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 completada la instalación, el complemento de dispositivo de GPU NVIDIA usa la API de Kubernetes para que la capacidad de GPU NVIDIA esté disponible.

Cada versión de Container-Optimized OS tiene al menos una versión compatible del controlador de GPU NVIDIA. Para obtener más información sobre cómo asignar la versión del controlador de GPU a la versión de GKE, puedes hacer lo siguiente:

Versiones de controladores 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 o R550
1,26 R470 (predeterminado), R525, R535 o R550

Ubuntu

El DaemonSet de instalación que despliegues dependerá del tipo de GPU y de la versión del nodo de GKE, tal como se indica a continuación:

  • En todas las GPUs excepto las GPUs 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

  • En el caso de las GPUs NVIDIA H200, instala el R550controlador:

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

En la siguiente tabla se indican 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 en función del tipo de nodos. En ambos casos, debe configurar el kubectl_manifesttipo de recurso de Terraform.

  • Para instalar el DaemonSet en COS, añade 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, añade 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/ubuntu/daemonset-preloaded.yaml"
  }

  resource "kubectl_manifest" "nvidia_driver_installer" {
    yaml_body = data.http.nvidia_driver_installer_manifest.body
  }

Asignar la versión de GKE y la versión de la 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 corresponden con las versiones de GKE y las versiones de la imagen de nodo de Container-Optimized OS, sigue estos pasos:
  1. Asocia las versiones de la imagen de nodo de Container-Optimized OS a las versiones de parche de GKE de la versión de GKE específica en la que quieras 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 de 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 de la milestone específica, busca la nota de la versión correspondiente a la versión de la imagen de nodo de Container-Optimized OS. Por ejemplo, en las notas de la versión de Container-Optimized OS: 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.

Instalar controladores mediante el aprovisionamiento automático de nodos con GPUs

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 conceder los ámbitos necesarios, modifica los ámbitos predeterminados del aprovisionamiento automático de nodos para añadir 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 de GKE o una posterior, GKE instala automáticamente la versión predeterminada del controlador NVIDIA en todos los nodos de GPU, incluidos los creados con el aprovisionamiento automático de nodos. Puedes saltarte las siguientes instrucciones en los clústeres en los que se ejecute GKE 1.32.2-gke.1297000 o una versión posterior.

En la versión 1.29.2-gke.1108000 de GKE y versiones posteriores, puedes seleccionar una versión del controlador de GPU para que GKE la instale automáticamente en los nodos de GPU aprovisionados automáticamente. Añade el siguiente campo al archivo de manifiesto:

spec:
  nodeSelector:
    cloud.google.com/gke-gpu-driver-version: "DRIVER_VERSION"

Sustituye DRIVER_VERSION por uno de los siguientes valores:

  • default: el controlador predeterminado y estable para tu versión de GKE del nodo.
  • latest: la versión del controlador más reciente disponible para tu nodo versión de GKE.
  • disabled: inhabilita la instalación automática de controladores 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 omite el selector de nodos.

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

Configurar pods para que utilicen las GPUs

Utilizas un límite de recursos para configurar los pods de forma que consuman GPUs. Puedes especificar un límite de recursos en una especificación de pod con el siguiente par clave-valor:

  • Clave: nvidia.com/gpu
  • Valor: número de GPUs que se van a consumir.

alpha.kubernetes.io/nvidia-gpu no se admite como nombre de recurso en GKE. En su lugar, usa nvidia.com/gpu como nombre de recurso.

El siguiente manifiesto es un ejemplo de una especificación de Pod que consume GPUs:

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

Usar varios tipos de GPU

Si deseas utilizar varios tipos de acelerador de GPU por clúster, debes crear varios grupos de nodos, cada uno con su propio tipo de acelerador. GKE asigna un selector de nodos único a los nodos de GPU para colocar cargas de trabajo de GPU en 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 orientar a tipos de GPU concretos añadiendo este selector de nodos a la especificación del pod de tu carga de trabajo. Por ejemplo:

apiVersion: v1
kind: Pod
metadata:
  name: my-gpu-pod
spec:
  containers:
  - name: my-gpu-container
    image: nvidia/cuda:11.0.3-runtime-ubuntu20.04
    command: ["/bin/bash", "-c", "--"]
    args: ["while true; do sleep 600; done;"]
    resources:
      limits:
       nvidia.com/gpu: 2
  nodeSelector:
    cloud.google.com/gke-accelerator: nvidia-tesla-t4

Actualizar grupos de nodos con aceleradores (GPUs y TPUs)

GKE actualiza automáticamente los clústeres estándar, incluidos los grupos de nodos. También puedes actualizar manualmente los grupos de nodos si quieres que tus nodos tengan una versión posterior antes. Para controlar cómo funcionan las actualizaciones en tu clúster, usa los canales de lanzamiento, las ventanas y exclusiones de mantenimiento y la secuencia de lanzamiento.

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

Para usar una estrategia de actualización de nodos, GKE debe aprovisionar recursos adicionales temporalmente, en función de 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 al intentar crear más nodos con GPUs o TPUs), consulta Actualizar en un entorno con recursos limitados.

Acerca de las bibliotecas NVIDIA CUDA-X

CUDA es la plataforma de computación paralela y el modelo de programación de NVIDIA para GPUs. Para usar aplicaciones CUDA, la imagen que utilices debe tener las bibliotecas. Para añadir las bibliotecas NVIDIA CUDA-X, puedes crear y usar tu propia imagen incluyendo los siguientes valores en la variable de entorno LD_LIBRARY_PATH de la especificación de tu contenedor:

  • /usr/local/nvidia/lib64: la ubicación de los controladores de dispositivos NVIDIA.
  • /usr/local/cuda-CUDA_VERSION/lib64: la ubicación de las bibliotecas NVIDIA CUDA-X en el nodo.

    Sustituye CUDA_VERSION por la versión de la imagen de CUDA-X que has usado. Algunas versiones también contienen utilidades de depuración en /usr/local/nvidia/bin. Para obtener más información, consulta la imagen de NVIDIA CUDA en Docker Hub.

    Para comprobar la versión mínima del controlador de la GPU que se necesita para tu versión de CUDA, consulta CUDA Toolkit and Compatible Driver Versions (CUDA Toolkit y 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 la GPU que sea compatible con la versión de CUDA que hayas elegido. Para obtener más información sobre cómo asignar la versión del controlador de GPU a la versión de GKE, consulta el artículo Asignar la versión de GKE y la versión de la imagen de nodo de Container-Optimized OS a la versión del controlador de GPU.

Monitorizar el rendimiento de la carga de trabajo de los nodos de GPU

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

  • Ciclo de trabajo (container/accelerator/duty_cycle): Porcentaje del tiempo durante el último periodo de muestreo (10 segundos) en el que el acelerador ha estado procesando activamente. 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.

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

Puedes usar paneles de control predefinidos para monitorizar tus clústeres con nodos de GPU. Para obtener más información, consulta Ver métricas de observabilidad. Para obtener información general sobre la monitorización de tus clústeres y sus recursos, consulta Observabilidad de GKE.

Ver métricas de uso de cargas de trabajo

Puedes ver las métricas de uso de GPU de tus cargas de trabajo en el panel de control Cargas de trabajo de la Google Cloud consola.

Para ver el uso de GPU de tu carga de trabajo, sigue estos pasos:

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

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

En el panel de control Cargas de trabajo se muestran gráficos sobre el uso y la capacidad de la memoria de la GPU, así como el ciclo de actividad de la GPU.

Ver métricas de NVIDIA Data Center GPU Manager (DCGM)

Puedes recoger y visualizar métricas de NVIDIA DCGM mediante Google Cloud Managed Service para Prometheus. En el caso de los clústeres de Autopilot, GKE instala los controladores. En los clústeres estándar, debes instalar los controladores de NVIDIA.

Para obtener instrucciones sobre cómo implementar el paquete DCGM gestionado por GKE, consulta el artículo Recoger y ver métricas de NVIDIA Data Center GPU Manager (DCGM).

Configurar la finalización correcta de los nodos de GPU

En los clústeres de GKE con el plano de control que ejecuta la versión 1.29.1-gke.1425000 o una posterior, los nodos de GPU admiten 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 de forma que finalice tus cargas de trabajo correctamente en este plazo de notificación, sigue los pasos que se indican en Gestionar interrupciones de nodos de GKE para GPUs y TPUs.

Siguientes pasos