O Google usa tecnologia de IA na tradução de conteúdos para seu idioma de preferência. As traduções com IA podem ter erros.

Implemente cargas de trabalho de GPU no Autopilot

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 de 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
	Spot Pods Calcule descontos por utilização garantida (CUDs) flexíveis para o Autopilot premium DFs do Compute Engine para o hardware do nó Reservas de capacidade do Compute Engine GKE Sandbox
	Spot Pods Descontos de fidelidade (CUDs) do Autopilot para pods normais

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 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 do 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 artigo Preços 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 CLI gcloud. Se instalou anteriormente a CLI gcloud, execute o comando gcloud components update para obter a versão mais recente. As versões anteriores da CLI gcloud podem não suportar a execução dos comandos neste documento.
Nota: para instalações existentes da CLI gcloud, certifique-se de que define a compute/region propriedade. Se usar principalmente clusters zonais, defina o compute/zone. Ao definir uma localização predefinida, pode evitar erros na CLI gcloud, como os seguintes: One of [--zone, --region] must be supplied: Please specify location. Pode ter de especificar a localização em determinados comandos se a localização do seu cluster for diferente da predefinição que definiu.

Certifique-se de que tem um cluster do GKE Autopilot a executar uma das seguintes versões para usar as seguintes GPUs ou funcionalidades:
- GPUs NVIDIA B200 (180 GB): 1.32.2-gke.1422000 ou posterior
- GPUs NVIDIA H200 (141 GB): 1.31.4-gke.1183000 ou posterior
- GPUs NVIDIA H100 Mega (80 GB): 1.28.9-gke.1250000 ou posterior e 1.29.4-gke.1542000 ou posterior
- GPUs NVIDIA H100 (80 GB): 1.28.6-gke.1369000 ou posterior e 1.29.1-gke.1575000 ou posterior
- GPUs NVIDIA RTX PRO 6000: 1.34.1-gke.1829001 ou posterior
- Vários pods de GPU por VM: 1.29.2-gke.1355000 ou posterior
- Outras GPUs: todas as versões suportadas

Certifique-se de que tem quotas de GPU suficientes disponíveis no seu projeto. Tem de ter uma quota de GPU do Compute Engine suficiente para os modelos de GPU que quer criar em cada região. Se precisar de quota de GPU adicional, peça um ajuste de quota.

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 e posterior do GKE.
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 o artigo 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.

Colocar 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-rtx-pro-6000: NVIDIA RTX PRO 6000
- 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-rtx-pro-6000: NVIDIA RTX PRO 6000 (pré-visualização)
- 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 selecionado.
Opcional runtimeClassname: gvisor: a definição que lhe permite executar este pod na sandbox do GKE. 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 estável predefinido 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 na sandbox do GKE. 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 SSDs locais para armazenamento efémero com as seguintes configurações:

Use GPUs NVIDIA RTX PRO 6000 e a classe de computação do acelerador, e execute a versão de patch do GKE 1.34.1-gke.1829001 ou posterior.
Use GPUs NVIDIA L4 e a classe de computação do acelerador, e execute a versão de patch do GKE 1.28.6-gke.1369000 ou posterior, ou 1.29.1-gke.1575000 ou 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.

Peça tipos de máquinas específicos através de ComputeClasses personalizadas

Em alguns casos, pode ter de executar a sua carga de trabalho de GPU num tipo de máquina específico, por exemplo, se o tipo de máquina que quer não for um tipo de máquina predefinido para clusters do Autopilot. Pode pedir explicitamente uma máquina específica através de ComputeClasses personalizadas, que lhe permitem definir um perfil de configuração de nós que especifica o tipo de máquina e a GPU.

Para ver informações gerais sobre as ComputeClasses, consulte o artigo Acerca das ComputeClasses personalizadas.

Para pedir um tipo de máquina específico para a sua carga de trabalho de GPU, conclua os seguintes passos:

Crie um manifesto para uma ComputeClass personalizada. Para este exemplo, guarde o seguinte como a3-computeclass.yaml:
```
apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: a3-edge-gpu
spec:
  priorities:
  - machineType: a3-edgegpu-8g-nolssd
    gpu:
     count: 8
     type: nvidia-h100-80gb
  nodePoolAutoCreation:
    enabled: true
```
Neste manifesto:
- metadata.name é o nome da sua ComputeClass personalizada, à qual fará referência na especificação do pod.
- O machineType é a máquina específica a aprovisionar.
- Os campos gpu especificam o tipo e o número de GPUs associadas a essa máquina. Os valores destes campos têm de corresponder às capacidades do machineType especificado.
Aplique o manifesto executando o seguinte comando:
```
kubectl apply -f a3-computeclass.yaml
```
No manifesto do Pod, peça a ComputeClass através do seletor de nós cloud.google.com/compute-class:
```
apiVersion: v1
kind
```