Implantar cargas de trabalho da GPU no Autopilot

Nesta página, mostramos como solicitar aceleradores de hardware (GPUs) nas cargas de trabalho do Autopilot do Google Kubernetes Engine (GKE).

O Autopilot oferece 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). Também é possível executar pods de GPU sem selecionar a classe de computação Accelerator. Para saber mais sobre os benefícios da classe de computação Accelerator, consulte Quando usar classes de computação específicas.

Preços

A cobrança do Autopilot varia conforme a classe de computação Accelerator ser ou não solicitada para executar suas cargas de trabalho da GPU.

Usar a classe de computação Accelerator? Preços Compatibilidade com os recursos do GKE
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 automático de nós e escalonabilidade. Saiba mais em Preços do modo Autopilot.

Compatível com os seguintes itens:
O faturamento é feito com base nas solicitações de recursos do pod da GPU. Para mais detalhes, consulte a seção "Pods de GPU" em Preços do Kubernetes Engine.

Compatível com os seguintes itens:

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.

  • 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 (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
      • Todas as outras GPUs: 1.24.2-gke.1800 ou mais recente

  • 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, é possível omitir os campos cloud.google.com/compute-class: "Accelerator" e cloud.google.com/gke-accelerator-count.

apiVersion: v1
kind: Pod
metadata:
  name: my-gpu-pod
spec:
  nodeSelector:
    cloud.google.com/compute-class: "Accelerator"
    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-80gb: NVIDIA H100 (80 GB) (disponível apenas com a classe de computação Accelerator)
    • 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.

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/compute-class: "Accelerator"
    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 --label=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. Será um dos seguintes valores:

  • nvidia-h100-80gb: NVIDIA H100 (80 GB) (disponível apenas com a classe de computação Accelerator)
  • 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

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 DCGM e o exportador do DCGM do Prometheus, consulte o Gerenciador de GPU de data center (DCGM, na sigla em inglês) NVIDIA na documentação do Google Cloud Observability.

A seguir