How to use GPU sharing in an ACK Lingjun managed cluster - Container Service for Kubernetes

El uso compartido de GPU permite que varios pods se ejecuten en la misma tarjeta GPU dentro de un clúster administrado ACK Lingjun. Según si sus cargas de trabajo requieren límites estrictos de memoria, elija entre dos modos:

Modo	Funcionamiento	¿Memoria de GPU aislada?	Cuándo utilizarlo
Uso compartido sin aislamiento	Los pods comparten la GPU; la memoria no se divide entre ellos	No	Cargas de trabajo que gestionan sus propios límites de memoria (por ejemplo, aplicaciones Java con `-Xmx`)
Uso compartido con aislamiento (eGPU)	Los pods comparten la GPU; cada pod obtiene un límite estricto de memoria aplicado por el módulo eGPU	Sí	Varios contenedores en una sola GPU donde uno no debe privar de recursos a los demás

Requisitos previos

Antes de empezar, asegúrese de contar con lo siguiente:

Un clúster administrado ACK Lingjun con al menos un nodo Lingjun acelerado por GPU. Consulte Create a Lingjun cluster with ACK activated
El componente de uso compartido de GPU, instalado de forma predeterminada en los clústeres administrados ACK Lingjun

Habilitar el uso compartido de GPU sin aislamiento

Utilice este modo cuando sus cargas de trabajo gestionen los límites de memoria de la GPU en la capa de aplicación.

Paso 1: Etiquetar el nodo

Confirme que el nodo es un nodo Lingjun al verificar si existe el archivo /etc/lingjun_metadata en el nodo. Si el archivo existe, ejecute nvidia-smi para comprobar que la GPU es accesible. Si el archivo no existe, el nodo no es un nodo Lingjun y no puede habilitar el uso compartido de GPU para él. Cree primero un node pool de Lingjun. Consulte Overview of Lingjun node pools.

Agregue la etiqueta de uso compartido de GPU al nodo:

kubectl label node <NODE_NAME> ack.node.gpu.schedule=share

Paso 2: Enviar un trabajo con uso compartido de GPU

Cree un archivo llamado tensorflow.yaml con el siguiente contenido:

apiVersion: batch/v1
kind: Job
metadata:
  name: tensorflow-mnist-share
spec:
  parallelism: 1
  template:
    metadata:
      labels:
        app: tensorflow-mnist-share
    spec:
      containers:
      - name: tensorflow-mnist-share
        image: registry.cn-beijing.aliyuncs.com/ai-samples/gpushare-sample:tensorflow-1.5
        command:
        - python
        - tensorflow-sample-code/tfjob/docker/mnist/main.py
        - --max_steps=100000
        - --data_dir=tensorflow-sample-code/data
        resources:
          limits:
            aliyun.com/gpu-mem: 4  # Request 4 GiB of GPU memory
        workingDir: /root
      restartPolicy: Never

El campo clave es aliyun.com/gpu-mem: 4 bajo resources.limits, que solicita 4 GiB de memoria de GPU para el pod.

Envíe el trabajo:
```
kubectl apply -f tensorflow.yaml
```

Paso 3: Verificar el uso compartido de GPU sin aislamiento

Obtenga el nombre del pod:
```
kubectl get pod | grep tensorflow
```

Ejecute nvidia-smi dentro del pod:

kubectl exec -ti tensorflow-mnist-share-xxxxx -- nvidia-smi

Salida esperada:

Wed Jun 14 06:45:56 2023
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 515.105.01   Driver Version: 515.105.01   CUDA Version: 11.7     |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|                               |                      |               MIG M. |
|===============================+======================+======================|
|   0  Tesla V100-SXM2...  On   | 00000000:00:09.0 Off |                    0 |
| N/A   35C    P0    59W / 300W |    334MiB / 16384MiB |      0%      Default |
|                               |                      |                  N/A |
+-------------------------------+----------------------+----------------------+

+-----------------------------------------------------------------------------+
| Processes:                                                                  |
|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |
|        ID   ID                                                   Usage      |
|=============================================================================|
+-----------------------------------------------------------------------------+

Campos clave para verificar:

Memory-Usage muestra 334MiB / 16384MiB: el pod ve los 16,384 MiB completos de memoria de GPU, no solo los 4 GiB solicitados. Esto confirma que el aislamiento no está activo.
Si el módulo de aislamiento de GPU estuviera instalado, el campo de memoria mostraría únicamente los 4 GiB solicitados.

En este modo, el pod no aplica límites de memoria a nivel del controlador de GPU. El programador rastrea las asignaciones de memoria mediante dos variables de entorno inyectadas en el contenedor. Las aplicaciones que necesitan respetar la asignación pueden calcular la fracción permitida: 4 / 16 = 0.25 (25% de la memoria total de la GPU).

ALIYUN_COM_GPU_MEM_CONTAINER=4   # GPU memory allocated to this pod (GiB)
ALIYUN_COM_GPU_MEM_DEV=16        # Total GPU memory per card (GiB)

Habilitar el uso compartido de GPU con aislamiento (eGPU)

Utilice este modo para aplicar límites estrictos de memoria de GPU entre pods en la misma tarjeta GPU.

Paso 1: Etiquetar el nodo

Confirme que el nodo es un nodo Lingjun al verificar si existe el archivo /etc/lingjun_metadata en el nodo. Si el archivo existe, ejecute nvidia-smi para comprobar que la GPU es accesible. Si el archivo no existe, el nodo no es un nodo Lingjun y no puede habilitar el uso compartido de GPU para él. Cree primero un node pool de Lingjun. Consulte Overview of Lingjun node pools.
Agregue la etiqueta de uso compartido de GPU al nodo. Elija el valor de la etiqueta según el tipo de aislamiento que necesite:

Valor de etiqueta

Qué habilita

egpu_mem

Solo aislamiento de memoria de GPU

egpu_core_mem

Aislamiento de memoria de GPU y aislamiento de potencia de cómputo

Para habilitar el aislamiento de memoria:
```
kubectl label node <NODE_NAME> ack.node.gpu.schedule=egpu_mem
```
La potencia de cómputo de la GPU siempre debe solicitarse junto con la memoria de la GPU. No se admite solicitar solo potencia de cómputo.

Paso 2: Confirmar que los recursos del nodo están listos

Después de etiquetar el nodo, espere a que el nodo reporte sus recursos de GPU y luego verifique:

kubectl get node <NODE_NAME> -oyaml

Busque aliyun.com/gpu-mem y aliyun.com/gpu-count en las secciones allocatable y capacity:

allocatable:
  aliyun.com/gpu-count: "1"
  aliyun.com/gpu-mem: "80"
  ...
  nvidia.com/gpu: "0"
  ...
capacity:
  aliyun.com/gpu-count: "1"
  aliyun.com/gpu-mem: "80"
  ...
  nvidia.com/gpu: "0"
  ...

Campos clave para verificar:

aliyun.com/gpu-count: "1": el nodo tiene una tarjeta GPU.
aliyun.com/gpu-mem: "80": el nodo tiene 80 GB de memoria total de GPU.
nvidia.com/gpu: "0": la GPU completa no se expone como un recurso programable independiente; la memoria se asigna mediante aliyun.com/gpu-mem.

Para programar un pod en un dispositivo GPU completo, agregue la etiqueta ack.gpushare.placement=require-whole-device al pod y especifique la cantidad de memoria de GPU mediante aliyun.com/gpu-mem .

Paso 3: Ejecutar un trabajo de benchmarking para verificar el aislamiento

Cree un archivo llamado benchmark.yaml con el siguiente contenido:

apiVersion: batch/v1
kind: Job
metadata:
  name: benchmark-job
spec:
  parallelism: 1
  template:
    spec:
      containers:
      - name: benchmark-job
        image: registry.cn-beijing.aliyuncs.com/ai-samples/gpushare-sample:benchmark-tensorflow-2.2.3
        command:
        - bash
        - run.sh
        - --num_batches=500000000
        - --batch_size=8
        resources:
          limits:
            aliyun.com/gpu-mem: 10  # Request 10 GB of GPU memory
        workingDir: /root
      restartPolicy: Never
      hostNetwork: true
      tolerations:
        - operator: Exists

Envíe el trabajo:
```
kubectl apply -f benchmark.yaml
```
Una vez que el pod se inicie, abra un shell en el pod:
```
kubectl exec -ti benchmark-job-xxxx bash
```

Ejecute vgpu-smi para verificar el estado de aislamiento de la GPU:

Memory-Usage muestra 8307MiB / 10782MiB: el pod tiene un límite de aproximadamente 10 GB, lo que confirma que el aislamiento de memoria de GPU está activo.
A diferencia de nvidia-smi en el modo sin aislamiento, vgpu-smi muestra solo la memoria asignada a este pod, no la memoria total de la GPU.

vgpu-smi

Salida esperada:

+------------------------------------------------------------------------------+
|    VGPU_SMI 460.91.03     DRIVER_VERSION: 460.91.03     CUDA Version: 11.2   |
+-------------------------------------------+----------------------------------+
| GPU  Name                Bus-Id           |        Memory-Usage     GPU-Util |
|===========================================+==================================|
|   0  xxxxxxxx            00000000:00:07.0 |  8307MiB / 10782MiB   100% /  100% |
+-------------------------------------------+----------------------------------+

Campos clave para verificar:

Preguntas frecuentes

¿Cómo compruebo si el componente de uso compartido de GPU está instalado?

Ejecute el siguiente comando:

kubectl get ds -nkube-system | grep gpushare

Si el componente está instalado, la salida enumera los siguientes DaemonSets:

NAME                                 DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   NODE SELECTOR                    AGE
gpushare-egpu-device-plugin-ds       0         0         0       0            0           <none>
gpushare-egpucore-device-plugin-ds   0         0         0       0            0           <none>

Pasos siguientes

Labels for enabling GPU scheduling policies: conozca todas las etiquetas de nodo disponibles para la programación de GPU.
Overview of Lingjun node pools: agregue nodos Lingjun a su clúster.

Valor de etiqueta	Qué habilita
`egpu_mem`	Solo aislamiento de memoria de GPU
`egpu_core_mem`	Aislamiento de memoria de GPU y aislamiento de potencia de cómputo