Compartir a través de

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 compatibles con GPU habilitadas, consulte Tamaños de máquina virtual optimizados para GPU en Azure. 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.

Nota:

Las máquinas virtuales habilitadas para GPU contienen hardware especializado que está sujeto a precios más altos y disponibilidad limitada según la región. Para obtener más información, consulte la herramienta de precios y la disponibilidad de regiones.

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.

Nota:

Para la versión 2023-06-01 o posterior de la API de AKS, el canal predeterminado para la actualización del SO del nodo es NodeImage. Para las versiones anteriores, el canal predeterminado es Ninguno. Para más información, consulte Actualización automática.

  • 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.

Nota:

La imagen de GPU de AKS (versión preliminar) será retirada a partir del 10 de enero de 2025. El encabezado personalizado ya no está disponible, lo que significa que no se pueden crear nuevos grupos de nodos habilitados para GPU mediante la imagen de GPU de AKS. Se recomienda migrar a o usar la configuración de GPU predeterminada en lugar de la imagen de GPU, puesto que ya no se admite la imagen de GPU. Para obtener más información, consulte Notas de la versión de AKS o vea este anuncio de retirada en nuestra Hoja de ruta pública de 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.

Nota:

De forma predeterminada, Microsoft automáticamente mantiene la versión de los controladores NVIDIA como parte de la implementación de la imagen de nodo, y AKS lo admite y administra. Aunque los controladores NVIDIA se instalan de forma predeterminada en los nodos compatibles con GPU, debe instalar el complemento de dispositivo.

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.

Para usar la SKU predeterminada del sistema operativo, cree el grupo de nodos sin especificar una SKU del sistema operativo. El grupo de nodos está configurado para el sistema operativo predeterminado en función de la versión de Kubernetes del clúster.

  1. Agregue un grupo de nodos a su clúster mediante el comando az aks nodepool add.

    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

    Este comando agrega un grupo de nodos denominado gpunp a myAKSCluster en myResourceGroup y utiliza parámetros para configurar las siguientes opciones del grupo de nodos:

    • --node-vm-size: establece el tamaño de la máquina virtual para el nodo en el grupo de nodos en Standard_NC6s_v3.
    • --node-taints: especifica sku=gpu:NoSchedule en el grupo de nodos.
    • --enable-cluster-autoscaler: habilita el autoescalador del clúster.
    • --min-count: configura el autoescalador del clúster para mantener un mínimo de un nodo en el grupo de nodos.
    • --max-count: configura el autoescalador de clúster para mantener un máximo de tres nodos en el grupo de nodos.

    Nota:

    Los taints y tamaños de las máquinas virtuales solo pueden configurarse durante la creación del grupo de nodos, pero puede actualizar la configuración del escalado automático en cualquier momento.

  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.17.2
        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

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