Es posible que parte de la información de esta página (o toda) no se aplique a Trusted Cloud de S3NS.

Esta página se ha traducido con Cloud Translation API.

Gestionar la pila de GPU con el operador de GPU NVIDIA en Google Kubernetes Engine (GKE)

Estándar

En esta página se explica cuándo usar el operador de GPU NVIDIA y cómo habilitarlo en GKE.

Información general

Los operadores son extensiones de software de Kubernetes que permiten a los usuarios crear recursos personalizados que gestionan aplicaciones y sus componentes. Puedes usar operadores para automatizar tareas complejas que van más allá de lo que ofrece Kubernetes, como desplegar y actualizar aplicaciones.

El operador de GPU NVIDIA es un operador de Kubernetes que proporciona una infraestructura y una API comunes para desplegar, configurar y gestionar los componentes de software necesarios para aprovisionar GPUs NVIDIA en un clúster de Kubernetes. El operador de GPU NVIDIA te ofrece una experiencia coherente, simplifica la gestión de recursos de GPU y optimiza la integración de cargas de trabajo aceleradas por GPU en Kubernetes.

¿Por qué usar el operador de GPU NVIDIA?

Te recomendamos que uses la gestión de GPUs de GKE para tus nodos de GPU, ya que GKE gestiona por completo el ciclo de vida de los nodos de GPU. Para empezar a usar GKE para gestionar tus nodos de GPU, elige una de estas opciones:

Por otro lado, el operador de GPU NVIDIA puede ser una opción adecuada si buscas una experiencia coherente en varios proveedores de servicios en la nube, si ya lo estás usando o si utilizas software que depende de él.

Para obtener más información sobre qué opción elegir, consulta Gestionar la pila de GPU a través de GKE o el operador de GPU de NVIDIA en GKE.

Limitaciones

El operador de GPU de NVIDIA es compatible con las imágenes de nodo de Container-Optimized OS (COS) y Ubuntu, con las siguientes limitaciones:

El operador de GPU de NVIDIA es compatible con GKE a partir de la versión 24.6.0 del operador de GPU o una posterior.
El operador de GPU de NVIDIA no es compatible con los clústeres de Autopilot.
El operador de GPU de NVIDIA no es compatible con las imágenes de nodos de Windows.
GKE no gestiona el operador de GPU NVIDIA. Para actualizar el operador de GPU NVIDIA, consulta la documentación de NVIDIA.

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.
Nota: Si ya tienes instalada la CLI de gcloud, asegúrate de definir la compute/region propiedad. Si usas principalmente clústeres zonales, define compute/zone en su lugar. Si defines una ubicación predeterminada, puedes evitar errores en gcloud CLI como el siguiente: One of [--zone, --region] must be supplied: Please specify location. Es posible que tengas que especificar la ubicación en determinados comandos si la ubicación de tu clúster es diferente de la predeterminada que hayas definido.

Asegúrate de que cumples los requisitos que se indican en el artículo Ejecutar GPUs en grupos de nodos Estándar.
Verifica que tienes Helm instalado en tu entorno de desarrollo. Helm viene preinstalado en Cloud Shell.

Aunque no hay ningún requisito específico de versión de Helm, puedes usar el siguiente comando para verificar que tienes Helm instalado.
```
helm version
```
Si el resultado es similar a Command helm not found, puedes instalar la CLI de Helm ejecutando este comando:
```
curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/master/scripts/get-helm-3 \
  && chmod 700 get_helm.sh \
  && ./get_helm.sh
```

Crear y configurar el grupo de nodos de GPU

Para crear y configurar el grupo de nodos de GPU, sigue estos pasos:

Crea un grupo de nodos de GPU siguiendo las instrucciones para crear un grupo de nodos de GPU con las siguientes modificaciones:
- Define gpu-driver-version=disabled para omitir la instalación automática de los controladores de la GPU, ya que no se admite cuando se usa el operador de GPU NVIDIA.
- Define --node-labels="gke-no-default-nvidia-gpu-device-plugin=true" en para inhabilitar el DaemonSet del complemento de dispositivo de GPU gestionado por GKE.
Ejecuta el siguiente comando y añade otras marcas para crear el grupo de nodos de GPU según sea necesario:
```
gcloud container node-pools create POOL_NAME \
  --accelerator type=GPU_TYPE,count=AMOUNT,gpu-driver-version=disabled \
  --node-labels="gke-no-default-nvidia-gpu-device-plugin=true"
```
Haz los cambios siguientes:
- POOL_NAME el nombre que has elegido para el grupo de nodos.
- GPU_TYPE: el tipo de acelerador de GPU que quieras usar. Por ejemplo, nvidia-h100-80gb.
- AMOUNT: número de GPUs que se van a asociar a los nodos del grupo de nodos.
Por ejemplo, el siguiente comando crea un grupo de nodos de GKE, a3nodepool, con GPUs H100 en el clúster zonal a3-cluster. En este ejemplo, el DaemonSet del complemento de dispositivo de GPU de GKE y la instalación automática de controladores están inhabilitados.
```
gcloud container node-pools create a3nodepool \
  --cluster=a3-cluster \
  --location=us-central1 \
  --node-locations=us-central1-a \
  --accelerator=type=nvidia-h100-80gb,count=8,gpu-driver-version=disabled \
  --machine-type=a3-highgpu-8g \
  --node-labels="gke-no-default-nvidia-gpu-device-plugin=true" \
  --num-nodes=1
```
Para obtener las credenciales de autenticación del clúster, ejecuta el siguiente comando:
```
USE_GKE_GCLOUD_AUTH_PLUGIN=True \
gcloud container clusters get-credentials CLUSTER_NAME \
  --location CONTROL_PLANE_LOCATION
```
Haz los cambios siguientes:
- CLUSTER_NAME: el nombre del clúster que contiene tu 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.
El resultado debería ser similar al siguiente:
```
Fetching cluster endpoint and auth data.
kubeconfig entry generated for CLUSTER_NAME.
```
(Opcional) Verifica que puedes conectarte al clúster.
```
kubectl get nodes -o wide
```
Debería aparecer una lista con todos los nodos que se ejecutan en este clúster.
Crea el espacio de nombres gpu-operator para el operador de GPU NVIDIA ejecutando este comando:
```
kubectl create ns gpu-operator
```
El resultado debería ser similar al siguiente:
```
namespace/gpu-operator created
```

Crea una cuota de recursos en el espacio de nombres gpu-operator ejecutando este comando:

kubectl apply -n gpu-operator -f - << EOF
apiVersion: v1
kind: ResourceQuota
metadata:
  name: gpu-operator-quota
spec:
  hard:
    pods: 100
  scopeSelector:
    matchExpressions:
    - operator: In
      scopeName: PriorityClass
      values:
        - system-node-critical
        - system-cluster-critical
EOF

El resultado debería ser similar al siguiente:

resourcequota/gpu-operator-quota created

Consulta la cuota de recursos del espacio de nombres gpu-operator:

kubectl get -n gpu-operator resourcequota gpu-operator-quota

El resultado debería ser similar al siguiente:

NAME                 AGE     REQUEST       LIMIT
gpu-operator-quota   2m27s   pods: 0/100

Instala los controladores manualmente en tus nodos de Container-Optimized OS o Ubuntu. Para obtener instrucciones detalladas, consulta el artículo Instalar manualmente los controladores de las GPU NVIDIA.
- Si usas COS, ejecuta los siguientes comandos para implementar el DaemonSet de instalación e instalar la versión predeterminada del controlador de GPU:
```
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml
```
- Si usas 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 describe en la sección de Ubuntu de las instrucciones.

Para verificar la versión del controlador de la GPU, ejecuta este comando:

kubectl logs -l k8s-app=nvidia-driver-installer  \
  -c "nvidia-driver-installer" --tail=-1 -n kube-system

Si la instalación del controlador de la GPU se completa correctamente, el resultado será similar al siguiente:

I0716 03:17:38.863927    6293 cache.go:66] DRIVER_VERSION=535.183.01
…
I0716 03:17:38.863955    6293 installer.go:58] Verifying GPU driver installation
I0716 03:17:41.534387    6293 install.go:543] Finished installing the drivers.

Instalar el operador de GPU NVIDIA

En esta sección se muestra cómo instalar el operador de GPU NVIDIA con Helm. Para obtener más información, consulta la documentación de NVIDIA sobre la instalación del operador de GPU de NVIDIA.

Añade el repositorio de Helm de NVIDIA:

helm repo add nvidia https://helm.ngc.nvidia.com/nvidia \
  && helm repo update

Instala el operador de GPU NVIDIA con Helm y las siguientes opciones de configuración:
- Asegúrate de que la versión del operador de GPU sea la 24.6.0 o una posterior.
- Configura la ruta de instalación del controlador en el operador de GPU con hostPaths.driverInstallDir=/home/kubernetes/bin/nvidia.
- Define la ruta de instalación del kit de herramientas toolkit.installDir=/home/kubernetes/bin/nvidia tanto para COS como para Ubuntu. En COS, el directorio /home se puede escribir y sirve como ubicación con estado para almacenar los archivos binarios del tiempo de ejecución de NVIDIA. Para obtener más información, consulta la sección Información general sobre los discos y el sistema de archivos de COS.
- Habilita la interfaz de dispositivo de contenedor (CDI) en el operador de GPU con cdi.enabled=true y cdi.default=true, ya que el modo antiguo no es compatible. Se requiere CDI tanto para COS como para Ubuntu en GKE.
```
helm install --wait --generate-name \
  -n gpu-operator \
  nvidia/gpu-operator \
  --set hostPaths.driverInstallDir=/home/kubernetes/bin/nvidia \
  --set toolkit.installDir=/home/kubernetes/bin/nvidia \
  --set cdi.enabled=true \
  --set cdi.default=true \
  --set driver.enabled=false
```
Para obtener más información sobre estos ajustes, consulta las secciones Opciones de personalización de gráficos comunes y Situaciones de implementación comunes de la documentación de NVIDIA.

Verifica que el operador de GPU NVIDIA se haya instalado correctamente.

Para comprobar que los operandos de GPU Operator se están ejecutando correctamente, ejecuta el siguiente comando.

kubectl get pods -n gpu-operator

El resultado es similar al siguiente:

NAME                                                          READY    STATUS
RESTARTS   AGE
gpu-operator-5c7cf8b4f6-bx4rg                                 1/1      Running   0          11m
gpu-operator-node-feature-discovery-gc-79d6d968bb-g7gv9       1/1      Running   0          11m
gpu-operator-node-feature-discovery-master-6d9f8d497c-thhlz   1/1      Running   0          11m
gpu-operator-node-feature-discovery-worker-wn79l              1/1      Running   0          11m
gpu-feature-discovery-fs9gw                                   1/1      Running   0          8m14s
gpu-operator-node-feature-discovery-worker-bdqnv              1/1      Running   0          9m5s
nvidia-container-toolkit-daemonset-vr8fv                      1/1      Running   0          8m15s
nvidia-cuda-validator-4nljj                                   0/1      Completed 0          2m24s
nvidia-dcgm-exporter-4mjvh                                    1/1      Running   0          8m15s
nvidia-device-plugin-daemonset-jfbcj                          1/1      Running   0          8m15s
nvidia-mig-manager-kzncr                                      1/1      Running   0          2m5s
nvidia-operator-validator-fcrr6                               1/1      Running   0          8m15s

Para comprobar que el recuento de GPUs se ha configurado correctamente en el campo "Allocatable" del nodo, ejecuta el siguiente comando:

kubectl describe node GPU_NODE_NAME | grep Allocatable -A7

Sustituye GPU_NODE_NAME por el nombre del nodo que tiene GPUs.

El resultado debería ser similar al siguiente:

Allocatable:
cpu:                11900m
ephemeral-storage:  47060071478
hugepages-1Gi:      0
hugepages-2Mi:      0
memory:             80403000Ki
nvidia.com/gpu:     1           # showing correct count of GPU associated with the nods
pods:               110

Para comprobar que la carga de trabajo de la GPU se ejecuta correctamente, puedes usar la herramienta cuda-vectoradd:

cat << EOF | kubectl create -f -
apiVersion: v1
kind: Pod
metadata:
  name: cuda-vectoradd
spec:
  restartPolicy: OnFailure
  containers:
  - name: vectoradd
    image: nvidia/samples:vectoradd-cuda11.2.1
    resources:
      limits:
        nvidia.com/gpu: 1
EOF

A continuación, ejecuta el siguiente comando:

kubectl logs cuda-vectoradd

El resultado debería ser similar al siguiente:

[Vector addition of 50000 elements]
Copy input data from the host memory to the CUDA device
CUDA kernel launch with 196 blocks of 256 threads
Copy output data from the CUDA device to the host memory
Test PASSED
Done

Gestionar la pila de GPU con el operador de GPU NVIDIA en Google Kubernetes Engine (GKE)

Información general

¿Por qué usar el operador de GPU NVIDIA?

Limitaciones

Antes de empezar

Crear y configurar el grupo de nodos de GPU

Instalar el operador de GPU NVIDIA

Siguientes pasos