Criar um pool de nós de GPU de várias instâncias no AKS (Serviço de Kubernetes do Azure)

Artigo
12/03/2024

A GPU A100 da NVIDIA pode ser dividida em até sete instâncias independentes. Cada instância tem seu próprio SM (Multiprocessador de Fluxo), que é responsável por executar instruções em paralelo e memória da GPU. Para obter mais informações sobre o NVIDIA A100, confira GPU NVIDIA A100.

Este artigo explica como criar um pool de nós de GPU de várias instâncias usando um tamanho de VM compatível com MIG em um cluster do AKS (Serviço de Kubernetes do Azure).

Pré-requisitos e limitações

Uma conta do Azure com uma assinatura ativa. Se você não tiver uma, crie uma conta gratuita.
CLI do Azure versão 2.2.0 ou posterior instalada e configurada. Execute az --version para encontrar a versão. Se você precisa instalar ou atualizar, consulte Instalar a CLI do Azure.
O cliente de linha de comando do Kubernetes, kubectl, instalado e configurado. Se você usar o Azure Cloud Shell, o kubectl já estará instalado. Para instalá-lo localmente, você pode usar o comando az aks install-cli.
Helm v3 instalado e configurado. Para obter mais informações, confira Como instalar o Helm.
Atualmente, não há suporte para pools de nós de GPU de várias instâncias no Azure Linux.
Você não pode usar o Dimensionador Automático de Cluster com pools de nós de GPU de várias instâncias.

Perfis de instância de GPU

Os perfis de instância de GPU definem como as GPUs são particionadas. A tabela a seguir mostra o perfil de instância de GPU disponível para o Standard_ND96asr_v4:

Nome do perfil	Fração do SM	Fração de memória	Número de instâncias criadas
MIG 1g.5gb	1/7	1/8	7
MIG 2g.10gb	2/7	2/8	3
MIG 3g.20gb	3/7	4/8	2
MIG 4g.20gb	4/7	4/8	1
MIG 7g.40gb	7/7	8/8	1

Por exemplo, o perfil da instância de GPU de MIG 1g.5gb indica que cada instância de GPU tem 1g de SM (multiprocessadores de streaming) e 5 gb de memória. Nesse caso, a GPU será particionada em sete instâncias.

Os perfis de instância da GPU disponíveis para esse tamanho de VM incluem MIG1g, MIG2g, MIG3g, MIG4g e MIG7g.

Importante

Não é possível alterar o perfil de instância de GPU aplicado após a criação do pool de nós.

Criar um cluster AKS

Crie um grupo de recursos do Azure usando o comando az group create.
```
az group create --name myResourceGroup --location southcentralus
```

Crie um cluster do AKS usando o comando az aks create.

az aks create \
    --resource-group myResourceGroup \
    --name myAKSCluster \
    --generate-ssh-keys

Configure kubectl para se conectar ao seu cluster do AKS usando o comando az aks get-credentials.
```
az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
```

Criar um pool de nós de GPU com várias instâncias

Você pode usar a CLI do Azure ou uma solicitação HTTP para a API do ARM para criar o pool de nós.

CLI do Azure
Solicitação HTTP

Crie um pool de nós de GPU de várias instâncias usando o comando az aks nodepool add e especifique o perfil de instância de GPU. O exemplo a seguir cria um pool de nós com o tamanho da Standard_ND96asr_v4 VM de GPU compatível com MIG.
```
az aks nodepool add \
    --name aks-mignode \
    --resource-group myResourceGroup \
    --cluster-name myAKSCluster \
    --node-vm-size Standard_ND96asr_v4 \
    --node-count 1 \
    --gpu-instance-profile MIG1g
```

Crie um pool de nós de GPU de várias instâncias colocando o perfil de instância de GPU no corpo da solicitação.

{
    "properties": {
        "count": 1,
        "vmSize": "Standard_ND96asr_v4",
        "type": "VirtualMachineScaleSets",
        "gpuInstanceProfile": "MIG1g"
    }
}

Determinar a estratégia de MIG (GPU de várias instâncias)

Antes de instalar os plug-ins da NVIDIA, você precisará especificar qual estratégia de MIG (GPU de várias instâncias) usar para o particionamento de GPU: estratégia única ou estratégia mista. As estratégias não afetarão como você executa cargas de trabalho de CPU, mas como os recursos de GPU serão exibidos.

Estratégia única: a estratégia única trata cada instância da GPU como uma GPU. Se você usar essa estratégia, os recursos de GPU serão exibidos como nvidia.com/gpu: 1.
Estratégia mista: a estratégia mista expõe as instâncias e o perfil de instância da GPU. Se você usar essa estratégia, o recurso de GPU será exibido como nvidia.com/mig1g.5gb: 1.

Instalar o plug-in do dispositivo NVIDIA e os componentes GFD (descoberta de recursos de GPU)

Defina sua estratégia de MIG como uma variável de ambiente. Você pode usar estratégias únicas ou mistas.
```
# Single strategy
export MIG_STRATEGY=single

# Mixed strategy
export MIG_STRATEGY=mixed
```
Adicione o repositório Helm do plug-in de dispositivo NVIDIA usando os comandos helm repo add e helm repo update.
```
helm repo add nvdp https://nvidia.github.io/k8s-device-plugin
helm repo update
```

Instale o plug-in do dispositivo NVIDIA usando o comando helm install.

helm install nvdp nvdp/nvidia-device-plugin \
--version=0.15.0 \
--generate-name \
--set migStrategy=${MIG_STRATEGY} \
--set gfd.enabled=true \
--namespace nvidia-device-plugin \
--create-namespace

Observação

A instalação do Helm do plug-in de dispositivo NVIDIA versão 0.15.0 e superior consolida o plug-in do dispositivo e os repositórios GFD. A instalação separada do Helm do componente de software GFD não é recomendada neste tutorial.

Confirmar a capacidade da GPU de várias instâncias

Verifique a conexão kubectl com o cluster usando o comando kubectl get para retornar uma lista dos nós de cluster.
```
kubectl get nodes -o wide
```
Confirme se o nó tem a capacidade de GPU de várias instâncias usando o comando kubectl describe node. O comando de exemplo a seguir descreve o nó chamado aks-mignode, que usa MIG1g como o perfil de instância de GPU.
```
kubectl describe node aks-mignode
```
Sua saída deve ser parecida com o seguinte exemplo de saída:
```
# Single strategy output
Allocatable:
    nvidia.com/gpu: 56

# Mixed strategy output
Allocatable:
    nvidia.com/mig-1g.5gb: 56
```

Agendar trabalho

Os exemplos a seguir são baseados na imagem base CUDA versão 12.1.1 para Ubuntu22.04, marcada como 12.1.1-base-ubuntu22.04.

Estratégia única

Crie um arquivo chamado single-strategy-example.yaml e copie-o para o manifesto a seguir.

apiVersion: v1
kind: Pod
metadata:
  name: nvidia-single
spec:
  containers:
  - name: nvidia-single
    image: nvidia/cuda:12.1.1-base-ubuntu22.04
    command: ["/bin/sh"]
    args: ["-c","sleep 1000"]
    resources:
      limits:
        "nvidia.com/gpu": 1

Implante o aplicativo usando o comando kubectl apply e especifique o nome do manifesto YAML.
```
kubectl apply -f single-strategy-example.yaml
```

Verifique os dispositivos de GPU alocados usando o comando kubectl exec. Esse comando retorna uma lista dos nós de cluster.

kubectl exec nvidia-single -- nvidia-smi -L

O exemplo a seguir é semelhante à saída que mostra as implantações e serviços criados com êxito:

GPU 0: NVIDIA A100 40GB PCIe (UUID: GPU-48aeb943-9458-4282-da24-e5f49e0db44b)
MIG 1g.5gb     Device  0: (UUID: MIG-fb42055e-9e53-5764-9278-438605a3014c)
MIG 1g.5gb     Device  1: (UUID: MIG-3d4db13e-c42d-5555-98f4-8b50389791bc)
MIG 1g.5gb     Device  2: (UUID: MIG-de819d17-9382-56a2-b9ca-aec36c88014f)
MIG 1g.5gb     Device  3: (UUID: MIG-50ab4b32-92db-5567-bf6d-fac646fe29f2)
MIG 1g.5gb     Device  4: (UUID: MIG-7b6b1b6e-5101-58a4-b5f5-21563789e62e)
MIG 1g.5gb     Device  5: (UUID: MIG-14549027-dd49-5cc0-bca4-55e67011bd85)
MIG 1g.5gb     Device  6: (UUID: MIG-37e055e8-8890-567f-a646-ebf9fde3ce7a)

Estratégia mista

Crie um arquivo chamado mixed-strategy-example.yaml e copie-o para o manifesto a seguir.

apiVersion: v1
kind: Pod
metadata:
  name: nvidia-mixed
spec:
  containers:
  - name: nvidia-mixed
    image: nvidia/cuda:12.1.1-base-ubuntu22.04
    command: ["/bin/sh"]
    args: ["-c","sleep 100"]
    resources:
      limits:
        "nvidia.com/mig-1g.5gb": 1

Implante o aplicativo usando o comando kubectl apply e especifique o nome do manifesto YAML.
```
kubectl apply -f mixed-strategy-example.yaml
```
Verifique os dispositivos de GPU alocados usando o comando kubectl exec. Esse comando retorna uma lista dos nós de cluster.
```
kubectl exec nvidia-mixed -- nvidia-smi -L
```
O exemplo a seguir é semelhante à saída que mostra as implantações e serviços criados com êxito:
```
GPU 0: NVIDIA A100 40GB PCIe (UUID: GPU-48aeb943-9458-4282-da24-e5f49e0db44b)
MIG 1g.5gb     Device  0: (UUID: MIG-fb42055e-9e53-5764-9278-438605a3014c)
```

Importante

A marca latest para imagens CUDA foi preterida no Docker Hub. Consulte o repositório da NVIDIA para obter as imagens mais recentes e as marcas correspondentes.

Solução de problemas

Se você não vir a capacidade de GPU de várias instâncias após a criação do pool de nós, confirme se a versão da API não é mais antiga que 2021-08-01.

Próximas etapas

Para saber mais sobre GPUs no Serviço de Kubernetes do Azure, confira:

Compartilhar via