Preparar a infraestrutura do GKE para cargas de trabalho do DRA

Este documento explica como configurar sua infraestrutura do Google Kubernetes Engine (GKE) para oferecer suporte à alocação dinâmica de recursos (DRA). As etapas de configuração incluem a criação de pools de nós que usam GPUs ou TPUs e a instalação de drivers DRA no cluster. Este documento é destinado a administradores de plataforma que querem reduzir a complexidade e a sobrecarga da configuração de infraestrutura com dispositivos de hardware especializados.

Limitações

  • O provisionamento automático de nós não é compatível.
  • Os clusters do Autopilot não são compatíveis com a DRA.
  • A instalação automática de drivers de GPU não é compatível com o DRA.
  • Não é possível usar os seguintes recursos de compartilhamento de GPU:
    • GPUs de compartilhamento de tempo
    • GPUs com várias instâncias
    • Serviço de multiprocessamento (MPS)
  • Para TPUs, é necessário ativar as versões v1beta1 e v1beta2 dos tipos de API DRA. Essa limitação não se aplica a GPUs, que podem usar versões da API v1.

Requisitos

Para usar o DRA, seu cluster do GKE precisa executar a versão 1.34 ou mais recente.

Você também precisa conhecer os seguintes requisitos e limitações, dependendo do tipo de hardware que quer usar:

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 gcloud CLI anteriormente, instale a versão mais recente executando o comando gcloud components update. Talvez as versões anteriores da gcloud CLI não sejam compatíveis com a execução dos comandos neste documento.

  • Ter um cluster do GKE Standard que execute a versão 1.34 ou mais recente. Também é possível criar um cluster regional.

  • Se você não estiver usando o Cloud Shell, instale a CLI do Helm:

    curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3
chmod 700 get_helm.sh
./get_helm.sh

  • Para usar o DRA com TPUs, ative as versões v1beta1 e v1beta2 dos tipos de API do DRA:

    gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-kubernetes-unstable-apis="resource.k8s.io/v1beta1/deviceclasses,resource.k8s.io/v1beta1/resourceclaims,resource.k8s.io/v1beta1/resourceclaimtemplates,resource.k8s.io/v1beta1/resourceslices,resource.k8s.io/v1beta2/deviceclasses,resource.k8s.io/v1beta2/resourceclaims,resource.k8s.io/v1beta2/resourceclaimtemplates,resource.k8s.io/v1beta2/resourceslices"

Criar um pool de nós do GKE com GPUs ou TPUs

No GKE, é possível usar o DRA com GPUs e TPUs. As configurações de configuração do pool de nós, como tipo de máquina, tipo e contagem de acelerador, sistema operacional e locais dos nós, dependem dos seus requisitos. Para criar um pool de nós compatível com DRA, selecione uma das seguintes opções:

GPU

Para usar o DRA com GPUs, faça o seguinte ao criar o pool de nós:

  • Desative a instalação automática de drivers de GPU especificando a opção gpu-driver-version=disabled na flag --accelerator ao configurar GPUs para um pool de nós.
  • Desative o plug-in de dispositivo GPU adicionando o identificador de nó gke-no-default-nvidia-gpu-device-plugin=true.
  • Permita que o DaemonSet do driver DRA seja executado nos nós adicionando o rótulo do nó nvidia.com/gpu.present=true.

Para criar um pool de nós de GPU para o DRA, siga estas etapas:

  1. Crie um pool de nós com o hardware necessário. O exemplo a seguir cria um pool de nós com uma instância g2-standard-24 no Container-Optimized OS com duas GPUs L4.

    gcloud container node-pools create NODEPOOL_NAME \
    --cluster=CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --machine-type "g2-standard-24" \
    --accelerator "type=nvidia-l4,count=2,gpu-driver-version=disabled" \
    --num-nodes "1" \
    --node-labels=gke-no-default-nvidia-gpu-device-plugin=true,nvidia.com/gpu.present=true

    Substitua:

    • NODEPOOL_NAME: o nome do pool de nós.
    • CLUSTER_NAME: o nome do cluster.
    • CONTROL_PLANE_LOCATION: a região ou zona do plano de controle do cluster, como us-central1 ou us-central1-a.

  2. Instale manualmente os drivers no Container-Optimized OS ou nós do Ubuntu. Para instruções detalhadas, consulte Instale manualmente os drivers de GPU NVIDIA.

TPU

Para usar o DRA com TPUs, desative o plug-in de dispositivo TPU adicionando o rótulo do nó gke-no-default-tpu-device-plugin=true. O exemplo a seguir cria um pool de nós da TPU Trillium com suporte a DRA:

gcloud container node-pools create NODEPOOL_NAME \
    --cluster CLUSTER_NAME --num-nodes 1 \
    --location=CONTROL_PLANE_LOCATION \
    --node-labels "gke-no-default-tpu-device-plugin=true,gke-no-default-tpu-dra-plugin=true" \
    --machine-type=ct6e-standard-8t

Substitua:

  • NODEPOOL_NAME: o nome do pool de nós.
  • CLUSTER_NAME: o nome do cluster.
  • CONTROL_PLANE_LOCATION: a região ou zona do plano de controle do cluster, como us-central1 ou us-central1-a.

Instalar drivers DRA

GPU

  1. Extraia e atualize o gráfico do Helm que contém o driver DRA da NVIDIA:

    helm repo add nvidia https://helm.ngc.nvidia.com/nvidia \
    && helm repo update

  2. Instale o driver NVIDIA DRA com a versão 25.3.2:

    helm install nvidia-dra-driver-gpu nvidia/nvidia-dra-driver-gpu \
    --version="25.3.2" --create-namespace --namespace=nvidia-dra-driver-gpu \
    --set nvidiaDriverRoot="/home/kubernetes/bin/nvidia/" \
    --set gpuResourcesEnabledOverride=true \
    --set resources.computeDomains.enabled=false \
    --set kubeletPlugin.priorityClassName="" \
    --set 'kubeletPlugin.tolerations[0].key=nvidia.com/gpu' \
    --set 'kubeletPlugin.tolerations[0].operator=Exists' \
    --set 'kubeletPlugin.tolerations[0].effect=NoSchedule'

    Para nós do Ubuntu, use o caminho do diretório nvidiaDriverRoot="/opt/nvidia".

TPU

  1. Clone o repositório ai-on-gke para acessar os gráficos do Helm que contêm os drivers DRA para GPUs e TPUs:

    git clone https://github.com/ai-on-gke/common-infra.git

  2. Navegue até o diretório que contém os gráficos:

    cd common-infra/common/charts

  3. Instale o driver DRA da TPU:

    ./tpu-dra-driver/install-tpu-dra-driver.sh

Verificar se sua infraestrutura está pronta para o DRA

  1. Para verificar se os pods de driver DRA estão em execução, selecione uma das seguintes opções:

    GPU 

    kubectl get pods -n nvidia-dra-driver-gpu

    O resultado será o seguinte:

    NAME                                         READY   STATUS    RESTARTS   AGE
nvidia-dra-driver-gpu-kubelet-plugin-52cdm   1/1     Running   0          46s

    TPU 

    kubectl get pods -n tpu-dra-driver

    O resultado será o seguinte:

    NAME                                         READY   STATUS    RESTARTS   AGE
tpu-dra-driver-kubeletplugin-h6m57           1/1     Running   0          30s

  2. Confirme se o ResourceSlice lista os dispositivos de hardware que você adicionou:

    kubectl get resourceslices -o yaml

    Se você usou o exemplo na seção anterior, a saída será semelhante a esta, dependendo se você configurou GPUs ou TPUs:

    GPU 

    apiVersion: v1
items:
- apiVersion: resource.k8s.io/v1
  kind: ResourceSlice
  metadata:
  # Multiple lines are omitted here.
  spec:
    devices:
    - attributes:
        architecture:
          string: Ada Lovelace
        brand:
          string: Nvidia
        cudaComputeCapability:
          version: 8.9.0
        cudaDriverVersion:
          version: 13.0.0
        driverVersion:
          version: 580.65.6
        index:
          int: 0
        minor:
          int: 0
        pcieBusID:
          string: "0000:00:03.0"
        productName:
          string: NVIDIA L4
        resource.kubernetes.io/pcieRoot:
          string: pci0000:00
        type:
          string: gpu
        uuid:
          string: GPU-ccc19e5e-e3cd-f911-65c8-89bcef084e3f
      capacity:
        memory:
          value: 23034Mi
      name: gpu-0
    - attributes:
        architecture:
          string: Ada Lovelace
        brand:
          string: Nvidia
        cudaComputeCapability:
          version: 8.9.0
        cudaDriverVersion:
          version: 13.0.0
        driverVersion:
          version: 580.65.6
        index:
          int: 1
        minor:
          int: 1
        pcieBusID:
          string: "0000:00:04.0"
        productName:
          string: NVIDIA L4
        resource.kubernetes.io/pcieRoot:
          string: pci0000:00
        type:
          string: gpu
        uuid:
          string: GPU-f783198d-42f9-7cef-9ea1-bb10578df978
      capacity:
        memory:
          value: 23034Mi
      name: gpu-1
    driver: gpu.nvidia.com
    nodeName: gke-cluster-1-dra-gpu-pool-b56c4961-7vnm
    pool:
      generation: 1
      name: gke-cluster-1-dra-gpu-pool-b56c4961-7vnm
      resourceSliceCount: 1
kind: List
metadata:
  resourceVersion: ""

    TPU 

    apiVersion: v1
items:
- apiVersion: resource.k8s.io/v1beta1
  kind: ResourceSlice
  metadata:
    # lines omitted for clarity
  spec:
    devices:
    - basic:
        attributes:
          index:
            int: 0
          tpuGen:
            string: v6e
          uuid:
            string: tpu-54de4859-dd8d-f67e-6f91-cf904d965454
      name: "0"
    - basic:
        attributes:
          index:
            int: 1
          tpuGen:
            string: v6e
          uuid:
            string: tpu-54de4859-dd8d-f67e-6f91-cf904d965454
      name: "1"
    - basic:
        attributes:
          index:
            int: 2
          tpuGen:
            string: v6e
          uuid:
            string: tpu-54de4859-dd8d-f67e-6f91-cf904d965454
      name: "2"
    - basic:
        attributes:
          index:
            int: 3
          tpuGen:
            string: v6e
          uuid:
            string: tpu-54de4859-dd8d-f67e-6f91-cf904d965454
      name: "3"
    driver: tpu.google.com
    nodeName: gke-tpu-b4d4b61b-fwbg
    pool:
      generation: 1
      name: gke-tpu-b4d4b61b-fwbg
      resourceSliceCount: 1
kind: List
metadata:
  resourceVersion: ""

A seguir