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 um único pod em cada nó 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.

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.
  • Se você solicitar explicitamente um nó de GPU específico para seu pod, ele precisa 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.
  • 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.

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 campo cloud.google.com/compute-class: "Accelerator".

apiVersion: v1
kind: Pod
metadata:
  name: my-gpu-pod
spec:
  nodeSelector:
    cloud.google.com/compute-class: "Accelerator"
    cloud.google.com/gke-accelerator: GPU_TYPE
  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_QUANTITY: o número de GPUs a serem alocadas para o contêiner. Precisa ser uma quantidade de GPU compatível para 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.

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. 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"

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
    ...
...

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 os nós da GPUs

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.

A seguir