Configurar o GPUDirect RDMA com o instalador automatizado da NCCL

Ao executar cargas de trabalho distribuídas de IA/ML, seus aplicativos geralmente exigem comunicação de alta capacidade de processamento e baixa latência entre GPUs em vários nós. As instâncias de máquina virtual (VM) A4 e A3 Ultra vêm com o adaptador de rede Titanium ML, que é baseado em controladores de interface de rede (NICs) NVIDIA ConnectX-7 (CX7). As duas famílias de VMs oferecem 3,2 Tbps sem bloqueio de tráfego de GPU para GPU entre nós usando RDMA em Ethernet convergente (RoCE). O RoCE permite o escalonamento e a colaboração em várias GPUs, oferecendo uma experiência de nuvem de alto desempenho para cargas de trabalho de IA.

Embora o GPUDirect RDMA forneça esse caminho de comunicação direta, configurar manualmente os plug-ins de rede e as declarações de recursos necessários pode ser complexo e propenso a erros.

Para resolver esse desafio operacional, combine o instalador automatizado do RDMA NCCL com a rede automatizada e o DRANET gerenciado pelo Google Kubernetes Engine (GKE) para simplificar a configuração do GPUDirect RDMA para cargas de trabalho de IA em vários hosts no GKE. O instalador automatizado do RDMA NCCL implanta automaticamente os binários NCCL e gIB necessários em pools de nós que usam tipos de máquina A3 Ultra ou A4. Ao usar esses recursos juntos, você pode se concentrar na implantação das cargas de trabalho de IA em vez de gerenciar manualmente a infraestrutura de rede subjacente e as declarações de recursos.

Para mais informações, consulte Criar um cluster com GPUDirect RDMA.

Vantagens

O instalador automatizado do NCCL de RDMA oferece os seguintes benefícios:

  • Instalação automática de bibliotecas NCCL de RDMA: a partir da versão 1.34.8-gke.1278000 do GKE para clusters Standard e da versão 1.36.2-gke.1368000 para clusters do Autopilot, é possível ativar a instalação automática das bibliotecas NCCL/gIB de RDMA, projetadas para otimizar o desempenho de rede da GPU no Google Cloud durante a criação do pool de nós usando uma única flag.
  • Configuração simplificada para executar cargas de trabalho de RDMA: ao combinar o instalador NCCL de RDMA automatizado, a rede automatizada para VMs de acelerador e a DRANET gerenciada pelo GKE, é possível implantar cargas de trabalho de IA com RDMA sem configuração de rede manual.
  • Compatibilidade e upgrades seguros: os binários NCCL de RDMA fornecidos pelo instalador passam por testes de qualificação de ponta a ponta antes de cada versão do GKE. Esse teste garante que as bibliotecas de espaço do usuário do RDMA permaneçam compatíveis com as versões específicas do kernel usadas no GKE, para que você possa fazer upgrade dos clusters e pools de nós com segurança sem interromper as cargas de trabalho em execução.

Limitações

O instalador automatizado do NCCL de RDMA tem as seguintes limitações:

  • O instalador automatizado do NCCL de RDMA é compatível com clusters do GKE Standard a partir da versão 1.34.8-gke.1278000 e com clusters do Autopilot a partir da versão 1.36.2-gke.1368000.
  • É possível usar o instalador automatizado do NCCL de RDMA apenas nos tipos de máquina a3-ultragpu-8g e a4-highgpu-8g.
  • Se você usa a DRANET gerenciada pelo GKE para configurar cargas de trabalho, consulte as principais considerações e limitações da DRANET gerenciada pelo GKE.
  • Não é possível usar a API de várias redes e o DRANET no mesmo pool de nós. É preciso escolher um método de anexo de rede para os pods.
  • Os nós do GKE precisam usar uma imagem de nó do Container-Optimized OS. As imagens de nós do Ubuntu e do Windows não são compatíveis.
  • Você precisa atender a todos os outros requisitos para executar o A3 Ultra e o A4 com o GPUDirect RDMA no GKE.

Antes de começar

Antes de começar, veja se você realizou as seguintes tarefas:

  • Verifique se o cluster usa a versão 1.34.8-gke.1278000 ou mais recente do GKE para clusters Standard ou a versão 1.36.2-gke.1368000 ou mais recente para clusters do Autopilot.
  • Verifique se você usa a versão 550.0.0 ou mais recente da Google Cloud CLI.
  • Verifique se você tem um cluster do Autopilot ou Standard. Para criar um novo cluster, consulte Criar um cluster do Autopilot.
  • Verifique se o cluster tem o GKE Dataplane V2 ativado. Para ativar o GKE Dataplane V2 ao criar um cluster, especifique a flag --enable-dataplane-v2. O GKE Dataplane V2 é ativado por padrão para todos os novos clusters do Autopilot.
  • Verifique se você configurou a rede de clusters e de pool de nós usando um dos seguintes métodos:
  • Verifique se você tem uma cota mínima de duas instâncias de máquina virtual (VM). Essa cota mínima corresponde a 16 GPUs se você usar os tipos de máquina a4-highgpu-8g ou a3-ultragpu-8g.

Criar um pool de nós com o instalador e a rede automatizada

Para ativar o GPUDirect RDMA para cargas de trabalho de IA de vários hosts, configure um pool de nós de GPU que combine o instalador automatizado do RDMA NCCL, a rede automatizada e a DRANET gerenciada pelo GKE.

Selecione uma das seguintes opções:

gcloud (padrão)

Para ativar o instalador automatizado da NCCL de RDMA em um pool de nós padrão, especifique rdma como o valor da flag --gpudirect-strategy. O GKE implanta automaticamente o plug-in RDMA NCCL compatível com a versão do nó.

  1. Configure as variáveis de ambiente a seguir:

    export CLUSTER_NAME=CLUSTER_NAME
    export CONTROL_PLANE_LOCATION=CONTROL_PLANE_LOCATION
    export PROJECT_ID=PROJECT_ID
    export NODE_POOL_NAME=NODE_POOL_NAME
    export NODEPOOL_LOCATION=NODEPOOL_LOCATION
    export ACCELERATOR_TYPE=ACCELERATOR_TYPE
    export ACCELERATOR_COUNT=ACCELERATOR_COUNT
    export DRIVER_VERSION=DRIVER_VERSION
    export MACHINE_TYPE=MACHINE_TYPE
    export NUM_NODES=NUM_NODES
    export RESERVATION_PROJECT=RESERVATION_PROJECT
    export RESERVATION_NAME=RESERVATION_NAME
    export RESERVATION_BLOCK=RESERVATION_BLOCK
    

    Substitua:

    • CLUSTER_NAME: o nome do cluster.
    • CONTROL_PLANE_LOCATION: o local do plano de controle do cluster.
    • PROJECT_ID: o ID do projeto.
    • NODE_POOL_NAME: o nome do novo pool de nós.
    • NODEPOOL_LOCATION: o local do pool de nós.
    • ACCELERATOR_TYPE: o tipo de acelerador, como nvidia-h200-141gb ou nvidia-b200.
    • ACCELERATOR_COUNT: o número de aceleradores, como 8.
    • DRIVER_VERSION: a versão do driver da GPU, como default ou latest.
    • MACHINE_TYPE: o tipo de máquina, que precisa ser a3-ultragpu-8g ou a4-highgpu-8g.
    • NUM_NODES: o número de nós no pool de nós.
    • RESERVATION_PROJECT: o ID do projeto em que a reserva está.
    • RESERVATION_NAME: o nome da reserva.
    • RESERVATION_BLOCK: o bloco de reserva.
  2. Crie o pool de nós:

    gcloud container node-pools create ${NODE_POOL_NAME} \
      --location=${CONTROL_PLANE_LOCATION} \
      --cluster=${CLUSTER_NAME} \
      --project=${PROJECT_ID} \
      --node-locations=${NODEPOOL_LOCATION} \
      --accelerator type=${ACCELERATOR_TYPE},count=${ACCELERATOR_COUNT},gpu-driver-version=${DRIVER_VERSION} \
      --machine-type=${MACHINE_TYPE} \
      --num-nodes=${NUM_NODES} \
      --reservation-affinity=specific \
      --reservation=projects/${RESERVATION_PROJECT}/reservations/${RESERVATION_NAME}/reservationBlocks/${RESERVATION_BLOCK} \
      --accelerator-network-profile=auto \
      --node-labels=cloud.google.com/gke-networking-dra-driver=true \
      --gpudirect-strategy=rdma
    

ComputeClass (Autopilot e Standard)

Para usar o instalador automatizado do NCCL de RDMA em clusters do Autopilot ou em clusters Standard com criação automática de pool de nós, configure um recurso ComputeClass personalizado com gpuDirect: rdma, acceleratorNetworkProfile: auto e DRANET ativados.

  1. Salve o seguinte manifesto como rdma-compute-class.yaml:

    apiVersion: cloud.google.com/v1
    kind: ComputeClass
    metadata:
      name: COMPUTE_CLASS_NAME
    spec:
      nodePoolConfig:
        dra:
          networking:
            enabled: true
      priorities:
      - gpu:
          type: ACCELERATOR_TYPE
          count: ACCELERATOR_COUNT
        machineType: MACHINE_TYPE
        # Optional: include the reservations block if you use a reservation
        reservations:
          affinity: Specific
          specific:
          - name: RESERVATION_NAME
            zones:
            - RESERVATION_ZONE
        acceleratorNetworkProfile: auto
        gpuDirect: rdma
      nodePoolAutoCreation:
        enabled: true
    

    Substitua:

    • COMPUTE_CLASS_NAME: o nome da ComputeClass.
    • ACCELERATOR_TYPE: o tipo de acelerador, como nvidia-h200-141gb ou nvidia-b200.
    • ACCELERATOR_COUNT: o número de aceleradores, como 8.
    • MACHINE_TYPE: o tipo de máquina, que precisa ser a3-ultragpu-8g ou a4-highgpu-8g.
    • RESERVATION_NAME: o nome da sua reserva.
    • RESERVATION_ZONE: a zona em que a reserva está.
  2. Aplique o manifesto:

    kubectl apply -f rdma-compute-class.yaml
    

    Ao implantar uma carga de trabalho que usa essa ComputeClass, adicione o seletor de nós cloud.google.com/compute-class: COMPUTE_CLASS_NAME à especificação do pod.

Terraform

É possível usar o Terraform para provisionar o cluster do GKE e o pool de nós com o instalador automatizado do NCCL de RDMA configurado.

  1. Instale o Terraform na máquina local seguindo a documentação oficial do Terraform.

  2. Crie um diretório vazio para armazenar sua configuração e mude para ele. Crie um arquivo chamado main.tf e preencha-o com o seguinte:

    # main.tf
    
    terraform {
      required_providers {
        google = {
          source  = "hashicorp/google"
          version = ">= 7.34.0" # Min version that supports the automated RDMA NCCL installer
        }
      }
    }
    
    provider "google" {
      project = "PROJECT_ID"
      region  = "REGION"
      zone    = "ZONE"
    }
    

    Substitua:

    • PROJECT_ID: o ID do projeto.
    • REGION: a região de computação.
    • ZONE: uma zona que aceita os tipos de máquina A3 Ultra ou A4.
  3. Execute os comandos a seguir no mesmo diretório para autenticar com o Google Cloud e inicializar o estado do Terraform:

    gcloud auth application-default login
    terraform init
    
  4. Adicione a seguinte configuração ao seu main.tf ou a um arquivo de configuração separado do Terraform. Essa configuração implanta um cluster com três nós a3-ultragpu-8g em us-central1-b configurados para usar o instalador automático de NCCL RDMA, um perfil de rede de acelerador automático e a DRANET gerenciada pelo GKE:

    resource "google_container_cluster" "cluster" {
      name               = "example-rdma-tf"
      location           = "us-central1-b"
    
      initial_node_count  = 3 # Number of CPU nodes in default pool
      deletion_protection = false # Optional, allows Terraform to delete clusters
    
      min_master_version      = "1.34.8-gke.1278000" # Required, min version for Standard clusters with automated RDMA NCCL installer support
      datapath_provider       = "ADVANCED_DATAPATH" # Required, enable GKE Dataplane v2
    }
    
    resource "google_container_node_pool" "rdma_pool" {
      name       = "rdma-pool"
      cluster    = google_container_cluster.cluster.name
      location   = google_container_cluster.cluster.location
      node_count = 3
    
      network_config {
        accelerator_network_profile = "auto" # Required if per-NIC networks are not manually configured
      }
    
      node_config {
        machine_type = "a3-ultragpu-8g"
        guest_accelerator {
          type  = "nvidia-h200-141gb"
          count = 8
        }
    
        ephemeral_storage_local_ssd_config { # Required, see https://github.com/hashicorp/terraform-provider-google/issues/17068
          data_cache_count = 0
          local_ssd_count = 32
        }
    
        gpudirect_strategy = "RDMA"
    
        labels = {
          "cloud.google.com/gke-networking-dra-driver"  = "true" # Automatically install DRANET driver
          "gke.networks.io/accelerator-network-profile" = "auto"
        }
      }
    }
    
  5. Execute terraform plan -out=tfplan para conferir as mudanças que o Terraform faz com base na configuração atual. Depois de verificar o plano, execute-o usando o seguinte comando:

    terraform apply tfplan
    

Criar um ResourceClaimTemplate

Para permitir que os pods solicitem e recebam dinamicamente dispositivos RDMA, crie um objeto ResourceClaimTemplate, ajudando a fornecer rede de alto desempenho para cargas de trabalho de IA. A configuração allocationMode: All aloca todos os dispositivos RDMA mrdma.google.com disponíveis. A alocação de todos os dispositivos disponíveis é crucial para cargas de trabalho de IA em vários hosts que exigem a utilização total dos recursos de GPU e RDMA.

  1. Salve o seguinte manifesto como all-mrdma-template.yaml:

    apiVersion: resource.k8s.io/v1
    kind: ResourceClaimTemplate
    metadata:
      name: all-mrdma
    spec:
      spec:
        devices:
          requests:
          - name: req-mrdma
            exactly:
              deviceClassName: mrdma.google.com
              allocationMode: All
    
  2. Aplique o manifesto:

    kubectl apply -f all-mrdma-template.yaml
    

Implantar e executar uma carga de trabalho de teste de RDMA da NCCL

Para verificar a configuração do RDMA, implante uma carga de trabalho de teste e execute um teste de coleta total da NCCL para confirmar a configuração.

  1. Salve o seguinte manifesto como nccl-test-workload.yaml:

    apiVersion: v1
    kind: Service
    metadata:
      name: nccl-host-1
    spec:
      selector:
        name: nccl-host-1
      clusterIP: None
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: nccl-host-2
    spec:
      selector:
        name: nccl-host-2
      clusterIP: None
    ---
    apiVersion: v1
    kind: Pod
    metadata:
      name: nccl-test-host-1
      labels:
        name: nccl-host-1
    spec:
      # Uncomment the following lines if you use a custom ComputeClass:
      # nodeSelector:
      #   cloud.google.com/compute-class: COMPUTE_CLASS_NAME
      volumes:
        - name: library-dir-host
          hostPath:
            path: /home/kubernetes/bin/nvidia
        - name: gib
          hostPath:
            path: /home/kubernetes/bin/gib
        - name: shared-memory
          emptyDir:
            medium: "Memory"
            sizeLimit: 250Gi
      resourceClaims:
      - name: rdma
        resourceClaimTemplateName: all-mrdma
      containers:
        - image: us-docker.pkg.dev/gce-ai-infra/gpudirect-gib/nccl-plugin-gib-diagnostic:v1.1.2
          name: test
          resources:
            requests:
              cpu: 150m
            limits:
              nvidia.com/gpu: 8
            claims:
            - name: rdma
          volumeMounts:
            - name: library-dir-host
              mountPath: /usr/local/nvidia
            - name: gib
              mountPath: /usr/local/gib
            - name: shared-memory
              mountPath: /dev/shm
          env:
            - name: LD_LIBRARY_PATH
              value: /usr/local/nvidia/lib64
          command: ["/bin/bash", "-c"]
          args:
            - |
              /scripts/container_entry.sh shell
              source /usr/local/gib/scripts/set_nccl_env.sh
              sleep infinity
    ---
    apiVersion: v1
    kind: Pod
    metadata:
      name: nccl-test-host-2
      labels:
        name: nccl-host-2
    spec:
      # Uncomment the following lines if you use a custom ComputeClass:
      # nodeSelector:
      #   cloud.google.com/compute-class: COMPUTE_CLASS_NAME
      volumes:
        - name: library-dir-host
          hostPath:
            path: /home/kubernetes/bin/nvidia
        - name: gib
          hostPath:
            path: /home/kubernetes/bin/gib
        - name: shared-memory
          emptyDir:
            medium: "Memory"
            sizeLimit: 250Gi
      resourceClaims:
      - name: rdma
        resourceClaimTemplateName: all-mrdma
      containers:
        - image: us-docker.pkg.dev/gce-ai-infra/gpudirect-gib/nccl-plugin-gib-diagnostic:v1.1.2
          name: test
          resources:
            requests:
              cpu: 150m
            limits:
              nvidia.com/gpu: 8
            claims:
            - name: rdma
          volumeMounts:
            - name: library-dir-host
              mountPath: /usr/local/nvidia
            - name: gib
              mountPath: /usr/local/gib
            - name: shared-memory
              mountPath: /dev/shm
          env:
            - name: LD_LIBRARY_PATH
              value: /usr/local/nvidia/lib64
          command: ["/bin/bash", "-c"]
          args:
            - |
              /scripts/container_entry.sh shell
              source /usr/local/gib/scripts/set_nccl_env.sh
              sleep infinity
    
  2. Aplique o manifesto da carga de trabalho de teste:

    kubectl apply -f nccl-test-workload.yaml
    
  3. Execute um teste de coleta total da NCCL entre os dois hosts de teste:

    kubectl exec nccl-test-host-1 -it -- /usr/local/gib/scripts/run_nccl_tests.sh -t all_gather -b 1K -e 8G nccl-host-1 nccl-host-2
    

Implantar sua carga de trabalho de IA/ML

Para executar os jobs de treinamento distribuído de maneira eficiente, os aplicativos de ML precisam solicitar os dispositivos RDMA provisionados pelo instalador. Depois de verificar a configuração do RDMA com a carga de trabalho de teste, é possível implantar os aplicativos de IA/ML. Os pods do aplicativo precisam referenciar o objeto ResourceClaimTemplate que você criou anteriormente (all-mrdma) para solicitar e receber dispositivos RDMA de forma dinâmica.

O manifesto do pod a seguir usa o objeto all-mrdma ResourceClaimTemplate. Substitua IMAGE pela imagem do contêiner da carga de trabalho de IA/ML e COMMAND pelo ponto de entrada do aplicativo.

apiVersion: v1
kind: Pod
metadata:
  name: my-rdma-workload
spec:
  restartPolicy: OnFailure
  # Uncomment the following lines if you use a custom ComputeClass:
  # nodeSelector:
  #   cloud.google.com/compute-class: COMPUTE_CLASS_NAME
  volumes:
    - name: library-dir-host
      hostPath:
        path: /home/kubernetes/bin/nvidia
    - name: gib
      hostPath:
        path: /home/kubernetes/bin/gib
    - name: shared-memory
      emptyDir:
        medium: "Memory"
        sizeLimit: 250Gi
  resourceClaims:
  - name: mrdma-claim
    resourceClaimTemplateName: all-mrdma
  containers:
  - name: my-container
    image: IMAGE # Replace with your AI/ML workload image, for example, gcr.io/your-project/your-ai-app:latest
    command: ["/bin/bash", "-c"]
    args:
      - |
        source /usr/local/gib/scripts/set_nccl_env.sh
        COMMAND # Replace with your workload command, for example, python3 train.py
    resources:
      limits:
        nvidia.com/gpu: 8 # Specify the required GPU count
      claims:
      - name: mrdma-claim
    volumeMounts:
      - name: library-dir-host
        mountPath: /usr/local/nvidia
      - name: gib
        mountPath: /usr/local/gib
      - name: shared-memory
        mountPath: /dev/shm
    env:
      - name: LD_LIBRARY_PATH
        value: /usr/local/nvidia/lib64
      - name: MASTER_ADDR
        value: "nccl-test-host-1" # Example for distributed training
      - name: MASTER_PORT
        value: "29500"

Para implantar essa carga de trabalho, salve o manifesto como workload.yaml e aplique-o:

kubectl apply -f workload.yaml

Configurações avançadas

Também é possível ativar o instalador automatizado do NCCL de RDMA em pools de nós que usam configurações manuais de várias redes em vez de rede automatizada com DRANET.

Criar um pool de nós em um cluster com várias redes ativadas

Se você seguiu as configurações de cluster em Suporte ao GPUDirect RDMA no GKE, use as instruções a seguir para criar um novo pool de nós com o instalador NCCL do RDMA automatizado ativado em clusters atuais com várias redes ativadas.

Para verificar se o cluster tem várias redes ativadas, execute o seguinte comando:

export CLUSTER_NAME=CLUSTER_NAME
export CONTROL_PLANE_LOCATION=CONTROL_PLANE_LOCATION
export PROJECT_ID=PROJECT_ID
export CLUSTER_VERSION=CLUSTER_VERSION

gcloud container clusters describe ${CLUSTER_NAME} \
  --location ${CONTROL_PLANE_LOCATION} --project ${PROJECT_ID} \
  --format="value(networkConfig.enableMultiNetworking)"

Para reutilizar as redes VPC para outras placas de rede (NICs) nas instâncias de VM A3 Ultra e VM A4, defina as seguintes variáveis:

export REGION=REGION
export ZONE=ZONE
export GVNIC_NETWORK_PREFIX=GVNIC_NETWORK_PREFIX
export RDMA_NETWORK_PREFIX=RDMA_NETWORK_PREFIX

Para criar um pool de nós com o instalador automatizado do RDMA NCCL, execute o seguinte comando:

export NODE_POOL_NAME=NODE_POOL_NAME
export PROJECT_ID=PROJECT_ID
export NODE_COUNT=NODE_COUNT
export ACCELERATOR_TYPE=ACCELERATOR_TYPE
export ACCELERATOR_COUNT=ACCELERATOR_COUNT
export DRIVER_VERSION=DRIVER_VERSION
export MACHINE_TYPE=MACHINE_TYPE
export RESERVATION=RESERVATION

gcloud container node-pools create ${NODE_POOL_NAME} --project ${PROJECT_ID} \
  --location ${CONTROL_PLANE_LOCATION} --node-locations ${ZONE} --cluster ${CLUSTER_NAME} --num-nodes=${NODE_COUNT} \
  --machine-type ${MACHINE_TYPE} \
  --accelerator type=${ACCELERATOR_TYPE},count=${ACCELERATOR_COUNT},gpu-driver-version=${DRIVER_VERSION} \
  --additional-node-network network=${GVNIC_NETWORK_PREFIX}-net,subnetwork=${GVNIC_NETWORK_PREFIX}-sub \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-0 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-1 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-2 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-3 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-4 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-5 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-6 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-7 \
  --scopes "https://www.googleapis.com/auth/cloud-platform" \
  --reservation-affinity=specific \
  --reservation=${RESERVATION} \
  --gpudirect-strategy=rdma

A seguir