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-8gea4-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:
- Rede automatizada com DRANET (recomendado): use a rede automatizada para VMs de acelerador com um perfil de rede do acelerador e o DRANET gerenciado pelo GKE para anexos de rede.
- Rede manual com a API de várias redes: siga o fluxo de trabalho manual para criar redes VPC e sub-redes, ativar a API de várias redes do GKE e configurar outras redes de nós no pool de nós do acelerador.
- 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-8goua3-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ó.
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_BLOCKSubstitua:
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, comonvidia-h200-141gbounvidia-b200.ACCELERATOR_COUNT: o número de aceleradores, como8.DRIVER_VERSION: a versão do driver da GPU, comodefaultoulatest.MACHINE_TYPE: o tipo de máquina, que precisa sera3-ultragpu-8goua4-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.
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.
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: trueSubstitua:
COMPUTE_CLASS_NAME: o nome da ComputeClass.ACCELERATOR_TYPE: o tipo de acelerador, comonvidia-h200-141gbounvidia-b200.ACCELERATOR_COUNT: o número de aceleradores, como8.MACHINE_TYPE: o tipo de máquina, que precisa sera3-ultragpu-8goua4-highgpu-8g.RESERVATION_NAME: o nome da sua reserva.RESERVATION_ZONE: a zona em que a reserva está.
Aplique o manifesto:
kubectl apply -f rdma-compute-class.yamlAo 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.
Instale o Terraform na máquina local seguindo a documentação oficial do Terraform.
Crie um diretório vazio para armazenar sua configuração e mude para ele. Crie um arquivo chamado
main.tfe 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.
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 initAdicione a seguinte configuração ao seu
main.tfou a um arquivo de configuração separado do Terraform. Essa configuração implanta um cluster com três nósa3-ultragpu-8gemus-central1-bconfigurados 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" } } }Execute
terraform plan -out=tfplanpara 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.
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: AllAplique 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.
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 infinityAplique o manifesto da carga de trabalho de teste:
kubectl apply -f nccl-test-workload.yamlExecute 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
- Saiba mais sobre o suporte ao GPUDirect RDMA no GKE.