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

GPU sharing 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 uno de los dos modos siguientes:

Mode	Node label	How it works	GPU memory isolated?	Use when
Compartición sin aislamiento	`ack.node.gpu.schedule=share`	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`)
Compartición con aislamiento (eGPU)	`ack.node.gpu.schedule=egpu_mem` para aislar solo la memoria de la GPU, o bien `ack.node.gpu.schedule=egpu_core_mem` para aislar tanto la memoria como la capacidad de cómputo de la GPU	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 ninguno debe dejar sin recursos a los demás

GPU sharing en un node pool de Lingjun solo surte efecto en los nodos que tienen una de estas etiquetas.

Requisitos previos

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

Un clúster administrado ACK Lingjun con como mínimo un nodo Lingjun acelerado por GPU. Consulte Create a Lingjun cluster with ACK activated
Un node pool de Lingjun. Consulte Create a Lingjun node pool.
La función KuberGPU (eGPU) habilitada en su clúster bare metal de Lingjun.
El complemento ack-ai-installer instalado en su clúster administrado ACK Pro. Cuando Deploy the cloud-native AI suite, seleccione Scheduling Policy Extension (Batch Task Scheduling, GPU Sharing, Topology-aware GPU Scheduling) para instalar el componente.
El complemento de GPU sharing instalado de forma predeterminada en los clústeres administrados ACK Lingjun. Para habilitar GPU sharing en un nodo, agregue una etiqueta de GPU sharing al nodo.

Habilitar GPU sharing sin aislamiento

Utilice este modo cuando sus cargas de trabajo definen sus propios límites de memoria de GPU. En este caso, usar el módulo de aislamiento de GPU para separar la memoria de las aplicaciones genera problemas como conflictos de recursos. Por ello, la programación de GPU compartida permite omitir la instalación del módulo de aislamiento en estos nodos. En GPU sharing without isolation, varios pods se ejecutan en la misma tarjeta GPU. Las interferencias entre los pods de la tarjeta, como la competencia por la memoria de la GPU, no se gestionan o se dejan a cargo de la capa de aplicación.

Paso 1: Etiquetar el nodo

Confirme que el nodo es un nodo Lingjun y compruebe si existe el archivo /etc/lingjun_metadata en el nodo. Si el archivo existe, ejecute nvidia-smi para comprobar que la GPU está disponible. Si la salida es normal, el nodo es un nodo Lingjun compatible con GPU sharing y puede continuar con el siguiente paso. Si el archivo no existe, el nodo no es un nodo Lingjun y no se puede habilitar GPU sharing en él. Cree primero un nodo Lingjun. Consulte Overview of Lingjun node pools.
Agregue la etiqueta de GPU sharing al nodo:
```
kubectl label node <NODE_NAME> ack.node.gpu.schedule=share
```
También puede establecer la etiqueta en la consola mediante la función node labels.

Paso 2: Enviar un trabajo con GPU sharing

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 dentro de resources.limits, que solicita 4 GiB de memoria de GPU para el pod.

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

Paso 3: Comprobar GPU sharing 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 que debe revisar:

Memory-Usage muestra 334MiB / 16384MiB: el pod ve los 16 384 MiB completos de memoria de la GPU, no solo los 4 GiB que solicitó. Esto confirma que el aislamiento no está activo. El ejemplo usa una tarjeta GPU V100 y el pod solicita 4 GiB de memoria de GPU. Los valores reales dependen de su entorno.
Si el módulo de aislamiento de GPU estuviera instalado, el campo de memoria mostraría únicamente los 4 GiB solicitados.

Este modo no aplica límites de memoria a nivel del controlador de la GPU. Su aplicación lee la memoria de GPU que puede utilizar desde dos variables de entorno, tal como muestra la siguiente salida. Para expresar la asignación como porcentaje de la memoria total de la tarjeta, divida ambos valores: 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 GPU sharing con aislamiento (eGPU)

Utilice este modo para aplicar límites estrictos de memoria de GPU entre los pods de una misma tarjeta. Soluciones del sector como NVIDIA vGPU, MPS, vCUDA y eGPU permiten aprovechar una GPU con mayor granularidad. Esta sección toma como ejemplo el módulo de aislamiento eGPU. En GPU sharing with isolation, varios pods se ejecutan en la misma tarjeta GPU y también se gestionan las interferencias entre ellos.

Paso 1: Etiquetar el nodo

Confirme que el nodo es un nodo Lingjun y compruebe 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 se puede habilitar GPU sharing en él. Cree primero un node pool de Lingjun. Consulte Overview of Lingjun node pools.
Agregue la etiqueta de GPU sharing al nodo. Elija el valor de la etiqueta según el tipo de aislamiento que necesite:

Label value

What it enables

egpu_mem

Solo aislamiento de memoria de GPU

egpu_core_mem

Aislamiento de memoria de GPU y de capacidad de cómputo

Para habilitar el aislamiento de memoria:
```
kubectl label node <NODE_NAME> ack.node.gpu.schedule=egpu_mem
```
También puede establecer la etiqueta en la consola mediante la función node labels.

Puede solicitar únicamente memoria de GPU. Sin embargo, si solicita capacidad de cómputo de GPU, debe solicitar tanto memoria como capacidad de cómputo. No se admite solicitar solo capacidad de cómputo.

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

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

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 que debe revisar:

aliyun.com/gpu-count: "1": el nodo tiene una tarjeta GPU.
aliyun.com/gpu-mem: "80": el nodo cuenta con 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. De forma predeterminada, el pod se programa entonces en una tarjeta GPU completa que tenga esa cantidad de memoria de GPU. Especifique la cantidad de memoria con aliyun.com/gpu-mem .

Paso 3: Ejecutar un trabajo de benchmark para comprobar 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 comprobar el estado del aislamiento de la GPU:

Memory-Usage muestra 8307MiB / 10782MiB: el pod tiene un límite aproximado de 10 GB, lo cual confirma que el aislamiento de memoria de GPU está activo.
A diferencia de nvidia-smi en el modo sin aislamiento, vgpu-smi muestra únicamente 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 que debe revisar:

Preguntas frecuentes

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

Ejecute el siguiente comando:

kubectl get ds -nkube-system | grep gpushare

Si el componente está instalado, la salida muestra 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.

Label value	What it enables
`egpu_mem`	Solo aislamiento de memoria de GPU
`egpu_core_mem`	Aislamiento de memoria de GPU y de capacidad de cómputo