Como usar o compartilhamento de GPU em um cluster gerenciado ACK Lingjun - Container Service for Kubernetes: Central de Documentação do Alibaba Cloud

O compartilhamento de GPU permite que vários pods executem 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	Funcionamento	Memória da GPU isolada?	Recomendado quando
Compartilhamento sem isolamento	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)	Os pods compartilham a GPU; cada pod recebe um limite rígido de memória imposto pelo módulo eGPU	Sim	Vários containers em uma única GPU onde um não deve privar os outros de recursos

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 Criar um cluster Lingjun com o ACK ativado
O componente de compartilhamento de GPU, instalado por padrão em clusters gerenciados ACK Lingjun

Ativar o compartilhamento de GPU sem isolamento

Use este modo quando suas cargas de trabalho gerenciarem limites de memória da GPU na camada de aplicação.

Etapa 1: Rotular o nó

Confirme se o nó é um nó Lingjun verificando se o arquivo /etc/lingjun_metadata existe no nó. Se o arquivo existir, execute nvidia-smi para verificar se a GPU está acessível. Caso o arquivo não exista, o nó não é um nó Lingjun e não é possível ativar o compartilhamento de GPU para ele. Crie primeiro um pool de nós Lingjun. Consulte Visão geral dos pools de nós Lingjun.

Adicione o rótulo de compartilhamento de GPU ao nó:

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

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      |
|=============================================================================|
+-----------------------------------------------------------------------------+

Verifique os seguintes campos principais:

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.
Se o módulo de isolamento de GPU estivesse instalado, o campo de memória mostraria apenas os 4 GiB solicitados.

Neste modo, o pod não impõe limites de memória no nível do driver da GPU. O agendador rastreia as alocações de memória usando duas variáveis de ambiente injetadas no container. Aplicações que precisam respeitar a alocação podem calcular a fração permitida: 4 / 16 = 0,25 (25% do total de memória 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.

Etapa 1: Rotular o nó

Confirme se o nó é um nó Lingjun verificando se o arquivo /etc/lingjun_metadata existe no nó. Se o arquivo existir, execute nvidia-smi para verificar se a GPU está acessível. Caso o arquivo não exista, o nó não é um nó Lingjun e não é possível ativar o compartilhamento de GPU para ele. Crie primeiro um pool de nós Lingjun. Consulte Visão geral dos pools de nós Lingjun.

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

O poder de computação da GPU deve sempre ser solicitado junto com a memória da GPU. Não há suporte para solicitar apenas poder de computação.

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

Verifique os seguintes campos principais:

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 de 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 e especifique a quantidade de memória da GPU 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 mostra 8307MiB / 10782MiB — o pod está limitado a aproximadamente 10 GB, confirmando que o isolamento de memória da GPU está ativo.
Diferente do nvidia-smi no modo sem isolamento, o vgpu-smi exibe 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% |
+-------------------------------------------+----------------------------------+

Verifique os seguintes campos principais:

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

Rótulos para ativar políticas de agendamento de GPU — saiba mais sobre todos os rótulos de nó disponíveis para agendamento de GPU.
Visão geral dos pools de nós Lingjun — adicione nós Lingjun ao seu cluster.