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

Estándar

Esta página te ayuda a decidir cuándo usar el operador de GPU de NVIDIA y te muestra cómo habilitar el operador de GPU de NVIDIA en GKE.

Descripción general

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

El operador de GPU de NVIDIA es un operador de Kubernetes que proporciona una API y una infraestructura comunes para implementar, configurar y administrar los componentes de software necesarios para aprovisionar las GPU de NVIDIA en un clúster de Kubernetes. El operador de GPU de NVIDIA te proporciona una experiencia coherente, simplifica la administració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 de NVIDIA?

Te recomendamos que uses la administración de GPU de GKE para tus nodos de GPU, ya que GKE administra por completo el ciclo de vida de los nodos de GPU. Si deseas comenzar a usar GKE para administrar tus nodos de GPU, elige una de estas opciones:

Como alternativa, el operador de GPU de NVIDIA puede ser una opción adecuada si buscas una experiencia coherente entre varios proveedores de servicios en la nube, si ya usas el operador de GPU de NVIDIA o si usas el software que depende del operador de GPU de NVIDIA.

Para obtener más información que te permita decidir entre estas opciones, consulta Administra 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 en modo Autopilot.
El operador de GPU de NVIDIA no es compatible con las imágenes de nodos de Windows.
GKE no administra el operador de GPU de NVIDIA. Para actualizar el operador de GPU de NVIDIA, consulta la documentación de NVIDIA.

Antes de comenzar

Antes de comenzar, asegúrate de haber realizado las siguientes tareas:

Habilita la API de Google Kubernetes Engine.

Habilitar la API de Google Kubernetes Engine

Si deseas usar Google Cloud CLI para esta tarea, instala y, luego, inicializa gcloud CLI. Si ya instalaste gcloud CLI, ejecuta gcloud components update para obtener la versión más reciente.
Nota: Para las instalaciones de gcloud CLI existentes, asegúrate de configurar las propiedades compute/region y compute/zone. Cuando configuras las ubicaciones predeterminadas, puedes evitar errores en la CLI de gcloud como el siguiente: One of [--zone, --region] must be supplied: Please specify location.

Asegúrate de cumplir con los requisitos que se indican en Ejecuta GPU en grupos de nodos estándar.
Verifica que tengas Helm instalado en tu entorno de desarrollo. Helm forma parte de las herramientas instaladas previamente en Cloud Shell.

Si bien no hay un requisito específico de una versión de Helm, puedes usar el siguiente comando para verificar que tengas Helm instalado.
```
helm version
```
Si el resultado es similar a Command helm not found, puedes instalar la CLI de Helm mediante la ejecución de 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
```

Crea y configura 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 mediante las instrucciones para crear un grupo de nodos de GPU con las siguientes modificaciones:
- Establece gpu-driver-version=disabled para saltar la instalación automática del controlador de GPU, ya que no es compatible con el operador de GPU de NVIDIA.
- Establece --node-labels="gke-no-default-nvidia-gpu-device-plugin=true" para inhabilitar el DaemonSet del complemento de dispositivo de GPU administrado de GKE.
Ejecuta el siguiente comando y agrega otras marcas para la creación del 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"
```
Reemplaza lo siguiente:
- POOL_NAME es el nombre que eliges para el grupo de nodos.
- GPU_TYPE: es el tipo de acelerador de GPU que quieres usar. Por ejemplo, nvidia-h100-80gb.
- AMOUNT: Es la cantidad de GPU que se deben adjuntar a los nodos del grupo de nodos.
Por ejemplo, el siguiente comando crea un grupo de nodos de GKE, a3nodepool, con las GPU H100 en el clúster zonal a3-cluster. En este ejemplo, se inhabilitan el daemonset del complemento de dispositivos de GPU de GKE y la instalación automática de controladores.
```
gcloud container node-pools create a3nodepool \
  --region=us-central1 --cluster=a3-cluster \
  --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
```
Ejecuta el siguiente comando para obtener las credenciales de autenticación del clúster:
```
USE_GKE_GCLOUD_AUTH_PLUGIN=True \
gcloud container clusters get-credentials CLUSTER_NAME [--zone COMPUTE_ZONE] [--region COMPUTE_REGION]
```
Reemplaza lo siguiente:
- CLUSTER_NAME: es el nombre del clúster que contiene tu grupo de nodos.
- COMPUTE_REGION o COMPUTE_ZONE: especifica la región o la zona del clúster en función de si tu clúster es regional o zonal, respectivamente.
El resultado es similar a este:
```
Fetching cluster endpoint and auth data.
kubeconfig entry generated for CLUSTER_NAME.
```
Verifica que puedes conectarte al clúster (opcional).
```
kubectl get nodes -o wide
```
Deberías ver una lista de todos los nodos que se ejecutan en este clúster.
Crea el espacio de nombres gpu-operator para el operador de GPU de NVIDIA mediante la ejecución de este comando:
```
kubectl create ns gpu-operator
```
El resultado es similar a este:
```
namespace/gpu-operator created
```

Crea una cuota de recursos en el espacio de nombres gpu-operator mediante la ejecución del siguiente 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 es similar a este:

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 es similar a este:

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

Instala de forma manual los controladores en tus nodos de Container-Optimized OS o Ubuntu. Para obtener instrucciones detalladas, consulta Instala controladores de GPU de NVIDIA de forma manual.
- Si usas COS, ejecuta los siguientes comandos para implementar el DaemonSet de instalación y, luego, 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 implementes depende del tipo de GPU y de la versión del nodo de GKE, como se describe en la sección de Ubuntu de las instrucciones.

Ejecuta el siguiente comando para verificar la versión del controlador de GPU:

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

Si la instalación del controlador de GPU se realiza de forma correcta, el resultado es 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.

Instala el operador de GPU de NVIDIA

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

Agrega el repositorio de Helm para NVIDIA:

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

Instala el operador de GPU de NVIDIA con Helm y las siguientes opciones de configuración:
- Asegúrate de que la versión del Operador de GPU sea 24.6.0 o posterior.
- Configura la ruta de instalación del controlador en el operador de GPU con hostPaths.driverInstallDir=/home/kubernetes/bin/nvidia.
- Establece la ruta de instalación del kit de herramientas toolkit.installDir=/home/kubernetes/bin/nvidia para COS y Ubuntu. En COS, el directorio /home se puede escribir y funciona como una ubicación con estado para almacenar los objetos binarios del entorno de ejecución de NVIDIA. Para obtener más información, consulta la descripción general de discos y sistemas 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 heredado no es compatible. CDI es necesario para COS y 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 esta configuración, consulta las opciones comunes de personalización de gráficos y las situaciones de implementación comunes en la documentación de NVIDIA.

Verifica que el operador de GPU de NVIDIA esté instalado correctamente.

Para comprobar que los operandos del operador de GPU se ejecuten de forma correcta, 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 GPU esté configurado de forma correcta en el campo “Asignable” del nodo, ejecuta el siguiente comando:

kubectl describe node GPU_NODE_NAME | grep Allocatable -A7

Reemplaza GPU_NODE_NAME por el nombre del nodo que tiene las GPU.

El resultado es similar a este:

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 GPU se ejecute de forma correcta, puedes usar la herramienta de 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

Luego, ejecuta el comando siguiente:

kubectl logs cuda-vectoradd

El resultado es similar a este:

[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

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

Descripción general

¿Por qué usar el operador de GPU de NVIDIA?

Limitaciones

Antes de comenzar

Crea y configura el grupo de nodos de GPU

Instala el operador de GPU de NVIDIA

¿Qué sigue?