How to use GPU sharing in an ACK Lingjun managed cluster - Container Service for Kubernetes: Central de Documentação do Alibaba Cloud

O compartilhamento de GPU permite que vários pods sejam executados na mesma placa GPU em um cluster gerenciado ACK Lingjun. Dependendo da necessidade de limites rígidos de memória nas suas cargas de trabalho, escolha entre dois modos:

Modo	Rótulo do nó	Funcionamento	Memória da GPU isolada?	Cenário recomendado
Compartilhamento sem isolamento	`ack.node.gpu.schedule=share`	Os pods compartilham a GPU; a memória não é particionada entre eles	Não	Cargas de trabalho que gerenciam seus próprios limites de memória (por exemplo, aplicativos Java com `-Xmx`)
Compartilhamento com isolamento (eGPU)	`ack.node.gpu.schedule=egpu_mem` apenas para isolamento de memória da GPU, ou `ack.node.gpu.schedule=egpu_core_mem` para isolamento de memória e poder de computação da GPU	Os pods compartilham a GPU; cada pod recebe um limite rígido de memória imposto pelo módulo eGPU	Sim	Vários contêineres em uma única GPU em que um não deve privar os outros de recursos

O compartilhamento de GPU em um pool de nós Lingjun entra em vigor apenas nos nós que possuem um desses rótulos.

Pré-requisitos

Antes de começar, verifique se você tem:

Um cluster gerenciado ACK Lingjun com pelo menos um nó Lingjun acelerado por GPU. Consulte Create a Lingjun cluster with ACK activated
Um pool de nós Lingjun. Consulte Create a Lingjun node pool.
A capacidade KuberGPU (eGPU) ativada no seu cluster bare metal Lingjun.
O complemento ack-ai-installer instalado no seu cluster gerenciado ACK Pro. Ao Deploy the cloud-native AI suite, selecione Scheduling Policy Extension (Batch Task Scheduling, GPU Sharing, Topology-aware GPU Scheduling) para instalar o componente.
O complemento de compartilhamento de GPU instalado por padrão em clusters gerenciados ACK Lingjun. Para ativar o compartilhamento de GPU em um nó, adicione um rótulo de compartilhamento de GPU ao nó.

Ativar o compartilhamento de GPU sem isolamento

Use este modo quando suas cargas de trabalho definirem seus próprios limites de memória da GPU. Nesse cenário, usar o módulo de isolamento de GPU para isolar a memória do aplicativo pode causar problemas como conflitos de recursos. Por isso, o agendamento compartilhado de GPU permite não instalar o módulo de isolamento nesses nós. No modo de compartilhamento de GPU sem isolamento, vários pods são executados na mesma placa GPU. Interferências entre os pods na placa, como contenção por memória da GPU, não são tratadas ou ficam a cargo da camada de aplicação.

Etapa 1: Rotular o nó

Confirme se o nó é um nó Lingjun verificando se /etc/lingjun_metadata existe no nó. Se o arquivo existir, execute nvidia-smi para verificar se a GPU está disponível. Se a saída for normal, o nó será compatível com compartilhamento de GPU e você poderá prosseguir para a próxima etapa. Caso o arquivo não exista, o nó não será um nó Lingjun e o compartilhamento de GPU não poderá ser ativado nele. Crie primeiro um nó Lingjun. Consulte Overview of Lingjun node pools.
Adicione o rótulo de compartilhamento de GPU ao nó:
```
kubectl label node <NODE_NAME> ack.node.gpu.schedule=share
```
Alternativamente, defina o rótulo no console usando o recurso node labels.

Etapa 2: Enviar um job de compartilhamento de GPU

Crie um arquivo chamado tensorflow.yaml com o seguinte conteúdo:

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

O campo principal é aliyun.com/gpu-mem: 4 em resources.limits, que solicita 4 GiB de memória da GPU para o pod.

Envie o job:
```
kubectl apply -f tensorflow.yaml
```

Etapa 3: Verificar o compartilhamento de GPU sem isolamento

Obtenha o nome do pod:
```
kubectl get pod | grep tensorflow
```

Execute nvidia-smi dentro do pod:

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

Saída 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 principais a verificar:

Memory-Usage exibe 334MiB / 16384MiB — o pod vê os 16.384 MiB completos de memória da GPU, e não apenas os 4 GiB solicitados. Isso confirma que o isolamento não está ativo. O exemplo usa uma placa GPU V100 e o pod solicita 4 GiB de memória da GPU. Os valores reais dependem do seu ambiente.
Se o módulo de isolamento de GPU estivesse instalado, o campo de memória mostraria apenas os 4 GiB solicitados.

Este modo não impõe limites de memória no nível do driver da GPU. Seu aplicativo lê a memória da GPU disponível a partir de duas variáveis de ambiente, conforme mostra a saída a seguir. Para expressar a alocação como uma porcentagem da memória total da placa, divida os dois valores: 4 / 16 = 0,25 (25% da memória total da 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)

Ativar o compartilhamento de GPU com isolamento (eGPU)

Use este modo para impor limites rígidos de memória da GPU entre pods na mesma placa GPU. Soluções do setor, como NVIDIA vGPU, MPS, vCUDA e eGPU, possibilitam o uso da GPU com granularidade mais fina. Esta seção usa o módulo de isolamento eGPU como exemplo. No modo de compartilhamento de GPU com isolamento, vários pods são executados na mesma placa GPU e as interferências entre eles também são gerenciadas.

Etapa 1: Rotular o nó

Confirme se o nó é um nó Lingjun verificando se /etc/lingjun_metadata existe no nó. Se o arquivo existir, execute nvidia-smi para verificar se a GPU está acessível. Se o arquivo não existir, o nó não será um nó Lingjun e você não poderá ativar o compartilhamento de GPU para ele. Crie primeiro um pool de nós Lingjun. Consulte Overview of Lingjun node pools.

Adicione o rótulo de compartilhamento de GPU ao nó. Escolha o valor do rótulo com base no tipo de isolamento necessário:

Valor do rótulo	O que ele ativa
`egpu_mem`	Apenas isolamento de memória da GPU
`egpu_core_mem`	Isolamento de memória da GPU e isolamento de poder de computação

Para ativar o isolamento de memória:

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

Você também pode definir o rótulo no console usando o recurso node labels.

É possível solicitar apenas memória da GPU, mas se você solicitar poder de computação da GPU, deverá solicitar tanto a memória quanto o poder de computação. A solicitação apenas de poder de computação não é suportada.

Etapa 2: Confirmar se os recursos do nó estão prontos

Após rotular o nó, aguarde até que ele reporte seus recursos de GPU e verifique:

kubectl get node <NODE_NAME> -oyaml

Procure por aliyun.com/gpu-mem e aliyun.com/gpu-count nas seções allocatable e 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 principais a verificar:

aliyun.com/gpu-count: "1" — o nó possui uma placa GPU.
aliyun.com/gpu-mem: "80" — o nó tem 80 GB de memória total da GPU.
nvidia.com/gpu: "0" — a GPU inteira não é exposta como um recurso agendável independente; a memória é alocada via aliyun.com/gpu-mem.

Para agendar um pod em um dispositivo GPU inteiro, adicione o rótulo ack.gpushare.placement=require-whole-device ao pod. Por padrão, o pod será então agendado em uma placa GPU inteira que possua essa quantidade de memória da GPU. Especifique a quantidade de memória usando aliyun.com/gpu-mem .

Etapa 3: Executar um job de benchmark para verificar o isolamento

Crie um arquivo chamado benchmark.yaml com o seguinte conteúdo:

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

Envie o job:
```
kubectl apply -f benchmark.yaml
```
Depois que o pod iniciar, abra um shell no pod:
```
kubectl exec -ti benchmark-job-xxxx bash
```

Execute vgpu-smi para verificar o status de isolamento da GPU:

Memory-Usage exibe 8307MiB / 10782MiB — o pod está limitado a aproximadamente 10 GB, confirmando que o isolamento de memória da GPU está ativo.
Diferentemente do nvidia-smi no modo sem isolamento, o vgpu-smi mostra apenas a memória alocada para este pod, e não a memória total da GPU.

vgpu-smi

Saída 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 principais a verificar:

Perguntas frequentes

Como verifico se o componente de compartilhamento de GPU está instalado?

Execute o seguinte comando:

kubectl get ds -nkube-system | grep gpushare

Se o componente estiver instalado, a saída listará os seguintes 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>

Próximos passos

Labels for enabling GPU scheduling policies — conheça todos os rótulos de nó disponíveis para agendamento de GPU.
Overview of Lingjun node pools — adicione nós Lingjun ao seu cluster.