Uso de GPU para cargas de trabajo de cálculo intensivo en Azure Kubernetes Service (AKS)

Por lo general, las unidades de procesamiento gráfico (GPU) se usan para cargas de trabajo de cálculo intensivo, como cargas de trabajo de visualización y gráficos. AKS admite grupos de nodos Linux habilitados para GPU para ejecutar cargas de trabajo de Kubernetes que consumen muchos procesos.

Este artículo le permite aprovisionar nodos con GPU programables en clústeres de AKS nuevos y existentes.

Máquinas virtuales habilitadas para GPU compatibles

Para ver las máquinas virtuales habilitadas para GPU disponibles, consulte Tamaños de máquina virtual optimizados para GPU en Azure. Si un tamaño de máquina virtual con GPU no está en nuestra lista de tamaños de máquina virtual compatibles, AKS no instala los componentes de software de GPU necesarios ni proporciona compatibilidad. AKS permite el uso de tamaños de máquina virtual de GPU no admitidos después de omitir la instalación automática del controlador de GPU.

Compruebe los tamaños de máquina virtual disponibles y admitidos mediante el az vm list-skus comando .

az vm list-skus --location <your-location> --output table

Para grupos de nodos de AKS, se recomienda un tamaño mínimo de Standard_NC6s_v3. La serie NVv4 (basada en GPU de AMD) no es compatible con AKS.

Limitaciones

• Si usa un grupo de nodos habilitados para GPU de Linux de Azure, no se aplican revisiones de seguridad automáticas. Consulte la versión actual de su API de AKS para conocer el comportamiento predeterminado del canal de actualización del SO del nodo.
• Flatcar Container Linux para AKS no es compatible con GPU NVIDIA en AKS.
• Azure Linux con protección de sistema operativo para AKS no se admite con GPU NVIDIA en AKS.

• No se admite la actualización de un grupo de nodos existente para agregar el tamaño de máquina virtual de GPU en AKS.

Antes de empezar

• Este artículo supone que ya tiene un clúster de AKS. Si no dispone de un clúster, cree uno mediante Azure CLI, Azure PowerShell o el Azure Portal.
• Necesita la versión 2.72.2 de la CLI de Azure o posterior instalada para establecer el --gpu-driver campo. Ejecute az --version para encontrar la versión. Si necesita instalarla o actualizarla, vea Instalación de la CLI de Azure.
• Si tiene instalada la extensión de la aks-preview CLI de Azure, actualice la versión a 18.0.0b2 o posterior.

Obtención de las credenciales del clúster

Obtenga las credenciales del clúster de AKS mediante el comando az aks get-credentials. Con el siguiente comando de ejemplo se obtienen las credenciales del clúster myAKSCluster en el grupo de recursos myResourceGroup:

az aks get-credentials --resource-group myResourceGroup --name myAKSCluster

Opciones para usar GPU de NVIDIA

El uso de GPU de NVIDIA implica la instalación de varios componentes de software NVIDIA, como el complemento de dispositivo NVIDIA para Kubernetes, la instalación del controlador de GPU, etc.

Instalación del complemento de dispositivo NVIDIA

La instalación del complemento de dispositivo NVIDIA es necesaria cuando se usan GPU en AKS. En algunos casos, la instalación se controla automáticamente, como cuando se usa el operador de GPU de NVIDIA. Además, puede instalar manualmente el complemento del dispositivo NVIDIA.

Instalar manualmente el complemento de dispositivo NVIDIA.

Puede implementar un DaemonSet para el complemento de dispositivo NVIDIA, que ejecuta un pod en cada nodo para proporcionar los controladores necesarios para las GPU. Este es el enfoque recomendado al usar grupos de nodos habilitados para GPU para Azure Linux.

az aks nodepool add \
    --resource-group myResourceGroup \
    --cluster-name myAKSCluster \
    --name gpunp \
    --node-count 1 \
    --node-vm-size Standard_NC6s_v3 \
    --node-taints sku=gpu:NoSchedule \
    --enable-cluster-autoscaler \
    --min-count 1 \
    --max-count 3

az aks nodepool add \
    --resource-group myResourceGroup \
    --cluster-name myAKSCluster \
    --name gpunp \
    --node-count 1 \
    --os-sku AzureLinux \
    --node-vm-size Standard_NC6s_v3 \
    --node-taints sku=gpu:NoSchedule \
    --enable-cluster-autoscaler \
    --min-count 1 \
    --max-count 3

1. Cree un espacio de nombres mediante el comando kubectl create namespace.

   kubectl create namespace gpu-resources
   

2. Cree un archivo llamado nvidia-device-plugin-ds.yaml y pegue el siguiente manifiesto YAML proporcionado como parte del proyecto NVIDIA device plugin for Kubernetes:

   apiVersion: apps/v1
   kind: DaemonSet
   metadata:
     name: nvidia-device-plugin-daemonset
     namespace: gpu-resources
   spec:
     selector:
       matchLabels:
         name: nvidia-device-plugin-ds
     updateStrategy:
       type: RollingUpdate
     template:
       metadata:
         labels:
           name: nvidia-device-plugin-ds
       spec:
         tolerations:
         - key: "sku"
           operator: "Equal"
           value: "gpu"
           effect: "NoSchedule"
         # Mark this pod as a critical add-on; when enabled, the critical add-on
         # scheduler reserves resources for critical add-on pods so that they can
         # be rescheduled after a failure.
         # See https://kubernetes.io/docs/tasks/administer-cluster/guaranteed-scheduling-critical-addon-pods/
         priorityClassName: "system-node-critical"
         containers:
         - image: nvcr.io/nvidia/k8s-device-plugin:v0.18.0
           name: nvidia-device-plugin-ctr
           env:
             - name: FAIL_ON_INIT_ERROR
               value: "false"
           securityContext:
             allowPrivilegeEscalation: false
             capabilities:
               drop: ["ALL"]
           volumeMounts:
           - name: device-plugin
             mountPath: /var/lib/kubelet/device-plugins
         volumes:
         - name: device-plugin
           hostPath:
             path: /var/lib/kubelet/device-plugins
   

3. Cree el DaemonSet y confirme que el plugin de dispositivos NVIDIA se ha creado correctamente mediante el comando kubectl apply.

   kubectl apply -f nvidia-device-plugin-ds.yaml
   

4. Ahora que instaló correctamente el complemento de dispositivo NVIDIA, puede comprobar que las GPU son programables y ejecutan una carga de trabajo de GPU.

Omitir la instalación del controlador de GPU

Si desea controlar la instalación de los controladores NVIDIA o usar el operador de GPU de NVIDIA, puede omitir la instalación predeterminada del controlador de GPU. Microsoft no admite ni administra el mantenimiento y la compatibilidad de los controladores NVIDIA como parte de la implementación de imágenes de nodo.

1. Cree un grupo de nodos mediante el comando az aks nodepool add y establezca el campo --gpu-driver en none para omitir la instalación predeterminada del controlador de GPU.

   az aks nodepool add \
       --resource-group myResourceGroup \
       --cluster-name myAKSCluster \
       --name gpunp \
       --node-count 1 \
       --gpu-driver none \
       --node-vm-size Standard_NC6s_v3 \
       --enable-cluster-autoscaler \
       --min-count 1 \
       --max-count 3
   

   Al establecer el campo API en --gpu-driver durante la creación del grupo de nodos, se omite realizar la instalación automática del controlador de GPU. No se cambian los nodos existentes. Puede escalar el grupo de nodos a cero y luego aumentarlo de nuevo para que el cambio tenga efecto.

   Si recibe el error unrecognized arguments: --gpu-driver none , actualice la versión de la CLI de Azure. Para más información, consulte la sección Antes de empezar.

2. Opcionalmente, puede instalar el operador de GPU nvidia siguiendo estos pasos.

Confirmación de que las GPU son programables

Después de crear el clúster, confirme que las GPUs son programables en Kubernetes.

1. Enumere los nodos de su clúster mediante el comando kubectl get nodes.

   kubectl get nodes
   

   El resultado debería ser similar al ejemplo siguiente:

   NAME                   STATUS   ROLES   AGE   VERSION
   aks-gpunp-28993262-0   Ready    agent   13m   v1.20.7
   

2. Confirme que las GPU son programables mediante el comando kubectl describe node.

   kubectl describe node aks-gpunp-28993262-0
   

   En la sección Capacidad, la GPU debe aparecer como nvidia.com/gpu: 1. El resultado debería ser similar al siguiente ejemplo reducido:

   Name:               aks-gpunp-28993262-0
   Roles:              agent
   Labels:             accelerator=nvidia
   
   [...]
   
   Capacity:
   [...]
    nvidia.com/gpu:                 1
   [...]
   

Ejecutar una carga de trabajo con GPU

Para ver la GPU en acción, puede programar una tarea que utilice GPU con las solicitudes de recursos adecuadas. En este ejemplo, ejecutaremos un trabajo Tensorflow con el conjunto de datos MNIST.

1. Cree un archivo llamado samples-tf-mnist-demo.yaml y pegue el siguiente manifiesto YAML, que incluye un límite de recursos de nvidia.com/gpu: 1:

   Nota:

   Si recibe un error de incompatibilidad de versión al utilizar controladores, como "la versión del controlador CUDA no es suficiente para la versión del entorno de ejecución de CUDA", consulte la tabla de compatibilidad de controladores NVIDIA.

   apiVersion: batch/v1
   kind: Job
   metadata:
     labels:
       app: samples-tf-mnist-demo
     name: samples-tf-mnist-demo
   spec:
     template:
       metadata:
         labels:
           app: samples-tf-mnist-demo
       spec:
         containers:
         - name: samples-tf-mnist-demo
           image: mcr.microsoft.com/azuredocs/samples-tf-mnist-demo:gpu
           args: ["--max_steps", "500"]
           imagePullPolicy: IfNotPresent
           resources:
             limits:
              nvidia.com/gpu: 1
         restartPolicy: OnFailure
         tolerations:
         - key: "sku"
           operator: "Equal"
           value: "gpu"
           effect: "NoSchedule"
   

2. Ejecute el trabajo mediante el comando kubectl apply, que analiza el archivo de manifiesto y crea los objetos de Kubernetes definidos.

   kubectl apply -f samples-tf-mnist-demo.yaml
   

Ver el estado de la carga de trabajo habilitada para GPU

1. Supervisa el progreso del trabajo mediante el comando kubectl get jobs con el indicador --watch. Puede tardar unos minutos en extraer primero la imagen y procesar el conjunto de datos.

   kubectl get jobs samples-tf-mnist-demo --watch
   

   Cuando la columna FINALIZACIONES muestra 1/1, el trabajo ha finalizado correctamente, como se muestra en la salida de ejemplo siguiente:

   NAME                    COMPLETIONS   DURATION   AGE
   
   samples-tf-mnist-demo   0/1           3m29s      3m29s
   samples-tf-mnist-demo   1/1   3m10s   3m36s
   

2. Salga del proceso kubectl --watch con Ctrl-C.

3. Obtén el nombre del pod mediante el comando kubectl get pods.

   kubectl get pods --selector app=samples-tf-mnist-demo
   

4. Vea la salida de la carga de trabajo habilitada para GPU utilizando el comando kubectl logs.

   kubectl logs samples-tf-mnist-demo-smnr6
   

   l siguiente ejemplo de salida condensada de los registros del pod confirma que el dispositivo GPU apropiado, Tesla K80, ha sido descubierto:

   2019-05-16 16:08:31.258328: I tensorflow/core/platform/cpu_feature_guard.cc:137] Your CPU supports instructions that this TensorFlow binary was not compiled to use: SSE4.1 SSE4.2 AVX AVX2 FMA
   2019-05-16 16:08:31.396846: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1030] Found device 0 with properties:
   name: Tesla K80 major: 3 minor: 7 memoryClockRate(GHz): 0.8235
   pciBusID: 2fd7:00:00.0
   totalMemory: 11.17GiB freeMemory: 11.10GiB
   2019-05-16 16:08:31.396886: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1120] Creating TensorFlow device (/device:GPU:0) -> (device: 0, name: Tesla K80, pci bus id: 2fd7:00:00.0, compute capability: 3.7)
   2019-05-16 16:08:36.076962: I tensorflow/stream_executor/dso_loader.cc:139] successfully opened CUDA library libcupti.so.8.0 locally
   Successfully downloaded train-images-idx3-ubyte.gz 9912422 bytes.
   Extracting /tmp/tensorflow/input_data/train-images-idx3-ubyte.gz
   Successfully downloaded train-labels-idx1-ubyte.gz 28881 bytes.
   Extracting /tmp/tensorflow/input_data/train-labels-idx1-ubyte.gz
   Successfully downloaded t10k-images-idx3-ubyte.gz 1648877 bytes.
   Extracting /tmp/tensorflow/input_data/t10k-images-idx3-ubyte.gz
   Successfully downloaded t10k-labels-idx1-ubyte.gz 4542 bytes.
   Extracting /tmp/tensorflow/input_data/t10k-labels-idx1-ubyte.gz
   Accuracy at step 0: 0.1081
   Accuracy at step 10: 0.7457
   Accuracy at step 20: 0.8233
   Accuracy at step 30: 0.8644
   Accuracy at step 40: 0.8848
   Accuracy at step 50: 0.8889
   Accuracy at step 60: 0.8898
   Accuracy at step 70: 0.8979
   Accuracy at step 80: 0.9087
   Accuracy at step 90: 0.9099
   Adding run metadata for 99
   Accuracy at step 100: 0.9125
   Accuracy at step 110: 0.9184
   Accuracy at step 120: 0.922
   Accuracy at step 130: 0.9161
   Accuracy at step 140: 0.9219
   Accuracy at step 150: 0.9151
   Accuracy at step 160: 0.9199
   Accuracy at step 170: 0.9305
   Accuracy at step 180: 0.9251
   Accuracy at step 190: 0.9258
   Adding run metadata for 199
   [...]
   Adding run metadata for 499
   

Actualización de un grupo de nodos

Tanto si desea actualizar o mejorar los grupos de nodos, es posible que observe que no hay ningún --gpu-driver parámetro para ninguna de las operaciones. Es posible que se produzca un error como unrecognized arguments: --gpu-driver none si intenta pasar el parámetro . No es necesario llamar al parámetro , ya que el valor no se ve afectado por ninguna de estas operaciones.

Cuando cree por primera vez su grupo de nodos, el parámetro que declare para --gpu-driver no se verá afectado por las operaciones de mejora o actualización. Si no desea que se instale ningún controlador y se seleccione --gpu-driver None al crear el grupo de nodos, los controladores no se instalarán en actualizaciones o actualizaciones posteriores.

Limpieza de recursos

Elimine los objetos Kubernetes asociados que creó en este artículo mediante el comando kubectl delete job.

kubectl delete jobs samples-tf-mnist-demo

Pasos siguientes

• Para ejecutar trabajos de Apache Spark, consulte Ejecución de trabajos de Apache Spark en AKS.
• A fin de obtener más información sobre las características del programador de Kubernetes, vea Procedimientos recomendados para las características avanzadas del programador en AKS.
• Para más información sobre Azure Kubernetes Service y Azure Machine Learning, consulte:
  • Configure un clúster de Kubernetes para el entrenamiento o la implementación de modelos de Machine Learning.
  • Implementación de un modelo con un punto de conexión en línea.
  • Servicio de alto rendimiento con Triton Inference Server.
  • Laboratorios para Kubernetes y Kubeflow.