Implemente cargas de trabalho de GPU no Autopilot

Esta página mostra como pedir GPUs para acelerar tarefas nas suas cargas de trabalho do Google Kubernetes Engine (GKE) Autopilot. Esta página também descreve como o Autopilot executa GPUs, como o modelo de preços muda consoante a versão do GKE, como definir pedidos e limites de recursos de pods e como monitorizar cargas de trabalho de GPU.

Esta página destina-se a administradores e operadores da plataforma, bem como a especialistas em dados e IA que querem pedir GPUs para cargas de trabalho que executam tarefas como a aprendizagem automática (AA) ou a inferência. Para saber mais sobre as funções, as responsabilidades e os exemplos de tarefas comuns a que fazemos referência no Google Cloud conteúdo, consulte o artigo Funções e tarefas comuns do utilizador do GKE.

Antes de continuar, certifique-se de que conhece os seguintes conceitos:

Selecione aceleradores em pods

O Autopilot usa a classe de computação de acelerador especializada para executar pods de GPU. Com esta classe de computação, o GKE coloca pods em nós de GPU, o que dá aos pods acesso a capacidades avançadas na máquina virtual (VM). Para usar esta classe num volume de trabalho da GPU, tome uma das seguintes medidas, consoante a sua versão do GKE:

  • Versão 1.29.4-gke.1427000 e posteriores: peça GPUs no manifesto da carga de trabalho. Também pode usar capacidades de partilha de GPU, como a partilha de tempo. O GKE não modifica os manifestos da carga de trabalho para adicionar um seletor de nós ou uma anotação para a classe de acelerador.
  • Versão 1.29 até à versão 1.29.4-gke.142700, inclusive: especifique o seletor de nós no manifesto do pod e peça GPUs.cloud.google.com/compute-class: Accelerator Se especificar este seletor de nós, também pode usar capacidades de partilha de GPU, como a partilha de tempo.
  • Versão 1.28.9-gke.1069000 até à versão 1.29, inclusive: especifique o seletor de nós cloud.google.com/compute-class: Accelerator no manifesto do pod juntamente com os seletores de GPU. Se especificar este seletor de nós, também pode usar capacidades de partilha de GPU, como a partilha de tempo.

A classe de computação do acelerador não é suportada em versões anteriores a 1.28.9-gke.1069000. Em alternativa, o GKE trata os pods de GPU nessas versões de forma semelhante a outros pods do Autopilot, e a faturação é feita com base nos pedidos de recursos. Para obter detalhes, consulte a secção Preços.

Compatibilidade do acelerador com as capacidades do GKE

A tabela seguinte mostra as capacidades do GKE compatíveis para cada método de seleção de aceleradores no GKE Autopilot:

Accelerator classe de computação selecionada Compatibilidade com as capacidades do GKE

Preços

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

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

Modelo de faturação baseado em nós. Todos os pods de GPU usam a classe de computação de acelerador. A faturação é feita com base no hardware do Compute Engine que executa as suas cargas de trabalho de GPU, além de um prémio do Autopilot para a gestão de nós e a escalabilidade. Para ver detalhes, consulte o Preço do modo de condução autónoma.
Da versão 1.29 até à versão 1.29.4-gke.1427000, mas sem incluir esta última

O modelo de faturação depende dos seletores de nós que especificar, da seguinte forma:

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

Só pode usar funcionalidades como GPUs de várias instâncias ou partilha de tempo se especificar explicitamente o seletor de nós cloud.google.com/compute-class: Accelerator.

Para ver detalhes, consulte a secção "Pods que têm requisitos de hardware específicos" em Preços do Kubernetes Engine.
Da versão 1.28.6-gke.1095000 até à versão 1.29, mas sem incluir esta última

Modelo de faturação baseado em nós, independentemente de especificar a classe de computação do acelerador nos manifestos do pod.

Só pode usar funcionalidades como GPUs de várias instâncias ou partilha de tempo se especificar explicitamente o seletor de nós cloud.google.com/compute-class: Accelerator.

Para ver detalhes, consulte a secção "Pods que têm requisitos de hardware específicos" em Preços do Kubernetes Engine.
Versões anteriores a 1.28.6-gke.1095000

Modelo de faturação baseado em pods. A faturação é feita com base nos pedidos de recursos do GPU Pod. Para ver detalhes, consulte a secção "Pods que têm requisitos de hardware específicos" em Preços do Kubernetes Engine.

Tenha em atenção as seguintes considerações de preços para as GPUs do Autopilot:

  • Todos os nós de GPU A100 (80 GB) usam SSDs locais para discos de arranque de nós em tamanhos fixos com base no número de GPUs. A faturação dos SSDs locais anexados é feita separadamente. Este preço não se aplica a GPUs A100 (40 GB).

  • O preço do GKE Sandbox é o mesmo que o preço predefinido do Autopilot. Para saber mais sobre o sandbox das cargas de trabalho do acelerador, consulte o GKE Sandbox e o guia de introdução ao GKE Sandbox.

Antes de começar

Antes de começar, certifique-se de que realizou as seguintes tarefas:

  • Ative a API Google Kubernetes Engine.
    • Ative a API Google Kubernetes Engine
  • Se quiser usar a CLI gcloud para esta tarefa, instale-a e, em seguida, inicialize-a. Se instalou anteriormente a CLI gcloud, execute gcloud components update para obter a versão mais recente.

Limitações

  • As GPUs de partilha de tempo e as GPUs de várias instâncias estão disponíveis com o Autopilot na versão 1.29.3-gke.1093000 do GKE e posterior.
  • A disponibilidade da GPU depende da Google Cloud região do cluster do Autopilot e da sua quota de GPU. Para encontrar um modelo de GPU por região ou zona, consulte a 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 os seus pods usarem essa capacidade.
  • Para versões do GKE anteriores à 1.29.2-gke.1355000, se pedir explicitamente um nó de GPU existente específico para o seu pod, o pod tem de consumir todos os recursos de GPU no nó. Por exemplo, se o nó existente tiver 8 GPUs e os contentores do pod pedirem um total de 4 GPUs, o Autopilot rejeita o pod.
  • Para a versão 1.29.2-gke.1355000 ou posterior do GKE, se quiser que vários pods de GPU se encaixem num único nó, a soma dos pedidos de GPU para esses pods tem de ser inferior ou igual a o número de recursos de GPU anexados a esse nó. Por exemplo, um nó com um gke-accelerator-count de 4 pode acomodar até quatro pods que pedem uma GPU cada.

A colocação de vários pods num único nó de GPU é útil em situações como as seguintes:

  • Tem reservas de capacidade para tipos de máquinas com aceleradores grandes e executa cargas de trabalho com uma única GPU, pelo que a implementação de um pod por nó desperdiçaria as outras GPUs nessa máquina
  • Tem cargas de trabalho de GPU que têm de ser executadas no mesmo anfitrião

Nestas situações, recomendamos que use todas as GPUs no nó, garantindo que a soma dos pedidos de recursos de GPU do pod no nó é igual ao número de GPUs associadas ao nó.

Peça GPUs nos seus contentores

Para pedir recursos de GPU para os seus contentores, adicione os seguintes campos à especificação do pod. Consoante os requisitos da carga de trabalho, pode omitir opcionalmente o seletor cloud.google.com/gke-accelerator-count.

apiVersion: v1
kind: Pod
metadata:
  name: my-gpu-pod
spec:
  # Optional: Use GKE Sandbox
  # runtimeClassName: gvisor
  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 o seguinte:

  • GPU_TYPE: o tipo de hardware da GPU. Os valores permitidos são os seguintes:

    • nvidia-gb200: NVIDIA GB200 (pré-visualização)
    • nvidia-b200: NVIDIA B200 (180GB)
    • nvidia-h200-141gb: NVIDIA H200 (141GB)
    • 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
    ou se usar o GKE Sandbox, uma das seguintes opções:
    • nvidia-gb200: NVIDIA GB200 (pré-visualização)
    • nvidia-b200: NVIDIA B200 (180 GB) (pré-visualização)
    • nvidia-h200-141gb: NVIDIA H200 (141 GB) (pré-visualização)
    • 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
    Para mais informações, consulte o artigo Suporte de modelos de GPU.

  • GPU_COUNT: o número total de GPUs disponíveis para anexar ao nó. Tem de ser igual ou superior a GPU_QUANTITY e uma quantidade de GPUs suportada para o tipo de GPU selecionado. Se omitir este nodeSelector, o Autopilot coloca um pod em cada nó de GPU.

  • GPU_QUANTITY: o número de GPUs a atribuir ao contentor. Tem de ser igual ou inferior a GPU_COUNT e uma quantidade de GPUs suportada para o tipo de GPU que selecionou.

  • Opcional runtimeClassname: gvisor: a definição que lhe permite executar este Pod no GKE Sandbox. Para usar, descomente esta linha. Para saber mais, consulte o artigo GKE Sandbox.

Para ver detalhes sobre a faturação da utilização do acelerador no modo de piloto automático, consulte a secção Preços.

Tem de especificar o tipo de GPU e a quantidade de GPUs na especificação do pod. Se omitir qualquer um destes valores, o Autopilot rejeita o seu pod.

Quando implementa este manifesto, o Autopilot instala automaticamente os controladores NVIDIA predefinidos para a versão do GKE do nó. Na versão 1.29.2-gke.1108000 e posterior, pode optar por instalar a versão mais recente do controlador para essa versão do GKE adicionando o seguinte seletor de nós ao seu manifesto:

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

Substitua DRIVER_VERSION por um dos seguintes valores:

  • default: o controlador predefinido e estável para a versão do GKE do seu nó. Se omitir o nodeSelector no manifesto, esta é a opção predefinida.
  • latest: a versão do controlador mais recente disponível para a versão do GKE do seu nó.

Peça CPU e memória para pods de GPU do Autopilot

Quando definir os seus pods de GPU, também deve pedir recursos de CPU e memória para que os seus contentores tenham o desempenho esperado. O Autopilot aplica mínimos, máximos e predefinições específicos de CPU e memória com base no tipo e na quantidade de GPU. Se executar vários pods de GPU num único nó, especifique a CPU e a memória. Caso contrário, o valor predefinido é a capacidade total do nó. Para ver detalhes, consulte o artigo Pedidos de recursos no Autopilot.

A especificação do pod deve ser semelhante ao seguinte exemplo, que pede quatro GPUs T4:

apiVersion: v1
kind: Pod
metadata:
  name: t4-pod
spec:
  # Optional: Use GKE Sandbox
  # runtimeClassName: gvisor
  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"
  • Opcional runtimeClassname: gvisor: a definição que lhe permite executar este Pod no GKE Sandbox. Para usar, descomente esta linha. Para saber mais, consulte o artigo GKE Sandbox.

Este manifesto especifica limits para recursos de CPU e memória. Se omitir o limits para CPU ou memória na versão 1.29.2-gke.1060000 e posterior do GKE, o GKE atribui aos seus pods a classe de QoS Burstable e permite que os seus pods usem recursos não utilizados da soma dos pedidos de recursos no nó. Para mais informações, consulte o artigo Configure o aumento rápido de pods no GKE.

Peça armazenamento efémero para pods de GPU do Autopilot

Também pode pedir armazenamento efémero em pods que precisem de armazenamento de curta duração. O armazenamento efémero máximo disponível e o tipo de hardware de armazenamento usado dependem do tipo e da quantidade de GPUs que o Pod pede. Pode usar o SSD local para armazenamento efémero se usar GPUs NVIDIA L4, a classe de computação de aceleradores e executar a versão de patch do GKE 1.28.6-gke.1369000 e posterior ou 1.29.1-gke.1575000 e posterior.

Para usar o SSD local para armazenamento efémero, adicione o nodeSelector ao manifesto da carga de trabalho.cloud.google.com/gke-ephemeral-storage-local-ssd: "true" Veja o manifesto de exemplo em Use Local SSD-backed ephemeral storage with Autopilot clusters. As GPUs NVIDIA H100 (80 GB) e as GPUs NVIDIA A100 (80 GB) usam sempre SSDs locais para armazenamento efémero, e não pode especificar este seletor de nós para essas GPUs.

Valide a atribuição de GPUs implementadas

Para verificar se uma carga de trabalho de GPU implementada tem as GPUs pedidas, execute o seguinte comando:

kubectl describe node NODE_NAME

Substitua NODE_NAME pelo nome do nó no qual o pod foi agendado.

O resultado é semelhante ao seguinte:


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

Verifique a versão do controlador da GPU

Nos clusters do Autopilot, o GKE instala automaticamente os controladores de dispositivos NVIDIA em todos os nós de GPU. Para encontrar a versão do controlador 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 é semelhante ao seguinte:

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

Como funciona a atribuição de GPUs no Autopilot

Depois de pedir um tipo de GPU e uma quantidade para os contentores num pod e implementar o pod, acontece o seguinte:

  1. Se não existir nenhum nó de GPU atribuível, o Autopilot aprovisiona um novo nó de GPU para agendar o pod. O Autopilot instala automaticamente os controladores da NVIDIA para facilitar o hardware.
  2. O Autopilot adiciona contaminações de nós ao nó da GPU e adiciona as tolerâncias correspondentes ao pod. Isto impede que o GKE agende 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 geridas pelo GKE que sejam executadas em todos os nós e quaisquer DaemonSets que configure para tolerar todas as contaminações de nós.

Execute DaemonSets em todos os nós

Pode querer executar DaemonSets em todos os nós, mesmo nos nós com taints aplicados. Por exemplo, alguns agentes de registo e monitorização têm de ser executados em todos os nós do cluster. Pode configurar esses DaemonSets para ignorar as restrições de nós, para que o GKE coloque essas cargas de trabalho em todos os nós.

Para executar DaemonSets em todos os nós do cluster, incluindo os nós de 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

Substitua IMAGE_PATH pelo caminho para a imagem do contentor.

Para executar DaemonSets em nós de GPU específicos no seu cluster, adicione o seguinte à sua 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 seus nós de destino. Pode ser uma das seguintes opções:

  • nvidia-gb200: NVIDIA GB200 (pré-visualização)
  • nvidia-b200: NVIDIA B200 (180GB)
  • nvidia-h200-141gb: NVIDIA H200 (141GB)
  • 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
ou, se usar o GKE Sandbox, uma das seguintes opções:

  • nvidia-gb200: NVIDIA GB200 (pré-visualização)
  • nvidia-b200: NVIDIA B200 (180 GB) (pré-visualização)
  • nvidia-h200-141gb: NVIDIA H200 (141 GB) (pré-visualização)
  • 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
Para mais informações, consulte o artigo Suporte de modelos de GPU.

Exemplos de utilização de GPUs no Autopilot

Pode atribuir GPUs a contentores em pods do Autopilot para facilitar cargas de trabalho, como as seguintes:

  • Inferência de aprendizagem automática (AA)
  • Preparação em ML
  • Renderização

Quantidades de GPUs suportadas

Quando pede GPUs na especificação do pod, tem de usar as seguintes quantidades com base no tipo de GPU:

Quantidades de GPUs
NVIDIA L4
nvidia-l4		 1, 2, 4, 8
NVIDIA T4
nvidia-tesla-t4		 1, 2, 4
NVIDIA A100 (40GB)
nvidia-tesla-a100		 1, 2, 4, 8, 16
NVIDIA A100 (80GB)
nvidia-a100-80gb		 1, 2, 4, 8
NVIDIA H100 (80GB)
nvidia-h100-80gb		 1, 2, 4, 8
NVIDIA H100 Mega (80GB)
nvidia-h100-mega-80gb		 8
NVIDIA H200 (141GB)
nvidia-h200-141gb		 8
NVIDIA B200 (180GB)
nvidia-b200		 8

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

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

  • Ciclo de trabalho (container/accelerator/duty_cycle): percentagem de tempo durante o período de amostragem anterior (10 segundos) durante o qual o acelerador estava a processar ativamente. Entre 1 e 100.
  • Utilização de memória (container/accelerator/memory_used): Quantidade de memória do acelerador atribuída em bytes.
  • Capacidade da memória (container/accelerator/memory_total): total de memória do acelerador em bytes.

Estas métricas aplicam-se ao nível do contentor (container/accelerator) e não são recolhidas para contentores agendados numa GPU que usa a partilha de tempo da GPU ou o NVIDIA MPS.

Pode usar painéis de controlo predefinidos para monitorizar os seus clusters com nós de GPU. Para mais informações, consulte o artigo Veja as métricas de observabilidade. Para ver informações gerais sobre a monitorização dos seus clusters e respetivos recursos, consulte a Observabilidade para o GKE.

Veja as métricas de utilização das cargas de trabalho

Pode ver as métricas de utilização da GPU da carga de trabalho no painel de controlo Cargas de trabalho na consola Google Cloud .

Para ver a utilização da GPU da carga de trabalho, siga estes passos:

  1. Aceda à página Workloads na Google Cloud consola.

    Aceda a Cargas de trabalho
  2. Selecione uma carga de trabalho.

O painel de controlo Workloads apresenta gráficos para a utilização e a capacidade da memória da GPU, bem como o ciclo de atividade da GPU.

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

Pode recolher e visualizar métricas do NVIDIA DCGM através do Google Cloud Managed Service for Prometheus. Para os clusters do Autopilot, o GKE instala os controladores. Para clusters padrão, tem de instalar os controladores da NVIDIA.

Para obter instruções sobre como implementar o pacote DCGM gerido pelo GKE, consulte o artigo Recolha e veja métricas do NVIDIA Data Center GPU Manager (DCGM).

O que se segue?