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

Artigo
08/02/2024

A GPU A100 da NVIDIA pode ser dividida em até sete instâncias independentes. Cada instância tem sua própria memória e SM (Multiprocessador de fluxo). 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 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.
Você não pode usar o Dimensionador Automático de Cluster com pools de nós 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 de instância da GPU MIG 1g.5gb indica que cada instância da GPU terá um SM (recurso de computação) de 1 GB 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 instância 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\
    --node-count 1 \
    --generate-ssh-keys

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.

az aks nodepool add \
    --name mignode \
    --resource-group myResourceGroup \
    --cluster-name myAKSCluster \
    --node-vm-size Standard_ND96asr_v4 \
    --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ê precisa 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 a descoberta de recursos da 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 plug-in do dispositivo Nvidia e os repositórios helm de descoberta de recursos de GPU usando os comandos helm repo add e helm repo update.

helm repo add nvdp https://nvidia.github.io/k8s-device-plugin
helm repo add nvgfd https://nvidia.github.io/gpu-feature-discovery
helm repo update

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

helm install \
--version=0.14.0 \
--generate-name \
--set migStrategy=${MIG_STRATEGY} \
nvdp/nvidia-device-plugin

Instale a descoberta de recursos de GPU usando o comando helm install.

helm install \
--version=0.2.0 \
--generate-name \
--set migStrategy=${MIG_STRATEGY} \
nvgfd/gpu-feature-discovery

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

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
```
Verifique a conexão 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 mignode, que usa MIG1g como o perfil de instância de GPU.
```
kubectl describe node 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 obter mais informações sobre pools de nós do AKS, confira Gerenciar pools de nós para um cluster no AKS.

Compartilhar via