Executar GPUs nos pools de nós do GKE Standard

Nesta página, mostramos como executar e otimizar cargas de trabalho com uso intensivo de computação, como inteligência artificial (IA) e processamento gráfico, anexando e usando aceleradores de hardware da unidade de processamento gráfico (GPU) NVIDIA® nos nós dos clusters padrão do Google Kubernetes Engine (GKE). Se você estiver usando pods do Autopilot, consulte Implantar cargas de trabalho da GPU no Autopilot.

Se você quiser implantar clusters com GPUs NVIDIA B200 ou NVIDIA H200 de 141 GB, consulte os seguintes recursos:

Visão geral

Com o GKE, é possível criar pools de nós equipados com GPUs. As GPUs fornecem computação avançada para impulsionar tarefas de aprendizado profundo, como reconhecimento de imagem, processamento de linguagem natural e outras tarefas que exigem computação intensiva, incluindo a transcodificação de vídeo e processamento de imagens. No modo do padrão do GKE, é possível anexar um hardware de GPU aos nós nos clusters e alocar recursos de GPU para cargas de trabalho conteinerizadas em execução nesses nós.

Para saber mais sobre casos de uso de GPUs, consulte a página GPUs do Google Cloud. Para mais informações sobre GPUs no GKE e as diferenças entre o modo padrão e o Autopilot, consulte Sobre GPUs no GKE.

Também é possível usar GPUs com VMs spot quando as cargas de trabalho conseguirem tolerar interrupções frequentes de nós. O uso de VMs spot reduz o preço da execução das GPUs. Para saber mais, consulte Como usar VMs spot com pools de nós de GPU.

A partir da versão 1.29.2-gke.1108000, é possível criar pools de nós GPU no GKE Sandbox. Para mais informações, consulte GKE Sandbox e Configuração de sandbox do GKE.

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 CLI do Google Cloud para essa tarefa, instale e inicialize a gcloud CLI. Se você instalou a CLI gcloud anteriormente, instale a versão mais recente executando o comando gcloud components update. Talvez as versões anteriores da CLI gcloud não sejam compatíveis com a execução dos comandos neste documento.

Requisitos para GPUs no GKE

As GPUs no GKE têm os seguintes requisitos:

  • Versão do Kubernetes: as versões disponíveis dependem da imagem de nó usada pelas GPUs:

  • Cota de GPU: você precisa ter uma cota de GPU do Compute Engine na zona desejada antes de criar nós de GPU. Para garantir que você tenha uma cota de GPU suficiente no seu projeto, consulte Cotas no console do Google Cloud .

    Se precisar de mais cota de GPU, solicite-a no Google Cloud console. Se o projeto tiver uma conta de faturamento estabelecida, ele receberá a cota automaticamente depois que você enviar a solicitação.

    Por padrão, as contas de teste gratuito não recebem cota de GPU.

  • Drivers GPU NVIDIA: ao criar um cluster ou um pool de nós, é possível instruir o GKE a instalar automaticamente uma versão do driver com base na versão do GKE. Se você não instruir o GKE a instalar automaticamente os drivers de GPU, será preciso instalá-los manualmente.

  • Série de máquinas: o tipo de GPU que você pode usar depende da série de máquinas, da seguinte maneira:

    Verifique se você tem cota suficiente no projeto para a série de máquina que corresponde ao tipo e quantidade de GPU selecionados.

  • GPUs em nós do Ubuntu: se você usa GPUs com nós do Ubuntu, os seguintes requisitos se aplicam:

    • Compatibilidade de drivers:

      • GPUs L4 e H100: driver NVIDIA versão 535 ou mais recente

      • GPUs H200: driver NVIDIA versão 550 ou mais recente

      • GPUs B200: driver NVIDIA versão 570 ou mais recente

      Se uma versão necessária do driver ou uma versão mais recente não for a versão padrão na versão do GKE, será necessário instalar manualmente um driver com suporte nos nós.

    • Compatibilidade de versões:

      Ao usar a série de máquinas A4 em pools de nós do Ubuntu, é necessário usar uma versão do GKE que inclua a imagem ubuntu-gke-2404-1-32-amd64-v20250730 ou uma versão mais recente da imagem do nó. As versões mínimas do GKE são as seguintes:

      • 1.32.7-gke.1067000 ou mais recente para a versão 1.32 do GKE
      • 1.33.3-gke.1247000 ou mais recente para a versão 1.33 do GKE
Prática recomendada:

Use o Container-Optimized OS para nós de GPU. O Container-Optimized OS inclui os drivers necessários para oferecer suporte à versão específica do GKE para nós de GPU.

Limitações do uso de GPUs no GKE

Antes de usar as GPUs no GKE, tenha em mente as seguintes limitações:

  • Não é possível adicionar GPUs a pools de nós atuais.
  • Os nós da GPU não podem ser migrados em tempo real durante os eventos de manutenção.
  • As GPUs não são compatíveis com os pools de nós do Windows Server.
  • Os clusters do GKE Standard que executam a versão 1.28.2-gke.1098000 ou anterior não são compatíveis com o provisionamento automático de nós que criam pools de nós com GPUs L4. No entanto, os clusters que executam versões anteriores são compatíveis com o escalonamento dos pools de nós já existentes pelo escalonador automático de clusters.

Disponibilidade de GPUs por regiões e zonas

As GPUs estão disponíveis em regiões e zonas específicas. Ao solicitar a cota de GPU, pense nas regiões em que pretende executar os clusters.

Para uma lista completa das regiões e zonas aplicáveis, consulte as GPUs no Compute Engine.

Também é possível ver as GPUs disponíveis na zona usando a Google Cloud CLI. Para ver uma lista de todos os tipos de aceleradores de GPU aceitos em cada zona, execute o seguinte comando:

gcloud compute accelerator-types list

Preços

Para informações sobre preços de GPUs, consulte a tabela de preços na página de GPUs do Google Cloud .

Verificar se há cota suficiente de GPU

A cota de GPU é o número total de GPUs que podem ser executadas no projetoGoogle Cloud . Para criar clusters com GPUs, é preciso que o projeto tenha cota suficiente.

A cota de GPU precisa ser pelo menos equivalente ao número total de GPUs que você pretende executar no cluster. Se você ativar o dimensionamento automático de cluster, será necessário solicitar uma cota de GPU pelo menos equivalente ao número de GPUs por nó multiplicado pelo número máximo de nós do cluster.

Por exemplo, se você criar um cluster com três nós que executem duas GPUs por nó, o projeto precisará de pelo menos seis cotas de GPUs.

Como solicitar cotas de GPU

Para solicitar uma cota de GPU, use o Google Cloud console. Para mais informações sobre como solicitar cotas, consulte Cotas de GPU na documentação do Compute Engine.

Para pesquisar a cota de GPU e enviar uma solicitação de cota, use o Google Cloud console:

  1. Acesse a página Cotas em "IAM e Admin" no console Google Cloud .

    Acesse Cotas

  2. Na caixa Filtro, faça o seguinte:

    1. Selecione a propriedade Cota, insira o nome do modelo de GPU e pressione Enter.
    2. (Opcional) Para aplicar filtros mais avançados e restringir os resultados, selecione a propriedade Dimensões (por exemplo, locais), adicione o nome da região ou zona que você está usando e pressione Enter.

  3. Na lista de cotas da GPU, selecione a cota que você quer alterar.

  4. Clique em Editar cotas. Um formulário de solicitação é aberto.

  5. Preencha o campo Novo limite de cota para cada solicitação.

  6. Preencha o campo Descrição da solicitação com detalhes sobre a solicitação.

  7. Clique em Próxima.

  8. Na caixa de diálogo Substituir confirmação, clique em Confirmar.

  9. Na tela Detalhes do contato, insira seu nome e um número de telefone que os aprovadores poderão usar para concluir a solicitação de alteração de cota.

  10. Clique em Enviar solicitação.

  11. Você receberá um e-mail de confirmação para acompanhar a alteração da cota.

Como executar GPUs em clusters do GKE Standard

Para executar GPUs em clusters do GKE Standard, crie um pool de nós com GPUs anexadas.

Prática recomendada:

Para melhorar o custo-benefício, a confiabilidade e a disponibilidade de GPUs no GKE, faça o seguinte:

  • Criar pools de nós de GPU separados. Para cada pool de nós, limite a localização do nó às zonas em que as GPUs que você quer estão disponíveis.
  • Ative o escalonamento automático em cada pool de nós.
  • Use clusters regionais para melhorar a disponibilidade replicando o plano de controle do Kubernetes nas zonas da região.
  • Configure o GKE a instalar automaticamente os drivers de GPU padrão ou mais recentes nos pools de nós para que você não precise instalar e gerenciar manualmente as versões do driver.

Conforme descrito nas seções a seguir, o GKE usa taints e tolerâncias de nós para garantir que os pods não sejam programados em nós inadequados.

Fazer um taint em um pool de nós de GPU para evitar a programação inadequada

Com um taint de nó, é possível marcar um nó para que o programador evite ou impeça o uso dele em determinados pods. Com base nos cenários a seguir, o GKE adiciona automaticamente restrições, ou você pode adicioná-las manualmente:

  • Quando você adiciona um pool de nós de GPU a um cluster que já executa um pool não baseado em GPU, o GKE faz um taint automaticamente dos nós com o seguinte código:

    • Chave: nvidia.com/gpu
    • Efeito: NoSchedule

    O GKE só adiciona esse taint se houver pelo menos um pool de nós não GPU no cluster.

  • Quando você adiciona um pool de nós de GPU a um cluster que tem apenas pools de nós de GPU ou se criar um novo cluster em que o pool de nós padrão tenha GPUs anexadas, é possível definir manualmente taints para o novo pool de nós com os seguintes valores:

    • Chave: nvidia.com/gpu
    • Efeito: NoSchedule

  • Se você adicionar um pool de nós que não seja de GPU ao cluster no futuro, o GKE não aplicará retroativamente esse taint aos nós de GPU. É preciso definir manualmente taints para o novo pool de nós.

Como restringir automaticamente a programação com uma tolerância

Com as tolerâncias, você designa pods que podem ser usados em nós "tainted". O GKE aplica automaticamente uma tolerância para que apenas pods que solicitam GPUs sejam programados em nós de GPU. Isso permite um escalonamento automático mais eficiente, porque os nós da GPU podem ser reduzidos rapidamente se não houver pods suficientes solicitando GPUs. Para fazer isso, o GKE executa o controlador de admissão ExtendedResourceToleration.

Crie um pool de nós de GPU

Para criar um pool de nós de GPU separado em um cluster atual, use o console doGoogle Cloud ou a Google Cloud CLI. Também é possível usar o Terraform para provisionar clusters do GKE e um pool de nós de GPU.

O GKE oferece suporte à instalação automática de drivers NVIDIA nos seguintes cenários:

  • Para clusters do GKE com a versão do plano de controle 1.32.2-gke.1297000 e mais recentes, o GKE instala automaticamente a versão padrão do driver NVIDIA para todos os nós de GPU, incluindo aqueles criados com provisionamento automático de nós.
  • Para clusters do GKE com a versão do plano de controle 1.30.1-gke.1156000 a 1.32.2-gke.1297000, o GKE instala automaticamente a versão padrão do driver NVIDIA para nós não criados com o provisionamento automático de nós.
  • Você pode escolher a versão mais recente disponível ou desativar explicitamente a instalação automática. Em versões anteriores à 1.30.1-gke.1156000, o GKE não instala um driver por padrão se você não especificar uma versão do driver ao criar ou atualizar o pool de nós.

gcloud

Para criar um pool de nós com GPUs em um cluster, execute o seguinte comando:

gcloud container node-pools create POOL_NAME \
  --accelerator type=GPU_TYPE,count=AMOUNT,gpu-driver-version=DRIVER_VERSION \
  --machine-type MACHINE_TYPE \
  --cluster CLUSTER_NAME \
  --location CONTROL_PLANE_LOCATION \
  --node-locations COMPUTE_ZONE1[,COMPUTE_ZONE2] \
  [--sandbox=type=gvisor]
  [--enable-autoscaling \
   --min-nodes MIN_NODES \
   --max-nodes MAX_NODES] \
  [--scopes=SCOPES] \
  [--service-account=SERVICE_ACCOUNT] \
  [--reservation-affinity=specific --reservation=RESERVATION_NAME]

Substitua:

  • POOL_NAME: o nome escolhido para o pool de nós.
  • GPU_TYPE: o tipo de acelerador de GPU que você usa. Por exemplo, nvidia-tesla-t4.
  • AMOUNT: o número de GPUs que serão anexadas aos nós no pool de nós.

  • DRIVER_VERSION: a versão do driver NVIDIA a ser instalado. Será um dos seguintes valores:

    • default: instale a versão padrão do driver para a versão do nó do GKE. Na versão 1.30.1-gke.1156000 e mais recentes do GKE, se você omitir a flag gpu-driver-version, essa será a opção padrão. Nas versões anteriores, o GKE não instala um driver se você omitir essa flag.
    • latest: instale a versão mais recente disponível do driver para a versão do GKE. Disponível apenas para nós que usam o Container-Optimized OS.
    • disabled: pula a instalação automática do driver. Você precisa instalar manualmente um driver depois de criar o pool de nós. Nas versões do GKE anteriores à 1.30.1-gke.1156000, essa é a opção padrão.

    A opção gpu-driver-version está disponível apenas para a versão 1.27.2-gke.1200 e posterior do GKE. Nas versões anteriores, omita essa flag e instale manualmente um driver depois de criar o pool de nós. Se você fizer upgrade de um cluster ou pool de nós atual para essa versão ou mais recente, o GKE instalará automaticamente a versão padrão do driver correspondente à versão do GKE, a menos que você especifique de maneira diferente ao iniciar o upgrade.

  • MACHINE_TYPE: o tipo de máquina do Compute Engine para os nós. Obrigatório para os seguintes tipos de GPU:

    • GPUs NVIDIA B200 (correspondentes ao tipo de acelerador nvidia-b200 e à série de máquinas A4)
    • GPUs NVIDIA H200 de 141 GB (correspondentes ao tipo de acelerador nvidia-h200-141gb e ao tipo de máquina A3 Ultra), GPUs NVIDIA H100 de 80 GB (correspondentes ao tipo de acelerador nvidia-h100-80gb e ao tipo de máquina A3 High) ou GPUs Mega NVIDIA H100 de 80 GB (correspondentes ao tipo de acelerador nvidia-h100-mega-80gb e ao tipo de máquina A3 Mega). Para mais informações, consulte a série de máquinas A3 na documentação do Compute Engine.
    • GPUs NVIDIA A100 de 40 GB (correspondentes ao tipo de acelerador nvidia-tesla-a100 e ao tipo de máquina A2 Standard) ou GPUs NVIDIA A100 de 80 GB (correspondentes ao tipo de acelerador nvidia-a100-80gb e ao tipo de máquina A2 Ultra). Para mais informações, consulte a série de máquinas A2 na documentação do Compute Engine.
    • GPUs NVIDIA L4 (correspondentes ao tipo de acelerador nvidia-l4 e à série de máquinas G2).

    Para todas as outras GPUs, essa flag é opcional.

  • CLUSTER_NAME: o nome do cluster no qual o pool de nós será criado.

  • CONTROL_PLANE_LOCATION: o local do Compute Engine do plano de controle do cluster. Forneça uma região para clusters regionais ou uma zona para clusters zonais.

  • COMPUTE_ZONE1,COMPUTE_ZONE2,[...]: as zonas específicas em que o GKE cria os nós da GPU. As zonas precisam estar na mesma região do cluster, especificada pela sinalização --location. Os tipos de GPU que você define precisam estar disponíveis em cada zona selecionada. Se você usar uma reserva, especifique as zonas em que ela tem capacidade. Recomendamos que você sempre use a flag --node-locations ao criar o pool de nós para especificar a zona ou as zonas que contêm as GPUs solicitadas.

  • Se quiser, crie pools de nós para executar cargas de trabalho em sandbox com o gVisor. Para saber mais, consulte GKE Sandbox para detalhes.

  • MIN_NODES: o número mínimo de nós para cada zona no pool de nós a qualquer momento. Esse valor será relevante apenas se a sinalização --enable-autoscaling for usada.

  • MAX_NODES: o número máximo de nós para cada zona no pool de nós a qualquer momento. Esse valor será relevante apenas se a sinalização --enable-autoscaling for usada.

  • Se quiser, crie o pool de nós de GPU usando uma conta de serviço personalizada anexando as seguintes flags. Em caso de omissão, o pool de nós usará a conta de serviço padrão do Compute Engine:

    • SERVICE_ACCOUNT: o nome da conta de serviço do IAM usada pelos nós.
    • SCOPES: uma lista separada por vírgulas de escopos de acesso a serem concedidos. Verifique se um dos escopos é storage-ro ou https://www.googleapis.com/auth/devstorage.read_only. Para saber mais sobre escopos, consulte Definir escopos de acesso. Se você omitir a flag scope, a criação do pool de nós de GPU vai falhar com um erro AccessDenied failed to download gpu_driver_versions.bin from GCS bucket.

  • RESERVATION_NAME: o nome da reserva de GPU a ser usada. Especifique a flag --reservation com --reservation-affinity=specific para usar a capacidade de GPU de uma reserva específica. Para mais informações, consulte Consumir uma reserva específica de projeto único.

Por exemplo, o comando a seguir cria um pool de nós de escalonamento automático de alta disponibilidade, p100, com duas GPUs P100 para cada nó, no cluster regional p100-cluster. O GKE instala automaticamente os drivers padrão nesses nós.

gcloud container node-pools create p100 \
  --accelerator type=nvidia-tesla-p100,count=2,gpu-driver-version=default \
  --cluster p100-cluster \
  --location us-central1 \
  --node-locations us-central1-c \
  --min-nodes 0 --max-nodes 5 --enable-autoscaling

Console

Para criar um pool de nós com GPUs:

  1. Acesse a página do Google Kubernetes Engine no Google Cloud console.

    Acessar o Google Kubernetes Engine

  2. Na lista de clusters, clique no nome do cluster que você quer modificar.

  3. Clique em Adicionar pool de nós.

  4. Opcionalmente, na página Detalhes do pool de nós, marque a caixa de seleção Ativar escalonamento automático.

  5. Configure o pool de nós como quiser.

  6. No painel de navegação, selecione Nós.

  7. Em Configuração da máquina, clique em GPU.

  8. Selecione um Tipo de GPU e o Número de GPUs para serem executados em cada nó.

  9. Leia o aviso e selecione Entendo as limitações.

  10. Na seção Instalação do driver da GPU, selecione um dos seguintes métodos:

    • Gerenciada pelo Google: o GKE instala automaticamente um driver. Se você selecionar essa opção, escolha uma das opções a seguir na lista suspensa Versão:
      • Padrão: instalar a versão padrão do driver.
      • Mais recente: instale a versão mais recente disponível do driver.
    • Gerenciada pelo cliente: o GKE não instala um driver. É necessário instalar manualmente um driver compatível usando as instruções em Como instalar drivers de dispositivo da GPU NVIDIA.

  11. Clique em Criar.

Terraform

É possível criar um cluster regional com o Terraform com GPUs usando um módulo do Terraform.

  1. Defina as variáveis do Terraform incluindo o seguinte bloco no arquivo variables.tf:

    variable "project_id" {
  default     = PROJECT_ID
  description = "the gcp_name_short project where GKE creates the cluster"
}

variable "region" {
  default     = CLUSTER_REGION
  description = "the gcp_name_short region where GKE creates the cluster"
}

variable "zone" {
  default     = "COMPUTE_ZONE"
  description = "the GPU nodes zone"
}

variable "cluster_name" {
  default     = "CLUSTER_NAME"
  description = "the name of the cluster"
}

variable "gpu_type" {
  default     = "GPU_TYPE"
  description = "the GPU accelerator type"
}

variable "gpu_driver_version" {
  default = "DRIVER_VERSION"
  description = "the NVIDIA driver version to install"
}

variable "machine_type" {
  default = "MACHINE_TYPE"
  description = "The Compute Engine machine type for the VM"
}

    Substitua:

    • PROJECT_ID: o ID do projeto.
    • CLUSTER_NAME: o nome do cluster do GKE.
    • CLUSTER_REGION: a região de computação do cluster.
    • COMPUTE_ZONE: a zona específica em que o GKE cria os nós da GPU. A zona precisa estar na mesma região especificada pela variável region. Essas zonas precisam ter os tipos de GPU definidos disponíveis. Para mais informações, consulte Disponibilidade de GPUs por regiões e zonas.
    • GPU_TYPE: o tipo de acelerador de GPU que você usa. Por exemplo, nvidia-tesla-t4.

    • DRIVER_VERSION: a versão do driver da GPU para o GKE instalar automaticamente. Este campo é opcional. Os valores a seguir são compatíveis:

      • INSTALLATION_DISABLED: desativa a instalação automática do driver da GPU. É necessário instalar manualmente os drivers para executar as GPUs. Nas versões do GKE anteriores à 1.30.1-gke.1156000, essa é a opção padrão se você omitir esse campo.
      • DEFAULT: instala automaticamente a versão padrão do driver na versão do sistema operacional do nó. Na versão 1.30.1-gke.1156000 e mais recentes do GKE, se você omitir esse campo, ele será a opção padrão. Nas versões anteriores, o GKE não instala um driver se você omitir esse campo.
      • LATEST: instala automaticamente a versão mais recente do driver disponível para a versão do SO do nó. Disponível apenas para nós que usam o Container-Optimized OS.

      Se você omitir esse campo, o GKE não instalará automaticamente um driver. Este campo não é aceito em pools de nós que usam provisionamento automático de nós. Para instalar manualmente um driver, consulte Instalar manualmente os drivers de GPU NVIDIA neste documento.

    • MACHINE_TYPE: o tipo de máquina do Compute Engine para os nós. Obrigatório para os seguintes tipos de GPU:

      • GPUs NVIDIA B200 (correspondentes ao tipo de acelerador nvidia-b200 e à série de máquinas A4)
      • GPUs NVIDIA H200 de 141 GB (correspondentes ao tipo de acelerador nvidia-h200-141gb e ao tipo de máquina A3 Ultra), GPUs NVIDIA H100 de 80 GB (correspondentes ao tipo de acelerador nvidia-h100-80gb e ao tipo de máquina A3 High) ou GPUs Mega NVIDIA H100 de 80 GB (correspondentes ao tipo de acelerador nvidia-h100-mega-80gb e ao tipo de máquina A3 Mega). Para mais informações, consulte a série de máquinas A3 na documentação do Compute Engine.
      • GPUs NVIDIA A100 de 40 GB (correspondentes ao tipo de acelerador nvidia-tesla-a100 e ao tipo de máquina A2 Standard) ou GPUs NVIDIA A100 de 80 GB (correspondentes ao tipo de acelerador nvidia-a100-80gb e ao tipo de máquina A2 Ultra). Para mais informações, consulte a série de máquinas A2 na documentação do Compute Engine.
      • GPUs NVIDIA L4 (correspondentes ao tipo de acelerador nvidia-l4 e à série de máquinas G2).

      Para todas as outras GPUs, essa flag é opcional.

  2. Adicione o seguinte bloco à configuração do Terraform:

    provider "google" {
  project = var.project_id
  region  = var.region
}

resource "google_container_cluster" "ml_cluster" {
  name               = var.cluster_name
  location           = var.region
  initial_node_count = 1
}

resource "google_container_node_pool" "gpu_pool" {
  name           = google_container_cluster.ml_cluster.name
  location       = var.region
  node_locations = [var.zones]
  cluster        = google_container_cluster.ml_cluster.name
  node_count     = 3

  autoscaling {
    total_min_node_count = "1"
    total_max_node_count = "5"
  }

  management {
    auto_repair  = "true"
    auto_upgrade = "true"
  }

  node_config {
    oauth_scopes = [
      "https://www.googleapis.com/auth/logging.write",
      "https://www.googleapis.com/auth/monitoring",
      "https://www.googleapis.com/auth/devstorage.read_only",
      "https://www.googleapis.com/auth/trace.append",
      "https://www.googleapis.com/auth/service.management.readonly",
      "https://www.googleapis.com/auth/servicecontrol",
    ]

    labels = {
      env = var.project_id
    }

    guest_accelerator {
      type  = var.gpu_type
      count = 1
      gpu_driver_installation_config {
        gpu_driver_version = var.gpu_driver_version
      }
    }

    image_type   = "cos_containerd"
    machine_type = var.machine_type
    tags         = ["gke-node", "${var.project_id}-gke"]

    disk_size_gb = "30"
    disk_type    = "pd-standard"

    metadata = {
      disable-legacy-endpoints = "true"
    }
  }
}

O Terraform chama APIs do Google Cloud para definir a criação de um novo cluster com um pool de nós que usa GPUs. Inicialmente, o pool de nós tem três nós, e o escalonamento automático está ativado. Para saber mais sobre o Terraform, consulte as especificações de recursos do google_container_node_pool em terraform.io.

Prática recomendada:

Para evitar custos adicionais, remova todos os recursos definidos no arquivo de configuração usando o comando terraform destroy.

Prática recomendada: também é possível criar um novo cluster com GPUs e especificar zonas usando a sinalização --node-locations. No entanto, recomendamos que você crie um pool de nós de GPU separado em um cluster atual, conforme mostrado nesta seção.

Instalar manualmente os drivers de GPU NVIDIA

É possível instalar manualmente os drivers da GPU NVIDIA nos nós implantando um DaemonSet de instalação nesses nós. Use a instalação manual nas seguintes situações:

  • Você desativou a instalação automática do driver do dispositivo ao criar um pool de nós de GPU.
  • Você usa uma versão do GKE anterior à versão mínima compatível para instalação automática.
  • A carga de trabalho exige uma versão específica do driver NVIDIA que não está disponível como padrão ou o driver mais recente com instalação automática. Por exemplo, usar GPUs com nós confidenciais do GKE.
Prática recomendada:

Use a instalação automática de drivers sempre que possível. Para fazer isso, especifique a opção gpu-driver-version na flag --accelerator ao criar o cluster padrão. Se você usou o DaemonSet para instalar manualmente os drivers de GPU até 25 de janeiro de 2023, talvez seja necessário aplicar novamente o DaemonSet para conseguir uma versão que ignore os nós que usam instalação automática do driver.

Para executar o DaemonSet de instalação, o pool de nós da GPU requer o escopo https://www.googleapis.com/auth/devstorage.read_only para se comunicar com o Cloud Storage. Sem esse escopo, o download do manifesto de instalação do DaemonSet falha. Esse escopo é um dos escopos padrão, que normalmente são adicionados quando você cria o cluster.

As instruções a seguir mostram como instalar os drivers nos nós do Container-Optimized OS (COS) e Ubuntu e como usar o Terraform.

COS

  • Para implantar o DaemonSet e instalar a versão padrão do driver da GPU, execute o seguinte comando:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml

  • Para instalar uma versão mais recente do driver da GPU na tabela de versões de driver desta seção, execute o seguinte comando:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded-latest.yaml

  • Para instalar uma versão do driver de GPU que ofereça suporte à execução de cargas de trabalho de GPU em nós confidenciais do GKE, execute o seguinte comando:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/refs/heads/master/nvidia-driver-installer/cos/daemonset-confidential.yaml

A instalação leva alguns segundos para ser concluída. Depois que a instalação for concluída, o plug-in do dispositivo GPU NVIDIA usará a API Kubernetes para disponibilizar a capacidade da GPU NVIDIA.

Cada versão do Container-Optimized OS tem pelo menos uma versão compatível de driver de GPU NVIDIA. Para mais informações sobre como mapear a versão do driver de GPU para a versão do GKE, faça o seguinte:

Versões do driver NVIDIA do GKE
1,33 R535 (padrão), R570, R575 ou R580
1.32 R535 (padrão), R570, R575 ou R580
1.31 R535 (padrão), R570, R575 ou R580
1,30 R535 (padrão) ou R550
1,29 R535 (padrão) ou R550
1.28 R535 (padrão) ou R550
1,27 R470 (padrão), R525, R535, ou R550
1,26 R470 (padrão), R525, R535, ou R550

Ubuntu

O DaemonSet de instalação implantado depende do tipo de GPU e da versão do nó do GKE da seguinte maneira:

  • Para todas as GPUs exceto as GPUs NVIDIA H200, execute o seguinte comando:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/ubuntu/daemonset-preloaded.yaml

  • Para GPUs NVIDIA H200, instale o driver R550:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/refs/heads/master/nvidia-driver-installer/ubuntu/daemonset-preloaded-R550.yaml

A instalação leva alguns segundos para ser concluída. Depois de instalado, o plug-in do dispositivo GPU NVIDIA usa a API Kubernetes para disponibilizar a capacidade da GPU NVIDIA.

A tabela a seguir lista as versões disponíveis do driver em cada versão do GKE:

Drivers de GPU do Ubuntu e versões do GKE
1,33 R535 (padrão)
1.32 R535 (padrão)
1.31 R535 (padrão)
1,30 R470 ou R535
1,29 R470 ou R535
1.28 R470 ou R535
1,27 R470 ou R535
1,26 R470 ou R535

Terraform

É possível usar o Terraform para instalar a versão padrão do driver da GPU com base no tipo de nós. Em ambos os casos, você precisa configurar o tipo de recurso kubectl_manifest do Terraform.

  • Para instalar o DaemonSet no COS, adicione o seguinte bloco na configuração do Terraform:

      data "http" "nvidia_driver_installer_manifest" {
    url = "https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml"
  }

  resource "kubectl_manifest" "nvidia_driver_installer" {
    yaml_body = data.http.nvidia_driver_installer_manifest.body
  }

  • Para instalar o DaemonSet no Ubuntu, adicione o seguinte bloco à sua configuração do Terraform:

      data "http" "nvidia_driver_installer_manifest" {
    url = "https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/ubuntu/daemonset-preloaded.yaml"
  }

  resource "kubectl_manifest" "nvidia_driver_installer" {
    yaml_body = data.http.nvidia_driver_installer_manifest.body
  }

Mapear a versão do GKE e a versão da imagem do nó do Container-Optimized OS para a versão do driver da GPU

Para encontrar as versões de driver da GPU mapeadas com as versões do GKE e as versões de imagem de nó do Container-Optimized OS, siga estas etapas:
  1. Mapeie as versões de imagem de nó do Container-Optimized OS para as versões de patch do GKE da versão específica do GKE em que você quer encontrar a versão do driver de GPU. Por exemplo, 1.33.0-gke.1552000 usa cos-121-18867-90-4.
  2. Escolha o marco da versão da imagem do nó do Container-Optimized OS nas notas de lançamento do Container-Optimized OS. Por exemplo, escolha o marco 121 para cos-121-18867-90-4.
  3. Na página de notas da versão do marco específico, encontre a nota da versão correspondente à versão da imagem do nó do Container-Optimized OS. Por exemplo, em Notas da versão do Container-Optimized OS: marco 121, consulte cos-121-18867-90-4. Na tabela da coluna Drivers de GPU, clique em Ver lista para conferir as informações da versão do driver de GPU.

Como instalar drivers usando o provisionamento automático de nós com GPUs

Ao usar o provisionamento automático de nós com GPUs, os pools de nós provisionados automaticamente não têm escopos suficientes para instalar os drivers. Para conceder os escopos necessários, modifique os escopos padrão do provisionamento automático de nós para adicionar logging.write, monitoring, devstorage.read_only e compute, como no exemplo a seguir.

gcloud container clusters update CLUSTER_NAME --enable-autoprovisioning \
    --min-cpu=1 --max-cpu=10 --min-memory=1 --max-memory=32 \
    --autoprovisioning-scopes=https://www.googleapis.com/auth/logging.write,https://www.googleapis.com/auth/monitoring,https://www.googleapis.com/auth/devstorage.read_only,https://www.googleapis.com/auth/compute

Para clusters que executam o GKE versão 1.32.2-gke.1297000 e mais recentes, o GKE instala automaticamente a versão padrão do driver NVIDIA para todos os nós de GPU, incluindo aqueles criados com o provisionamento automático de nós. É possível pular as instruções a seguir para clusters que executam o GKE versão 1.32.2-gke.1297000 e posterior.

No GKE versão 1.29.2-gke.1108000 e mais recentes, selecione uma versão do driver da GPU para que o GKE instale automaticamente nos nós da GPU provisionados automaticamente. Adicione o seguinte campo ao seu 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ó.
  • latest: a versão mais recente do driver disponível para a versão do GKE do nó.
  • disabled: desativa a instalação automática do driver da GPU. Com esse valor selecionado, é necessário instalar manualmente os drivers para executar as GPUs. Nas versões do GKE anteriores à 1.32.2-gke.1297000, essa é a opção padrão se você omitir o seletor de nós.

Para saber mais sobre provisionamento automático, consulte Como usar o provisionamento automático de nós.

Como configurar pods para consumir GPUs

Use um limite de recurso para configurar os pods para consumir GPUs. Especifique um limite de recurso em uma especificação de pod (em inglês) usando o par de chave-valor a seguir:

  • Chave: nvidia.com/gpu
  • Valor: número de GPUs a serem consumidas

alpha.kubernetes.io/nvidia-gpu não é aceito como um nome de recurso no GKE. Use nvidia.com/gpu como o nome do recurso.

O manifesto a seguir é um exemplo de especificação de pod que consome GPUs:

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

Como consumir vários tipos de GPU

Se você quiser usar vários tipos de aceleradores de GPU por cluster, precisará criar vários pools de nós, cada um com seu próprio tipo de acelerador. O GKE anexa um seletor de nós (em inglês) exclusivo aos nós da GPU para alocar as cargas de trabalho nos nós com tipos de GPU específicos:

  • Chave: cloud.google.com/gke-accelerator
  • Valor: o tipo de acelerador de GPUque você usa. Por exemplo, nvidia-tesla-t4.

Para segmentar determinados tipos de GPU, adicione esse seletor de nó à especificação do pod da carga de trabalho. Por exemplo:

apiVersion: v1
kind: Pod
metadata:
  name: my-gpu-pod
spec:
  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: 2
  nodeSelector:
    cloud.google.com/gke-accelerator: nvidia-tesla-t4

Fazer upgrade de pools de nós usando aceleradores (GPUs e TPUs)

O GKE faz upgrade automático de clusters Padrão, incluindo pools de nós. Também é possível fazer upgrade manual dos pools de nós se quiser que seus nós usem uma versão mais recente antecipadamente. Para controlar como os upgrades funcionam no cluster, use os canais de lançamento, janelas de manutenção e exclusões e sequenciamento de lançamento.

Também é possível configurar uma estratégia de upgrade de nós para o pool de nós, como upgrades súbitos, upgrades azul-verde ou upgrades de curta duração. Ao configurar essas estratégias, é possível garantir que o upgrade dos pools de nós ocorra de uma maneira que atinja o equilíbrio ideal entre velocidade e interrupção do seu ambiente. Para pools de nós de fração de TPU de vários hosts, em vez de usar a estratégia de upgrade de nós configurada, o GKE recria atomicamente todo o pool de nós em uma única etapa. Para saber mais, consulte a definição de atomicidade em Terminologia relacionada à TPU no GKE.

O uso de uma estratégia de upgrade de nó exige temporariamente que o GKE provisione recursos adicionais, dependendo da configuração. Se Google Cloud tiver capacidade limitada para os recursos do pool de nós, por exemplo, se você estiver enfrentando erros de disponibilidade de recursos ao tentar criar mais nós com GPUs ou TPUs, consulte Fazer upgrade em um ambiente limitado de recursos.

Sobre as bibliotecas CUDA-X da NVIDIA

O CUDA® é a plataforma de computação paralela e o modelo de programação da NVIDIA para GPUs. Para usar aplicativos CUDA, a imagem usada precisa ter as bibliotecas. Para adicionar as bibliotecas CUDA-X da NVIDIA, crie e use sua própria imagem incluindo os seguintes valores na variável de ambiente LD_LIBRARY_PATH na especificação do contêiner:

  • /usr/local/nvidia/lib64: a localização dos drivers de dispositivo da NVIDIA;
  • /usr/local/cuda-CUDA_VERSION/lib64: a localização das bibliotecas NVIDIA CUDA-X no nó.

    Substitua CUDA_VERSION pela versão da imagem CUDA-X que você usou. Algumas versões também contêm utilitários de depuração em /usr/local/nvidia/bin. Para mais detalhes, veja a imagem NVIDIA CUDA no DockerHub.

    Para verificar a versão mínima do driver da GPU necessária para a versão do CUDA, consulte Kit de ferramentas CUDA e versões compatíveis do driver.

Verifique se a versão do patch do GKE em execução nos nós inclui uma versão do driver da GPU compatível com a versão CUDA escolhida. Para mais informações sobre o mapeamento da versão do driver da GPU para a versão do GKE, consulte Mapear a versão do GKE e a versão da imagem do nó do Container-Optimized OS para a versão do driver da GPU.

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.

Essas métricas se aplicam no nível do contêiner (container/accelerator) e não são coletadas para contêineres programados em uma GPU que usa compartilhamento de tempo de GPU ou NVIDIA MPS.

É 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 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)

Configurar o encerramento automático de nós de GPU

Nos clusters do GKE com o plano de controle em execução na versão 1.29.1-gke.1425000 ou posterior, os nós da GPU são compatíveis com sinais SIGTERM que alertam o nó sobre um encerramento iminente. A notificação de encerramento iminente pode ser configurada em até 60 minutos nos nós da GPU.

Para configurar o GKE para encerrar as cargas de trabalho normalmente dentro desse período de notificação, siga as etapas em Gerenciar a interrupção de nós do GKE para GPUs e TPUs.

A seguir