Executar GPUs nos pools de nós do GKE Standard

Nesta página, mostramos como usar os aceleradores de hardware da unidade de processamento gráfico (GPU, na sigla em inglês) NVIDIA® nos nós dos clusters padrão do Google Kubernetes Engine (GKE). Para mais informações sobre GPUs no GKE, consulte Sobre GPUs no GKE.

Também é possível usar GPUs diretamente nos pods do Autopilot. Para instruções, consulte Implantar cargas de trabalho da GPU no Autopilot.

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.

Para saber mais sobre casos de uso de GPUs, consulte a página GPUs do Google Cloud.

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

Requisitos

As GPUs no GKE têm os seguintes requisitos:

  • Versão do Kubernetes: para pools de nós que usam a imagem de nó do Container-Optimized OS, os nós da GPU estão disponíveis na versão 1.9 ou superior do GKE. Para os pools de nós que usam a imagem do nó do Ubuntu, os nós da GPU estão disponíveis na versão 1.11.3 ou superior do GKE.

  • 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 console do Google Cloud. Se o projeto tiver uma conta de faturamento definida, ele receberá a cota automaticamente assim que você enviar a solicitação.

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

  • GPUs A100: as GPUs A100 são compatíveis apenas com tipos de máquina a2 e exigem a versão 1.18.6-gke.3504 ou mais recente do GKE. Você precisa garantir que tem cota suficiente para que o tipo de máquina A2 subjacente use a GPU A100.

  • GPUs L4:

    • Use o GKE versão 1.22.17-gke.5400 ou posterior.
    • A versão do GKE escolhida precisa incluir o driver NVIDIA versão 525 ou posterior no Container-Optimized OS. Se a versão 525 ou posterior do driver não for a versão padrão ou mais recente na versão do GKE, será preciso instalar manualmente um driver compatível nos nós.

Limitações

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 existentes.
  • Os nós da GPU não podem ser migrados em tempo real durante os eventos de manutenção.

  • O tipo de GPU que você pode usar depende da série de máquina, 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.

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

  • Para GPUs H100, para usar SSDs locais para armazenamento de pods, é necessário especificar explicitamente o número exato de SSDs locais que serão anexados à VM A3 subjacente usando a flag --ephemeral-storage-local-ssd=count=SSD_COUNT para armazenamento temporário ou a flag --local-nvme-ssd-block=count=SSD_COUNT para bloquear acesso. Se você omitir essa sinalização, não será possível usar os SSDs locais nos pods. Essas sinalizações serão necessárias apenas se você quiser usar o SSD local para acesso a dados.

    O tamanho de máquina compatível no GKE é a3-highgpu-8g, e a contagem de SSD local correspondente é 16.

Disponibilidade

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.

Cota de GPU

A cota de GPU é o número total de GPUs que podem ser executadas no projeto do Google 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 equivalente pelo menos ao número máximo de nós do cluster multiplicado pelo número de GPUs por nó.

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 console do Google Cloud. 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 console do Google Cloud:

  1. No IAM e administrador, acesse a página Cotas no console do 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 para 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 Next.

  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

Para executar GPUs em clusters do GKE Standard, crie um pool de nós com GPUs anexadas. 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

Além disso, o GKE aplica automaticamente as tolerâncias correspondentes aos pods que solicitam GPUs ao executar o controlador de admissão ExtendedResourceToleration (em inglês).

Isso faz com que apenas os pods solicitando GPUs sejam programados para os nós da GPU. Esse processo permite um escalonamento automático mais eficiente, porque os nós poderão ser reduzidos rapidamente se não houver pods suficientes exigindo GPUs.

Para melhor custo-benefício, confiabilidade e disponibilidade de GPUs no GKE, recomendamos as seguintes ações:

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

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 do Google Cloud ou a CLI do Google Cloud. Também é possível usar o Terraform para provisionar clusters do GKE e um pool de nós de GPU.

É possível instruir o GKE a instalar automaticamente a versão padrão ou mais recente do driver NVIDIA que corresponde à sua versão do Container-Optimized OS.

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] \
  --region COMPUTE_REGION --cluster CLUSTER_NAME \
  --node-locations COMPUTE_ZONE1[,COMPUTE_ZONE2] \
  [--enable-autoscaling \
   --min-nodes MIN_NODES \
   --max-nodes MAX_NODES] \
  [--ephemeral-storage-local-ssd=count=SSD_COUNT]

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.

  • 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 GKE.
    • 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. Se você omitir gpu-driver-version, o GKE não vai instalar um driver automaticamente.

  • AMOUNT: o número de GPUs que serão anexadas aos nós no pool de nós.

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

    Para todas as outras GPUs, essa flag é opcional.

  • COMPUTE_REGION: a região do Compute Engine do cluster, como us-central1. Escolha uma região que tenha pelo menos uma zona em que as GPUs solicitadas estejam disponíveis.

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

  • 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 --region. Os tipos de GPU que você define precisam estar disponíveis em cada zona selecionada. Recomendamos que você sempre use a sinalização --node-locations ao criar o pool de nós para especificar a zona ou as zonas que contêm as GPUs solicitadas.

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

  • SSD_COUNT: o número de SSDs locais a serem anexados para armazenamento temporário. Essa sinalização é necessária para usar SSDs locais em tipos de máquina A3 com GPUs H100.

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 \
  --region us-central1 --cluster p100-cluster \
  --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 Google Kubernetes Engine no console do Google Cloud.

    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_ZONE1,COMPUTE_ZONE2"
  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_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 especificada pela variável region. Essas zonas precisam ter os tipos de GPU definidos disponíveis. Para saber quais zonas têm GPUs, consulte Disponibilidade. Use a variável node_locations ao criar o pool de nós de GPU para especificar a zona que contém as GPUs solicitadas.
    • 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.
      • DEFAULT: instala automaticamente a versão padrão do driver na versão do sistema operacional do nó.
      • LATEST: instala automaticamente a versão mais recente do driver disponível para a versão do SO do nó.

    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:

    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
  node_locations = [var.zone]
}

resource "google_container_node_pool" "gpu_pool" {
  name       = google_container_cluster.ml_cluster.name
  location   = var.region
  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.

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

Se você tiver optado por desativar a instalação automática do driver do dispositivo ao criar um pool de nós de GPU ou se estiver usando uma versão do GKE anterior à versão mínima compatível para instalação automática, será necessário instalar manualmente um driver de GPU NVIDIA compatível nos nós. O Google fornece um DaemonSet que pode ser aplicado para instalar os drivers. Em nós de GPU que usam SO Container-Optimized, você também pode escolher entre a versão padrão do driver da GPU ou uma versão mais recente.

Recomendamos que você use a instalação automática do driver quando possível especificando a opção gpu-driver-version na sinalização --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.

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

Como alternativa, para instalar a versão mais recente do driver da GPU (veja a tabela abaixo), execute o seguinte comando:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded-latest.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.

Cada versão da imagem do Container-Optimized OS tem pelo menos uma versão compatível de driver de GPU NVIDIA. Consulte as Notas da versão dos principais marcos de LTS do Container-Optimized OS para a versão padrão suportada.

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

Versão GKE Driver NVIDIA
1.26 R470 (padrão), R510 ou R525
1,25 R470 (padrão), R510 ou R525
1.24 R470 (padrão), R510 ou R525
1.23 R450 (padrão), R470, R510 ou R525
1.22 R450 (padrão), R470, R510 ou R525
1.21 R450 (padrão), R470 ou R510
1.20 R450(padrão), R470

Ubuntu

Para implantar o DaemonSet de instalação para todas as GPUs, exceto as GPUs NVIDIA L4, execute o seguinte comando:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/ubuntu/daemonset-preloaded.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.

Para GPUs NVIDIA L4, instale o driver R525 usando o seguinte comando:

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

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

Versão GKE Driver NVIDIA
1,27 R470
1.26 R470
1,25 R470
1.24 R470
1.23 R470
1.22 R450
1.21 R450
1.20 R450

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
  }

Como usar 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 por padrão 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

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

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

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

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

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. 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 um estratégia de upgrade de nós para o pool de nós, como upgrades súbitos ou upgrades azuis-verdes. 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ós exigirá temporariamente que o GKE provisione recursos adicionais, dependendo da configuração. Se o 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, use um dos seguintes métodos:

  • Recomendado: Use uma imagem com as bibliotecas CUDA-X da NVIDIA pré-instaladas. Por exemplo, você pode usar contêineres de aprendizado profundo. Esses contêineres pré-instalam os principais frameworks de ciência de dados, as bibliotecas CUDA-X da NVIDIA e as ferramentas. Como alternativa, a imagem da NVIDIA CUDA contém apenas as bibliotecas da NVIDIA CUDA-X.
  • Crie e use sua própria imagem. Nesse caso, inclua os seguintes valores na variável de ambiente LD_LIBRARY_PATH na especificação do contêiner:
    1. /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.
    2. /usr/local/nvidia/lib64: a localização dos drivers de dispositivo da NVIDIA;

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 ver uma lista de versões dos drivers da GPU associadas à versão do GKE, consulte a página correspondente do Container-Optimized OS vinculada na tabela de versões atuais do GKE.

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.

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 Standard, é preciso instalar os drivers da NVIDIA. Para clusters do Autopilot, o GKE instala os drivers.

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.

Configurar o encerramento automático do nó da 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.

É possível configurar o GKE para encerrar as cargas de trabalho normalmente dentro desse período de notificação. No manifesto do pod, defina o campo spec.terminationGracePeriodSeconds como um valor de até 60 minutos (3600 segundos). Por exemplo, para receber um tempo de notificação de 10 minutos, no manifesto do pod, defina o campo spec.terminationGracePeriodSeconds como 600 segundos da seguinte maneira:

  spec:
    terminationGracePeriodSeconds: 600

O GKE se esforça para encerrar esses pods da melhor maneira possível e executar a ação de encerramento definida por você, por exemplo, salvando um estado de treinamento.

A seguir