Gerencie cGPU usando pools de nós - : Central de Documentação do Alibaba Cloud

O uso de pools de nós para gerenciar cGPU permite políticas flexíveis de compartilhamento de GPU e isolamento de memória. Este tópico mostra como criar dois pools de nós com rótulos específicos em um cluster dedicado para controlar esses recursos.

Cenários

Os recursos descritos neste tópico são suportados apenas em clusters dedicados, não em clusters gerenciados.
Para instalar o componente ack-cgpu em um cluster ACK Pro, consulte Gerenciar o componente ack-cgpu.

Pré-requisitos

Certifique-se de ter concluído as seguintes tarefas:

Instalar o componente ack-cgpu.

Planeje seus pools de nós.

É possível usar nomes personalizados para os pools de nós. Este tópico utiliza cgpu e cgpu-no-isolation como exemplos.

Pool de nós	Compartilhamento de GPU	Isolamento de memória	Rótulos
cgpu	Ativado	Ativado	cgpu=true cgpu.disable.isolation=false
cgpu-no-isolation	Ativado	Desativado	cgpu=true cgpu.disable.isolation=true

Contexto

Ao utilizar o compartilhamento de GPU no Container Service for Kubernetes (ACK), você pode se deparar com os seguintes cenários:

No Trabalho de Treinamento A, o código da aplicação já especifica a memória de GPU utilizável. Portanto, o cluster precisa fornecer apenas o compartilhamento de GPU, sem isolamento de memória.
No Trabalho de Treinamento B, o código da aplicação não especifica a memória de GPU utilizável. Nesse caso, o cluster deve fornecer tanto o compartilhamento de GPU quanto o isolamento de memória.

Como suportar ambos os cenários em um único cluster?

O gerenciamento de cGPU por meio de pools de nós atende a ambas as situações. Basta criar dois pools de nós:

Um pool de nós que fornece apenas compartilhamento de GPU, sem isolamento de memória. Este pool destina-se a trabalhos como o Trabalho de Treinamento A.
Um pool de nós que fornece compartilhamento de GPU e isolamento de memória. Este pool destina-se a trabalhos como o Trabalho de Treinamento B.

Observações de uso

Ao gerenciar cGPU com pools de nós, considere os pontos a seguir:

Se um trabalho não tiver um nodeSelector especificado, seus pods poderão ser agendados em qualquer pool de nós, o que pode gerar resultados inesperados.

Importante
Sempre especifique um nodeSelector para cada trabalho.
Caso um rótulo de nó seja alterado (por exemplo, de cgpu.disable.isolation=false para cgpu.disable.isolation=true), reinicie o pod gpushare-device-plugin nesse nó para que a configuração de isolamento de memória tenha efeito.

Para reiniciar o plugin, exclua o pod gpushare-device-plugin existente. O ACK criará automaticamente um novo. Siga estas etapas:
1. Execute o comando a seguir para listar os pods gpushare-device-plugin no cluster:
```
kubectl get po -n kube-system -l name=gpushare-device-plugin-ds -o wide
```
  A saída esperada é semelhante a esta:
```
NAME                              READY   STATUS    RESTARTS   AGE   IP              NODE                        NOMINATED NODE   READINESS GATES
gpushare-device-plugin-ds-6r8gs   1/1     Running   0          18h   192.168.7.157   cn-shanghai.192.168.7.157   <none>           <none>
gpushare-device-plugin-ds-pjrvn   1/1     Running   0          15h   192.168.7.158   cn-shanghai.192.168.7.158   <none>           <none>
```
2. Por exemplo, para excluir o pod no nó cn-shanghai.192.168.7.157, execute o seguinte comando:
```
kubectl delete po gpushare-device-plugin-ds-6r8gs -n kube-system
```

Etapa 1: Criar pools de nós

Faça login no console do ACK. No painel de navegação à esquerda, clique em Clusters.
Na página Clusters, clique no nome do seu cluster. No painel de navegação à esquerda, clique em Nodes > Node Pools.
No canto superior direito, clique em Create Node Pool.
Na página Create Node Pool, configure os parâmetros do pool de nós.
Para obter mais informações sobre os parâmetros, consulte Criar um cluster gerenciado ACK. A lista a seguir descreve alguns parâmetros importantes:
- Quantity: Número inicial de nós no pool de nós. Defina como 0 se não estiver criando nós agora.
- Operating System: Selecione o sistema operacional dos nós, como CentOS 7.x ou Alibaba Cloud Linux 2.x.
- Node Labels: Rótulos a serem aplicados aos nós neste pool de nós.
- ECS Tags: Tags a serem aplicadas às instâncias ECS subjacentes.
- Custom Resource Group: Grupo de recursos para os nós no pool de nós.
Na seção Node Labels, adicione rótulos específicos a cada pool de nós.
- Pool de nós cgpu: cgpu=true e cgpu.disable.isolation=false
- Pool de nós cgpu-no-isolation: cgpu=true e cgpu.disable.isolation=true
A configuração a seguir usa o pool de nós cgpu-no-isolation como exemplo.
Clique em Confirm.

Na página Node Pools, um Status definido como Initializing indica que o pool de nós está sendo criado. Quando a criação for concluída, o Status mudará para Active.

Nota

Se precisar adicionar nós de GPU, escale horizontalmente o pool de nós. Para mais informações, consulte Criar e gerenciar pools de nós.

Etapa 2: Enviar trabalhos

Envie dois trabalhos, cgpu-test e cgpu-test-no-isolation. Você deve especificar um nodeSelector no arquivo YAML de cada trabalho.

cgpu-test: O tamanho da memória de GPU disponível não está definido no código deste trabalho, portanto, ele requer isolamento de memória cGPU para executar corretamente. O arquivo YAML de exemplo a seguir mostra a configuração:

apiVersion: batch/v1
kind: Job
metadata:
  name: cgpu-test
spec:
  parallelism: 1
  template:
    metadata:
      labels:
        app: cgpu-test
    spec:
      nodeSelector:
        cgpu.disable.isolation: "false" # Add a nodeSelector to select the cgpu node pool.
      containers:
      - name: cgpu-test
        image: registry.cn-hangzhou.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:
            # This pod requests a total of 3 GiB of GPU memory.
            aliyun.com/gpu-mem: 3
        workingDir: /root
      restartPolicy: Never

Nota

nodeSelector: Especifica o pool de nós cgpu.
cgpu.disable.isolation: "false": Agenda o trabalho em um nó do pool de nós cgpu.
aliyun.com/gpu-mem: Define a quantidade de memória da GPU em GiB.

cgpu-test-no-isolation: O código deste trabalho gerencia seu próprio uso de memória de GPU, portanto, não requer isolamento de memória cGPU. O arquivo YAML de exemplo a seguir mostra a configuração:

apiVersion: batch/v1
kind: Job
metadata:
  name: cgpu-test-no-isolation
spec:
  parallelism: 1
  template:
    metadata:
      labels:
        app: cgpu-test-no-isolation
    spec:
      nodeSelector:
        cgpu.disable.isolation: "true" # Add a nodeSelector to select the cgpu-no-isolation node pool.
      containers:
      - name: cgpu-test-no-isolation
        image: registry.cn-hangzhou.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:
            # This pod requests a total of 3 GiB of GPU memory.
            aliyun.com/gpu-mem: 3

Nota

nodeSelector: Especifica o pool de nós cgpu-no-isolation.
cgpu.disable.isolation: "true": Agenda o trabalho em um nó do pool de nós cgpu-no-isolation.
aliyun.com/gpu-mem: Define a quantidade de memória da GPU em GiB.

Etapa 3: Verificar os resultados

Execute o comando a seguir para verificar o status do trabalho:

kubectl get po

A saída esperada é semelhante a esta:

NAME                       READY   STATUS    RESTARTS   AGE
cgpu-test-0                1/1     Running   0          5m55s
cgpu-test-no-isolation-0   1/1     Running   0          6m42s

Execute o comando nvidia-smi no pod cgpu-test-0, que requer isolamento de memória, para verificar a memória de GPU disponível para o contêiner.

kubectl exec cgpu-test-0 -- nvidia-smi

A saída esperada é semelhante a esta:

Mon Nov  2 11:33:10 2020
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 418.87.01    Driver Version: 418.87.01    CUDA Version: 10.1     |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|===============================+======================+======================|
|   0  Tesla V100-SXM2...  On   | 00000000:00:07.0 Off |                    0 |
| N/A   34C    P0    54W / 300W |   3039MiB /  3226MiB |      1%      Default |
+-------------------------------+----------------------+----------------------+
+-----------------------------------------------------------------------------+
| Processes:                                                       GPU Memory |
|  GPU       PID   Type   Process name                             Usage      |
|=============================================================================|
+-----------------------------------------------------------------------------+

A memória total visível para o contêiner é de 3.226 MiB, muito inferior ao total físico da placa de 16 GiB. Isso confirma que o isolamento de memória cGPU está em vigor.

Execute o comando nvidia-smi no pod cgpu-test-no-isolation-0, que não requer isolamento de memória, para verificar a memória de GPU disponível para o contêiner.

kubectl exec cgpu-test-no-isolation-0 -- nvidia-smi

A saída esperada é semelhante a esta:

Mon Nov  2 11:39:59 2020
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 418.87.01    Driver Version: 418.87.01    CUDA Version: 10.1     |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|===============================+======================+======================|
|   0  Tesla V100-SXM2...  On   | 00000000:00:07.0 Off |                    0 |
| N/A   37C    P0    56W / 300W |   1929MiB / 16130MiB |      1%      Default |
+-------------------------------+----------------------+----------------------+
+-----------------------------------------------------------------------------+
| Processes:                                                       GPU Memory |
|  GPU       PID   Type   Process name                             Usage      |
|=============================================================================|
+-----------------------------------------------------------------------------+

A memória total visível para o contêiner é de 16.130 MiB, que corresponde à memória total da placa de GPU de 16 GiB. Isso confirma que o isolamento de memória cGPU está desativado. Neste cenário, a aplicação no contêiner deve determinar sua cota de memória permitida a partir das seguintes variáveis de ambiente. Execute o comando a seguir para consultar o tamanho permitido da memória de GPU.

kubectl exec cgpu-test-no-isolation-0 -- env | grep ALIYUN

A saída esperada é semelhante a esta:

ALIYUN_COM_GPU_MEM_CONTAINER=3    # The amount of memory in GiB that this container is allowed to use on a GPU card. In this case, 3 GiB.
ALIYUN_COM_GPU_MEM_DEV=15      # The total memory of the GPU card.
...

Compare a saída do nvidia-smi dos pods cgpu-test-no-isolation-0 e cgpu-test-0.

A saída para cgpu-test-no-isolation-0 mostra a memória inteira da placa de GPU, enquanto a saída para cgpu-test-0 mostra apenas sua fatia de memória alocada. Isso demonstra que os pools de nós fornecem uma maneira eficaz de gerenciar os recursos do cGPU.