Implantar cargas de trabalho da GPU no Autopilot

Nesta página, mostramos como solicitar GPUs para acelerar tarefas nas cargas de trabalho do Autopilot do Google Kubernetes Engine (GKE). Esta página também descreve como o Autopilot executa GPUs, como seu modelo de preços muda dependendo da versão do GKE, como definir solicitações e limites de recursos de pods e como monitorar cargas de trabalho de GPU.

Esta página é destinada a administradores e operadores de plataforma e especialistas em dados e IA que querem solicitar GPUs para cargas de trabalho que executam tarefas como treinamento ou inferência de machine learning (ML). Para saber mais sobre as funções, responsabilidades e tarefas de exemplo comuns referenciadas no conteúdo do Google Cloud, consulte Funções e tarefas de usuário comuns do GKE Enterprise.

Antes de continuar, confira se você conhece os seguintes conceitos:

Sobre a seleção de aceleradores em pods

O Autopilot usa a classe de computação Accelerator especializada para executar pods de GPU. Com essa classe de computação, o GKE coloca pods em nós da GPU, fornecendo aos pods acesso a recursos avançados na máquina virtual (VM). Para usar essa classe em uma carga de trabalho de GPU, faça uma das seguintes ações, dependendo da versão do GKE:

  • Versão 1.29.4-gke.1427000 e mais recentes: solicite GPUs no manifesto da carga de trabalho. Também é possível usar recursos de compartilhamento de GPU, como o compartilhamento de tempo. O GKE não modifica os manifestos da carga de trabalho para adicionar um seletor de nós ou uma anotação à classe Accelerator.
  • Versão 1.29 até, mas sem incluir, a versão 1.29.4-gke.142700: especifique o seletor de nós cloud.google.com/compute-class: Accelerator no manifesto do pod e solicite GPUs. Se você especificar esse seletor de nós, também poderá usar recursos de compartilhamento de GPU, como o compartilhamento de tempo.
  • Versão 1.28.9-gke.1069000 até a versão 1.29, mas não incluindo: especifique o seletor de nó cloud.google.com/compute-class: Accelerator no manifesto do pod com os selecionadores de GPU. Se você especificar esse seletor de nós, também poderá usar recursos de compartilhamento de GPU, como o compartilhamento de tempo.

A classe de computação Accelerator não tem suporte para versões anteriores à 1.28.9-gke.1069000. Em vez disso, o GKE trata os pods de GPU nessas versões de maneira semelhante a outros pods do Autopilot, e você é cobrado pelas solicitações de recursos. Para mais detalhes, consulte Preços.

Compatibilidade com os recursos do GKE

A tabela a seguir mostra os recursos compatíveis do GKE para cada método de seleção de aceleradores no Autopilot do GKE:

Classe de computação Accelerator selecionada Compatibilidade com os recursos do GKE

Preços

A tabela a seguir descreve como o modelo de faturamento usado pelo GKE depende da versão do cluster. Para uma descrição dos modelos de faturamento do Autopilot do GKE, consulte Preços do Autopilot.

Versão GKE Preços
1.29.4-gke.1427000 e posterior

Modelo de faturamento baseado em nó. Todos os pods de GPU usam a classe de computação Accelerator. Você é cobrado pelo hardware do Compute Engine que executa suas cargas de trabalho da GPU, além do nível Premium do Autopilot para gerenciamento de nós e escalonabilidade. Saiba mais em Preços do modo Autopilot.
Da versão 1.29 até a versão 1.29.4-gke.1427000, mas sem incluir esta última.

O modelo de faturamento depende dos seletores de nó especificados, conforme abaixo:

  • cloud.google.com/compute-class: Accelerator: usa o modelo de faturamento baseado em nó e a classe de computação Accelerator.
  • Nenhum seletor de classe de computação: usa o modelo de faturamento baseado em pods.

Só é possível usar recursos como GPUs de várias instâncias ou compartilhamento de tempo se você especificar explicitamente o seletor de nós cloud.google.com/compute-class: Accelerator.

Para mais detalhes, consulte a seção "Pods com requisitos de hardware específicos" em Preços do Kubernetes Engine.
Da versão 1.28.6-gke.1095000 até a versão 1.29, mas sem incluir esta última

Modelo de faturamento baseado em nó, independentemente de você especificar a classe de computação do Accelerator nos manifestos do pod.

Só é possível usar recursos como GPUs de várias instâncias ou compartilhamento de tempo se você especificar explicitamente o seletor de nós cloud.google.com/compute-class: Accelerator.

Para mais detalhes, consulte a seção "Pods com requisitos de hardware específicos" em Preços do Kubernetes Engine.
Versões anteriores à 1.28.6-gke.1095000

Modelo de faturamento baseado em pods. O faturamento é feito com base nas solicitações de recursos do pod da GPU. Para mais detalhes, consulte a seção "Pods com requisitos de hardware específicos" em Preços do Kubernetes Engine.

Antes de começar

Antes de começar, veja se você realizou as seguintes tarefas:

  • Ative a API Google Kubernetes Engine.
    • Ativar a API Google Kubernetes Engine
  • Se você quiser usar a CLI do Google Cloud para essa tarefa, instale e, em seguida, inicialize a CLI gcloud. Se você instalou a gcloud CLI anteriormente, instale a versão mais recente executando gcloud components update.

  • Verifique se você tem um cluster do Autopilot do GKE com uma das seguintes versões em execução:

    • Classe de computação Accelerator: qualquer versão de patch de 1.28 a partir de 1.28.6-gke.1095000
      • GPUs NVIDIA H100 Mega (80 GB): 1.28.9-gke.1250000 ou mais recente e 1.29.4-gke.1542000 ou mais recente
      • GPUs NVIDIA H100 (80 GB): 1.28.6-gke.1369000 ou mais recente e 1.29.1-gke.1575000 ou mais recente
      • Vários pods de GPU por VM: 1.29.2-gke.1355000 ou mais recente

    • Nenhuma classe de computação selecionada:

      • GPUs NVIDIA L4: 1.28.3-gke.1203000 ou mais recentes
      • GPUs NVIDIA A100 (80 GB): 1.27 ou mais recentes

  • Verifique se você tem cotas de GPU suficientes disponíveis no seu projeto. É preciso ter cota de GPU do Compute Engine suficiente para os modelos de GPU que você quer criar em cada região. Se você precisar de mais cota, solicite uma cota de GPU.

Limitações

  • GPUs de compartilhamento de tempo e GPUs de várias instâncias estão disponíveis com o Autopilot no GKE versão 1.29.3-gke.1093000 e mais recente.
  • A disponibilidade da GPU depende da região do Google Cloud do cluster do Autopilot e da cota de GPU. Para encontrar um modelo de GPU por região ou zona, consulte Disponibilidade de regiões e zonas de GPU.
  • Para GPUs NVIDIA A100 (80 GB), é cobrado um preço fixo pelos SSDs locais anexados aos nós, independentemente de seus pods usarem essa capacidade.
  • Para versões do GKE anteriores à 1.29.2-gke.1355000, se você solicitar explicitamente um nó da GPU atual específico para seu pod, o pod precisará consumir todos os recursos da GPU no nó. Por exemplo, se o nó atual tiver oito GPUs e os contêineres do pod solicitarem um total de quatro GPUs, o Autopilot rejeitará o pod.
  • No GKE versão 1.29.2-gke.1355000 ou mais recente, se você quiser que vários pods de GPU se encaixem em um único nó, a soma das solicitações de GPU desses pods precisa ser menor ou igual a o número de recursos de GPU anexados a esse nó. Por exemplo, um nó com gke-accelerator-count de 4 pode acomodar até quatro pods que solicitam uma GPU cada.

Colocar vários pods em um único nó de GPU é útil em situações como as seguintes:

  • Você tem reservas de capacidade para tipos grandes de máquinas Accelerator e executa cargas de trabalho de GPU única. Portanto, a implantação de um pod por nó desperdiçaria as outras GPUs na máquina.
  • Você tem cargas de trabalho de GPU que precisam ser executadas no mesmo host

Nessas situações, recomendamos que você use todas as GPUs no nó, garantindo que a soma das solicitações de recursos da GPU do pod no nó seja igual ao número de GPUs anexadas ao nó.

Solicitar GPUs nos seus contêineres

Para solicitar recursos de GPU para seus contêineres, adicione os seguintes campos à especificação do seu pod. Dependendo dos requisitos da carga de trabalho, você tem a opção de omitir o seletor cloud.google.com/gke-accelerator-count.

apiVersion: v1
kind: Pod
metadata:
  name: my-gpu-pod
spec:
  nodeSelector:
    cloud.google.com/gke-accelerator: GPU_TYPE
    cloud.google.com/gke-accelerator-count: GPU_COUNT
  containers:
  - name: my-gpu-container
    image: nvidia/cuda:11.0.3-runtime-ubuntu20.04
    command: ["/bin/bash", "-c", "--"]
    args: ["while true; do sleep 600; done;"]
    resources:
      limits:
        nvidia.com/gpu: GPU_QUANTITY

Substitua:

  • GPU_TYPE: o tipo de hardware da GPU. Os valores permitidos são os seguintes:
    • nvidia-h100-mega-80gb: NVIDIA H100 Mega (80GB)
    • nvidia-h100-80gb: NVIDIA H100 (80GB)
    • nvidia-a100-80gb: NVIDIA A100 (80GB)
    • nvidia-tesla-a100: NVIDIA A100 (40GB)
    • nvidia-l4: NVIDIA L4
    • nvidia-tesla-t4: NVIDIA T4
  • GPU_COUNT: o número total de GPUs disponíveis para anexar ao nó. Precisa ser maior ou igual a GPU_QUANTITY e uma quantidade de GPU compatível com o tipo de GPU selecionado. Se este nodeSelector for omitido, o Autopilot vai colocar um pod em cada nó da GPU.
  • GPU_QUANTITY: o número de GPUs a serem alocadas para o contêiner. Precisa ser menor ou igual a GPU_COUNT e uma quantidade de GPU compatível com o tipo de GPU selecionado.

Para saber como você vai receber cobranças pelo uso do acelerador no modo Autopilot, consulte a seção Preços.

Especifique o tipo e a quantidade de GPU na especificação do pod. Se você omitir um desses valores, o Autopilot rejeitará o pod.

Quando você implanta esse manifesto, o Autopilot instala automaticamente os drivers NVIDIA padrão da versão do GKE do nó. Na versão 1.29.2-gke.1108000 e posterior, é possível instalar a versão mais recente do driver para essa versão do GKE adicionando o seguinte seletor de nós ao manifesto:

spec:
  nodeSelector:
    cloud.google.com/gke-gpu-driver-version: "DRIVER_VERSION"

Substitua DRIVER_VERSION por um dos seguintes valores:

  • default: o driver padrão e estável para a versão do GKE do seu nó. Se você omitir o nodeSeletor do manifesto, essa será a opção padrão.
  • latest: a versão mais recente do driver disponível para a versão do GKE do nó.

Solicitações de CPU e memória para pods de GPU do Autopilot

Ao definir os pods de GPU, também é necessário solicitar recursos de CPU e memória para que os contêineres funcionem conforme o esperado. O Autopilot impõe específicos, máximos e padrões mínimos de CPU e memória com base no tipo e na quantidade de GPU. Se você executar vários pods de GPU em um único nó, especifique a CPU e a memória. Caso contrário, o padrão será a capacidade total do nó. Veja mais detalhes em Solicitações de recursos no Autopilot.

A especificação do pod é semelhante ao exemplo a seguir, que solicita quatro GPUs T4:

apiVersion: v1
kind: Pod
metadata:
  name: t4-pod
spec:
  nodeSelector:
    cloud.google.com/gke-accelerator: "nvidia-tesla-t4"
  containers:
  - name: t4-container-1
    image: nvidia/cuda:11.0.3-runtime-ubuntu20.04
    command: ["/bin/bash", "-c", "--"]
    args: ["while true; do sleep 600; done;"]
    resources:
      limits:
        nvidia.com/gpu: 3
        cpu: "54"
        memory: "54Gi"
      requests:
        cpu: "54"
        memory: "54Gi"
  - name: t4-container-2
    image: nvidia/cuda:11.0.3-runtime-ubuntu20.04
    command: ["/bin/bash", "-c", "--"]
    args: ["while true; do sleep 600; done;"]
    resources:
      limits:
        nvidia.com/gpu: 1
        cpu: "18"
        memory: "18Gi"
      requests:
        cpu: "18"
        memory: "18Gi"

Este manifesto especifica limits para recursos de CPU e memória. Se você omitir o limits para CPU ou memória no GKE versão 1.29.2-gke.1060000 e posterior, o GKE fornecerá aos seus pods a classe QoS Burstable e permitirá que seus pods usem bursts em recursos não utilizados da soma de solicitações de recursos no nó. Para mais informações, acesse Configurar o bursting de pods no GKE.

Solicitações de armazenamento temporário para pods de GPU do Autopilot

Também é possível solicitar armazenamento temporário em pods que precisam de armazenamento de curta duração. O armazenamento temporário máximo e o tipo de hardware de armazenamento usado dependem do tipo e da quantidade de GPUs que o pod solicita. É possível usar o SSD local para armazenamento temporário se estiver usando GPUs NVIDIA L4, a classe de computação Accelerator e executando o patch do GKE versão 1.28.6-gke.1369000 e posterior ou 1.29.1-gke.1575000 e posterior.

Se quiser usar o SSD local para armazenamento temporário, adicione o nodeSeletor da cloud.google.com/gke-ephemeral-storage-local-ssd: "true" ao seu manifesto de carga de trabalho. Confira o exemplo de manifesto em Usar o armazenamento temporário com suporte de SSD local com clusters do Autopilot. As GPUs NVIDIA H100 (80 GB) e NVIDIA A100 (80 GB) sempre usam SSDs locais para armazenamento temporário, e não é possível especificar esse seletor de nós para essas GPUs.

Verificar a alocação da GPU

Para verificar se uma carga de trabalho da GPU implantada tem as GPUs solicitadas, execute o seguinte comando:

kubectl describe node NODE_NAME

Substitua NODE_NAME pelo nome do nó em que o pod foi programado.

O resultado será assim:


apiVersion: v1
kind: Node
metadata:
...
  labels:
    ...
    cloud.google.com/gke-accelerator: nvidia-tesla-t4
    cloud.google.com/gke-accelerator-count: "1"
    cloud.google.com/machine-family: custom-48
    ...
...

Verificar a versão do driver da GPU

Nos clusters do Autopilot, o GKE instala automaticamente drivers de dispositivos NVIDIA em todos os nós da GPU. Para encontrar a versão do driver que o GKE instalou no seu cluster, execute o seguinte comando:

kubectl logs --selector=k8s-app=nvidia-gpu-device-plugin \
    --container="nvidia-gpu-device-plugin" \
    --tail=-1 \
    --namespace=kube-system | grep Driver

O resultado será assim:

I1206 18:37:08.251742    5851 metrics.go:144] nvml initialized successfully. Driver version: 535.104.12

Como funciona a alocação de GPUs no Autopilot

Depois de solicitar um tipo de GPU e uma quantidade para os contêineres em um pod e implantar o pod, acontece o seguinte:

  1. Se não houver nenhum nó de GPU alocável, o Autopilot provisionará um novo nó de GPU para programar o pod. O Autopilot instala automaticamente os drivers da NVIDIA para facilitar o hardware.
  2. O Autopilot adiciona taints de nó ao nó da GPU e as tolerâncias correspondentes ao pod. Isso impede que o GKE programe outros pods no nó da GPU.

O Autopilot coloca exatamente um pod de GPU em cada nó de GPU, bem como quaisquer cargas de trabalho gerenciadas pelo GKE que sejam executadas em todos os nós, além de todos os DaemonSets configurados para tolerar todos os taints de nó.

Executar DaemonSets em cada nó

É possível executar DaemonSets em cada nó, até mesmo nos nós com taints aplicados. Por exemplo, alguns agentes de geração de registros e monitoramento precisam ser executados em cada nó do cluster. É possível configurar esses DaemonSets para ignorar os taints de nós para que o GKE coloque essas cargas de trabalho em cada nó.

Para executar DaemonSets em cada nó do cluster, incluindo os nós da GPU, adicione a seguinte tolerância à especificação:

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: logging-agent
spec:
  tolerations:
  - key: ""
    operator: "Exists"
    effect: ""
  containers:
  - name: logging-agent-v1
    image: IMAGE_PATH

Para executar DaemonSets em nós da GPU específicos no cluster, adicione o seguinte à especificação:

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: logging-agent
spec:
  nodeSelector:
    cloud.google.com/gke-accelerator: "GPU_TYPE"
  tolerations:
  - key: ""
    operator: "Exists"
    effect: ""
  containers:
  - name: logging-agent-v1
    image: IMAGE_PATH

Substitua GPU_TYPE pelo tipo de GPU nos nós de destino. Pode ser um dos seguintes:

  • nvidia-h100-mega-80gb: NVIDIA H100 Mega (80GB)
  • nvidia-h100-80gb: NVIDIA H100 (80GB)
  • nvidia-a100-80gb: NVIDIA A100 (80GB)
  • nvidia-tesla-a100: NVIDIA A100 (40GB)
  • nvidia-l4: NVIDIA L4
  • nvidia-tesla-t4: NVIDIA T4

Casos de uso de GPU no Autopilot

É possível alocar GPUs para contêineres de pods do Autopilot para facilitar cargas de trabalho como as seguintes:

  • Inferência de machine learning (ML)
  • ML treinamento
  • Renderização

Quantidades de GPUs compatíveis

Ao solicitar GPUs na especificação do pod, é preciso usar as seguintes quantidades com base no tipo de GPU:

Quantidades de GPU
NVIDIA L4
nvidia-l4		 1, 2, 4, 8
NVIDIA® T4
nvidia-tesla-t4		 1, 2, 4
NVIDIA A100 (40 GB)
nvidia-tesla-a100		 1, 2, 4, 8, 16
NVIDIA A100 (80 GB)
nvidia-a100-80gb		 1, 2, 4, 8
NVIDIA H100 (80 GB)
nvidia-h100-80gb		 8
NVIDIA H100 Mega (80GB)
nvidia-h100-mega-80gb		 8

Se você solicitar uma quantidade de GPU não suportada para esse tipo, o Autopilot rejeitará seu pod.

Monitorar o desempenho da carga de trabalho do nó da GPU

Se o cluster do GKE tiver métricas do sistema ativadas, as seguintes métricas estarão disponíveis no Cloud Monitoring para monitorar o desempenho da carga de trabalho da GPU:

  • Ciclo de trabalho (container/accelerator/duty_cycle): porcentagem de tempo durante o período de amostra anterior (10 segundos) em que o acelerador estava realizando o processamento. Entre 1 e 100.
  • Uso da memória (container/accelerator/memory_used): quantidade de memória do acelerador alocada em bytes.
  • Capacidade de memória (container/accelerator/memory_total): memória total do acelerador em bytes.

É possível usar painéis predefinidos para monitorar seus clusters com nós de GPU. Para mais informações, consulte Conferir métricas de observabilidade. Para informações gerais sobre como monitorar os clusters e os recursos deles, consulte Observabilidade no GKE.

Conferir as métricas de uso das cargas de trabalho

Veja as métricas de uso da GPU da carga de trabalho no painel Cargas de trabalho no Console do Google Cloud.

Para ver o uso da GPU nas cargas de trabalho, siga estas etapas:

  1. Acesse a página Cargas de trabalho no console do Google Cloud.

    Acesse "Cargas de trabalho"
  2. Selecionar uma carga de trabalho

O painel Cargas de trabalho exibe gráficos de uso e capacidade de memória da GPU e de ciclo de trabalho da GPU.

Conferir as métricas do NVIDIA Data Center GPU Manager (DCGM)

É possível coletar e conferir as métricas do NVIDIA DCGM usando o Google Cloud Managed Service para Prometheus. Para clusters do Autopilot, o GKE instala os drivers. Para clusters Standard, é preciso instalar os drivers da NVIDIA.

Para instruções sobre como implantar o pacote do DCGM gerenciado pelo GKE, consulte Coletar e visualizar métricas do NVIDIA Data Center GPU Manager (DCGM)

A seguir