Como executar GPUs com várias instâncias

Esta página fornece instruções sobre como aumentar a utilização e reduzir custos executando GPUs de várias instâncias. Com essa configuração, você particiona uma unidade de processamento gráfico (GPU) NVIDIA A100 ou H100 para compartilhar uma única GPU em vários contêineres no Google Kubernetes Engine (GKE).

Antes de ler esta página, confira se você conhece os conceitos do Kubernetes, como pods, nós, implantações e namespaces, e os conceitos do GKE, como pools de nós, escalonamento automático e provisionamento automático.

Introdução

O Kubernetes aloca uma GPU completa por contêiner, mesmo que o contêiner só precise de uma fração dela para a carga de trabalho, o que pode levar ao desperdício de recursos e a custos excessivos, especialmente ao usar a geração mais recente de GPUs avançadas. Melhore a sua utilização com as GPUs de várias instâncias, que permitem particionar uma única GPU com suporte em até sete frações. Cada fração pode ser alocada de modo independente para um contêiner no nó, com um máximo de sete contêineres por GPU. As GPUs de várias instâncias fornecem isolamento de hardware entre as cargas de trabalho e QoS consistente e previsível para todos os contêineres em execução na GPU.

Para aplicativos CUDA®, as GPUs de várias instâncias são amplamente transparentes. Cada partição de GPU aparece como um recurso de GPU normal e o modelo de programação permanece inalterado.

Para mais informações sobre as GPUs de várias instâncias, consulte o Guia do usuário de GPUs NVIDIA com várias instâncias.

GPUs com suporte

Os seguintes tipos dão suporte às GPUs de várias instâncias:

  • NVIDIA A100 (40 GB)
  • NVIDIA A100 (80 GB)

  • NVIDIA H100 (80 GB)

Partições de GPU com várias instâncias

A GPU A100 e a GPU H100 consistem em sete unidades de computação e oito unidades de memória, que podem ser particionadas em instâncias de GPU de tamanhos variados. Os tamanhos de partição de GPU usam a seguinte sintaxe: [compute]g.[memory]gb. Por exemplo, um tamanho de partição de GPU de 1g.5gb refere-se a uma instância de GPU com uma unidade de computação (1/7 de multiprocessadores de streaming na GPU) e uma unidade de memória (5 GB). O tamanho da partição das GPUs pode ser especificado ao implantar uma carga de trabalho do Autopilot ou ao criar um cluster padrão.

A tabela de particionamento no guia do usuário de GPUs NVIDIA com várias instâncias lista todos os diferentes tamanhos de partição de GPU, além da quantidade de recursos de computação e memória disponíveis em cada partição. A tabela também mostra o número de instâncias de GPU para cada tamanho de partição que podem ser criadas na GPU.

A seguinte tabela lista os tamanhos de partição com suporte no GKE:

Tamanho de partição Instâncias de GPU
GPU: NVIDIA A100 (40GB) (nvidia-tesla-a100)
1g.5gb 7
2g.10gb 3
3g.20gb 2
7g.40gb 1
GPU: NVIDIA A100 (80GB) (nvidia-a100-80gb)
1g.10gb 7
2g.20gb 3
3g.40gb 2
7g.80gb 1
GPU: NVIDIA H100 (80 GB) (nvidia-h100-80gb e nvidia-h100-mega-80gb)
1g.10gb 7
1g.20gb 4
2g.20gb 3
3g.40gb 2
7g.80gb 1

A GPU de cada nó em um pool é particionada da mesma maneira. Por exemplo, considere um pool de nós com dois nós, quatro GPUs em cada nó e um tamanho de partição de 1g.5gb. O GKE cria sete partições de tamanho 1g.5gb em cada GPU. Como há quatro GPUs em cada nó, há 28 1g.5gb partições de GPU disponíveis em cada nó. Como há dois nós no pool, um total de 56 partições de GPU de 1g.5gb está disponível em todo o pool de nós.

Para criar um cluster do GKE Standard com mais de um tipo de partição de GPU, crie vários pools de nós. Por exemplo, se você quiser nós com partições de GPU de 1g.5gb e 3g.20gb em um cluster, crie dois pools de nós: um com o tamanho de partição de GPU definido como 1g.5gb e o outro com 3g.20gb.

Um cluster do GKE Autopilot cria nós automaticamente com a configuração de partição correta quando você cria cargas de trabalho que exigem tamanhos de partição diferentes.

Cada nó é rotulado com o tamanho das partições de GPU que estão disponíveis no nó. Essa rotulagem permite que cargas de trabalho segmentem os nós com o tamanho de partição de GPU necessário. Por exemplo, em um nó com instâncias de GPU de 1g.5gb, o nó é rotulado como:

cloud.google.com/gke-gpu-partition-size=1g.5gb

Como funciona

Para usar GPUs com várias instâncias, execute as seguintes tarefas:

  1. Criar um cluster com GPUs com várias instâncias ativadas.
  2. Instalar drivers manualmente.
  3. Verificar quantos recursos de GPU estão no nó.
  4. Implantar contêineres usando GPUs de várias instâncias.

Preços

As GPUs de várias instâncias são exclusivamente A100 e H100 e estão sujeitas aos preços correspondentes de GPU, além de outros produtos usados para executar as cargas de trabalho. Só é possível conectar GPUs inteiras a nós no cluster para particionamento. Consulte a página Preços das GPUs para mais informações.

Limitações

  • O uso de partições de GPU com várias instâncias com o GKE não é recomendado para cargas de trabalho não confiáveis.
  • As partições de GPU de escalonamento automático e de provisionamento automático são totalmente compatíveis com o GKE 1.20.7-gke.400 ou versões mais recentes. Nas versões anteriores, apenas os pools de nós com pelo menos um nó podem ser escalonados automaticamente com base na demanda por tamanhos específicos de partição de GPU das cargas de trabalho.
  • As métricas de utilização da GPU (por exemplo, duty_cycle) não estão disponíveis para GPUs de várias instâncias.
  • O recurso de várias instâncias divide uma GPU física em instâncias discretas, cada uma isolada das outras no nível do hardware. Um contêiner que usa uma instância de GPU de várias instâncias só pode acessar os recursos de CPU e memória disponíveis para essa instância.
  • Um pod só pode consumir até uma instância de GPU de várias instâncias.

Antes de começar

Antes de começar, verifique se você realizou as tarefas a seguir:

  • Ativar a API Google Kubernetes Engine.
    • Ativar a API Google Kubernetes Engine
  • Se você quiser usar a Google Cloud CLI para essa tarefa, instale e, em seguida, inicialize a CLI gcloud. Se você instalou a CLI gcloud anteriormente, instale a versão mais recente executando gcloud components update.
  • No Autopilot, as GPUs de várias instâncias são compatíveis com a versão 1.29.3-gke.1093000 e posterior do GKE.
  • É necessário ter cota suficiente de GPU NVIDIA A100. Consulte Como solicitar um aumento na cota.
  • Se quiser usar GPUs de várias instâncias com o Autopilot, saiba mais sobre o uso de GPUs com o Autopilot em Implantar cargas de trabalho de GPU no Autopilot.
  • O GKE atribui a classe de computação Accelerator a todas as cargas de trabalho de GPU de várias instâncias em clusters do Autopilot.

Como criar um cluster com GPUs com várias instâncias ativadas

Se você usar o GKE Standard, será necessário ativar GPUs de várias instâncias no cluster. Os clusters do Autopilot que executam a versão 1.29.3-gke.1093000 e mais recentes ativam as GPUs de várias instâncias por padrão. Para usar GPUs de várias instâncias no Autopilot, consulte a seção Implantar contêineres usando a GPU de várias instâncias desta página.

Ao criar um cluster Standard com GPUs de várias instâncias, você precisa especificar gpuPartitionSize, além de acceleratorType e acceleratorCount. acceleratorType precisa ser nvidia-tesla-a100, nvidia-a100-80gb ou nvidia-h100-80gb.

O exemplo a seguir mostra como criar um cluster do GKE com um nó e sete partições de GPU de tamanho 1g.5gb no nó. As outras etapas nesta página usam um tamanho de partição de GPU de 1g.5gb, o que cria sete partições em cada GPU. Também é possível usar qualquer um dos tamanhos compatíveis de partição de GPU mencionados anteriormente.

É possível usar a CLI do Google Cloud ou o Terraform.

gcloud

Como criar um cluster com GPUs com várias instâncias ativadas:

gcloud container clusters create CLUSTER_NAME  \
    --project=PROJECT_ID  \
    --zone ZONE  \
    --cluster-version=CLUSTER_VERSION  \
    --accelerator type=nvidia-tesla-a100,count=1,gpu-partition-size=1g.5gb,gpu-driver-version=DRIVER_VERSION  \
    --machine-type=a2-highgpu-1g  \
    --num-nodes=1

Substitua:

  • CLUSTER_NAME: o nome do novo cluster;
  • PROJECT_ID: o ID do seu projeto do Google Cloud.
  • ZONE: a zona de computação do plano de controle do cluster.
  • CLUSTER_VERSION: a versão precisa ser 1.19.7-gke.2503 ou posterior.
  • DRIVER_VERSION: a versão do driver NVIDIA a ser instalado. Será um dos seguintes valores:
    • default: instale a versão padrão do driver para a versão do GKE.
    • latest: instale a versão mais recente disponível do driver para a versão do GKE. Disponível apenas para nós que usam o Container-Optimized OS.
    • disabled: pula a instalação automática do driver. Você precisa instalar manualmente um driver depois de criar o cluster. Se você omitir gpu-driver-version, essa será a opção padrão.

Terraform

Para criar um cluster com GPUs de várias instâncias ativadas usando o Terraform, consulte o exemplo a seguir:

resource "google_container_cluster" "default" {
  name               = "gke-standard-zonal-gpu"
  location           = "us-central1-a"
  initial_node_count = 1

  node_config {
    guest_accelerator {
      type  = "nvidia-tesla-t4"
      count = 1
      gpu_driver_installation_config {
        gpu_driver_version = "LATEST"
      }
    }
    machine_type = "n1-standard-2"
  }

  # Set `deletion_protection` to `true` will ensure that one cannot
  # accidentally delete this instance by use of Terraform.
  deletion_protection = false
}

Para saber mais como usar o Terraform, consulte o Suporte do Terraform para GKE.

Conectar ao cluster

Configure kubectl para se conectar ao cluster recém-criado:

gcloud container clusters get-credentials CLUSTER_NAME

Instalar drivers

Se você optar por desativar a instalação automática do driver ao criar o cluster ou estiver executando uma versão do GKE anterior à 1.27.2-gke.1200, instale de modo manual um driver NVIDIA com suporte após a conclusão da criação. As GPUs de várias instâncias exigem um driver NVIDIA versão 450.80.02 ou posterior.

Depois que o driver for instalado, o modo GPU de várias instâncias será ativado. Se você instalou drivers automaticamente, os nós serão reiniciados quando o plug-in do dispositivo GPU começar a criar partições de GPU. Se você instalou drivers manualmente, os nós serão reiniciados quando a instalação do driver for concluída. Talvez leve alguns minutos para a reinicialização ser concluída.

Como verificar quantos recursos de GPU estão no nó

Execute o seguinte comando para verificar se a capacidade e a contagem alocável dos recursos do nvidia.com/gpu são 7:

kubectl describe nodes

Esta é a saída do comando:

...
Capacity:
  ...
  nvidia.com/gpu:             7
Allocatable:
  ...
  nvidia.com/gpu:             7

Implantar contêineres usando a GPU de várias instâncias

É possível implantar até um contêiner por dispositivo de GPU com várias instâncias no nó. Neste exemplo, com um tamanho de partição de 1g.5gb, há sete partições de GPU com várias instâncias disponíveis no nó. Como resultado, é possível implantar até sete contêineres que solicitam GPUs nesse nó.

  1. Este é um exemplo que inicia o contêiner cuda:11.0.3-base-ubi7 e executa nvidia-smi para imprimir o UUID da GPU no contêiner. Neste exemplo, há sete contêineres, e cada contêiner recebe uma partição de GPU. Este exemplo também define o seletor de nós cloud.google.com/gke-gpu-partition-size para segmentar nós com partições de GPU de 1g.5gb.

    Piloto automático

          cat &lt&ltEOF | kubectl apply -f -
      apiVersion: apps/v1
      kind: Deployment
      metadata:
        name: cuda-simple
      spec:
        replicas: 7
        selector:
          matchLabels:
            app: cuda-simple
        template:
          metadata:
            labels:
              app: cuda-simple
          spec:
            nodeSelector:
              cloud.google.com/gke-gpu-partition-size: 1g.5gb
              cloud.google.com/gke-accelerator: nvidia-tesla-a100
              cloud.google.com/gke-accelerator-count: "1"
            containers:
            - name: cuda-simple
              image: nvidia/cuda:11.0.3-base-ubi7
              command:
              - bash
              - -c
              - |
                /usr/local/nvidia/bin/nvidia-smi -L; sleep 300
              resources:
                limits:
                  nvidia.com/gpu: 1
      EOF

    Esse manifesto faz o seguinte:

    • Solicita o tipo de GPU nvidia-tesla-a100 definindo o seletor de nós cloud.google.com/gke-accelerator.
    • Divide a GPU no tamanho de partição 1g.5gb.
    • Anexa uma única GPU ao nó definindo o seletor de nós cloud.google.com/gke-accelerator-count.

    Padrão

          cat &lt&ltEOF | kubectl apply -f -
      apiVersion: apps/v1
      kind: Deployment
      metadata:
        name: cuda-simple
      spec:
        replicas: 7
        selector:
          matchLabels:
            app: cuda-simple
        template:
          metadata:
            labels:
              app: cuda-simple
          spec:
            nodeSelector:
              cloud.google.com/gke-gpu-partition-size: 1g.5gb
            containers:
            - name: cuda-simple
              image: nvidia/cuda:11.0.3-base-ubi7
              command:
              - bash
              - -c
              - |
                /usr/local/nvidia/bin/nvidia-smi -L; sleep 300
              resources:
                limits:
                  nvidia.com/gpu: 1
      EOF

    Esse manifesto faz o seguinte:

    • Solicita uma única GPU com o tamanho de partição 1g.5gb.

  2. Verifique se todos os sete pods estão em execução:

    kubectl get pods

    Esta é a saída do comando:

    NAME                           READY   STATUS    RESTARTS   AGE
cuda-simple-849c47f6f6-4twr2   1/1     Running   0          7s
cuda-simple-849c47f6f6-8cjrb   1/1     Running   0          7s
cuda-simple-849c47f6f6-cfp2s   1/1     Running   0          7s
cuda-simple-849c47f6f6-dts6g   1/1     Running   0          7s
cuda-simple-849c47f6f6-fk2bs   1/1     Running   0          7s
cuda-simple-849c47f6f6-kcv52   1/1     Running   0          7s
cuda-simple-849c47f6f6-pjljc   1/1     Running   0          7s

  3. Visualize os registros para conferir o UUID da GPU usando o nome de qualquer pod do comando anterior:

    kubectl logs cuda-simple-849c47f6f6-4twr2

    Esta é a saída do comando:

    GPU 0: A100-SXM4-40GB (UUID: GPU-45eafa61-be49-c331-f8a2-282736687ab1)
  MIG 1g.5gb Device 0: (UUID: MIG-GPU-45eafa61-be49-c331-f8a2-282736687ab1/11/0)

A seguir