Ejecuta GPU en grupos de nodos de GKE Standard (original) (raw)

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áginaGPUs 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:

Requisitos para las GPUs en GKE

Las GPU en GKE tienen los siguientes requisitos:

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:

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:

  1. Ve a la página IAM y administración en la consola de Google Cloud.
    Ir a Cuotas
  2. En la casilla Filtro, haz lo siguiente:
    1. Selecciona la propiedad de Cuota, ingresa el nombre del modelo de GPU y presiona Intro.
    2. (Opcional) Para aplicar filtros más avanzados para limitar los resultados, selecciona la propiedad Dimensiones (p. ej., ubicaciones), agrega el nombre de la región o zona que usas y presiona Intro.
  3. En la lista de cuotas de GPU, selecciona la que deseas cambiar.
  4. Haz clic en Editar cuotas. Se abrirá un formulario de solicitud.
  5. Completa el campo Nuevo límite de cuota para cada solicitud de cuotas.
  6. Completa el campo Descripción de la solicitud con los detalles sobre tu solicitud.
  7. Haz clic en Siguiente.
  8. En el cuadro de diálogo Confirmación de anulación, haz clic en Confirmar.
  9. En la pantalla Detalles de contacto, ingresa tu nombre y un número de teléfono que los responsables de aprobación podrán usar para completar la solicitud de cambio de cuota.
  10. Haz clic en Enviar solicitud.
  11. Recibirás un correo electrónico de confirmación para realizar un seguimiento del cambio de cuota.

Ejecuta 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:

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:

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:

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:

  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:
  1. Haz clic en Crear.

Terraform

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

  1. Para configurar las variables de Terraform, incluye el siguiente bloque en el archivo variables.tf:
variable "project_id" {  
  default     = PROJECT_ID  
  description = "the gcp_name_short project where GKE creates the cluster"  
}  
variable "region" {  
  default     = CLUSTER_REGION  
  description = "the gcp_name_short region where GKE creates the cluster"  
}  
variable "zone" {  
  default     = "COMPUTE_ZONE1,COMPUTE_ZONE2"  
  description = "the GPU nodes zone"  
}  
variable "cluster_name" {  
  default     = "CLUSTER_NAME"  
  description = "the name of the cluster"  
}  
variable "gpu_type" {  
  default     = "GPU_TYPE"  
  description = "the GPU accelerator type"  
}  
variable "gpu_driver_version" {  
  default = "DRIVER_VERSION"  
  description = "the NVIDIA driver version to install"  
}  
variable "machine_type" {  
  default = "MACHINE_TYPE"  
  description = "The Compute Engine machine type for the VM"  
}

Reemplaza lo siguiente:

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.

Esta marca es opcional para todas las demás GPU. 2. Agrega el siguiente bloque a la configuración de Terraform: 

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

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

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:

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

  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  
  }  
  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:

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:

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:

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:

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:

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

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

Puedes ver las métricas de uso de GPU de tu carga de trabajo desde el panel de Cargas de trabajo en la consola de Google Cloud.

Para ver el uso de GPU de tu carga de trabajo, realiza los siguientes pasos:

  1. Ve a la página Cargas de trabajo en la consola de Google Cloud.
    Ir a Cargas de trabajo
  2. Selecciona una carga de trabajo.

El panel de las cargas de trabajo muestra los gráficos para el uso y la capacidad de la memoria de GPU y el ciclo de trabajo de GPU.

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

Puedes recopilar y visualizar métricas de NVIDIA DCGM a través deGoogle 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.

¿Qué sigue?