Neste documento, mostramos como criar um cluster do Google Kubernetes Engine (GKE) otimizado para IA que usa instâncias A4X Max do Compute Engine para oferecer suporte às suas cargas de trabalho de IA e ML.
As séries A4X Max e A4X permitem executar clusters de IA/ML em grande escala usando o sistema NVIDIA Multi-Node NVLink (MNNVL), uma solução em escala de rack que permite maior potência e desempenho da GPU. Essas máquinas oferecem recursos como posicionamento de carga de trabalho direcionado, programação com reconhecimento de topologia e controles avançados de manutenção de cluster. Para mais informações, consulte Recursos de gerenciamento de clusters. Com o A4X Max, o GKE também oferece uma configuração de rede automatizada que simplifica a configuração do cluster.
As cargas de trabalho de IA e ML, como o treinamento distribuído, exigem uma aceleração poderosa para otimizar o desempenho, reduzindo os tempos de conclusão dos jobs. O GKE oferece uma única plataforma para executar um conjunto diversificado de cargas de trabalho para suas organizações, reduzindo o ônus operacional de gerenciar várias plataformas. É possível executar cargas de trabalho como pré-treinamento distribuído de alta performance, ajuste fino e inferência de modelos, exibição de aplicativos e serviços de suporte. Para cargas de trabalho que exigem alto desempenho, alta capacidade de processamento e baixa latência, o GPUDirect RDMA reduz os saltos de rede necessários para transferir payloads de e para GPUs. Essa abordagem usa de maneira mais eficiente a largura de banda da rede disponível. Para mais informações, consulte Stacks de rede de GPU.
Neste documento, você vai aprender a criar um cluster do GKE com a Google Cloud CLI para ter a máxima flexibilidade ao configurar o cluster com base nas necessidades da sua carga de trabalho. Para usar a CLI gcloud e criar clusters com outros tipos de máquina, consulte o seguinte:
- A4X: crie um cluster do GKE personalizado otimizado para IA que usa A4X.
- A4 ou A3 Ultra: para criar um cluster que usa A4 ou A3 Ultra, consulte Criar um cluster do GKE personalizado otimizado para IA que usa A4 ou A3 Ultra. É possível usar essas séries de máquinas para executar cargas de trabalho com ou sem GPUDirect RDMA.
Como alternativa, use o Cluster Toolkit para implantar rapidamente seu cluster com configurações padrão que refletem as práticas recomendadas para muitos casos de uso. Para mais informações, consulte Criar um cluster do GKE otimizado para IA com configuração padrão.
Antes de começar
Antes de começar, verifique se você realizou as tarefas a seguir:
- Ative a API 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.
Obter capacidade
Para conseguir capacidade para instâncias de computação A4X Max, crie uma reserva futura. Para mais informações sobre reservas adiantadas, consulte a coluna Reservas adiantadas no Hipercomputador de IA na tabela Escolher uma opção de consumo.
Para obter capacidade com uma reserva adiantada, consulte a linha Reservas adiantadas no Hipercomputador de IA na tabela Como obter capacidade.
Requisitos
Os requisitos a seguir se aplicam a um cluster do GKE otimizado para IA com instâncias de computação A4X Max:
Para o A4X Max, use uma das seguintes versões:
- Para a versão 1.35 ou mais recente, use a versão 1.35.0-gke.2745000 ou mais recente do GKE.
- Para a versão 1.34, use a versão 1.34.3-gke.1318000 ou mais recente do GKE.
Essas versões ajudam a garantir que o A4X Max use o seguinte:
- R580.95.05, a versão mínima do driver de GPU para A4X Max, que é ativada por padrão.
- Gerenciamento de memória coerente baseado em driver (CDMM), que é ativado por padrão. A NVIDIA recomenda que os clusters do Kubernetes ativem esse modo para resolver o excesso de relatórios de memória. O CDMM permite que a memória da GPU seja gerenciada pelo driver em vez do sistema operacional (SO). Essa abordagem ajuda a evitar a ativação on-line da memória da GPU pelo SO e expõe a memória da GPU como um nó de acesso à memória não uniforme (NUMA, na sigla em inglês) para o SO. Não há suporte para GPUs de várias instâncias quando o CDMM está ativado. Para mais informações sobre o CDMM, consulte Suporte de hardware e software.
- GPUDirect RDMA e MNNVL, que são recomendados para permitir que os pools de nós do A4X Max usem os recursos de rede do A4X Max.
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.
Sua carga de trabalho do GKE precisa usar todas as GPUs disponíveis, e o pod precisa usar todas as NICs secundárias disponíveis em um único nó do GKE. Vários pods não podem compartilhar RDMA em um único nó do GKE.
É necessário usar o modelo de provisionamento vinculado à reserva para criar clusters com o A4X Max. Outros modelos de provisionamento não são compatíveis.
Estas instruções usam o DRANET para configurar um cluster do GKE otimizado para IA com A4X Max. A multirrede não é compatível com o tipo de máquina
a4x-maxgpu-4g-metal.
Considerações para criar um cluster
Ao criar um cluster, considere as seguintes informações:
- Escolha um local para o cluster:
- Verifique se você está usando um local que tem disponibilidade para o tipo de máquina escolhido. Para mais informações, consulte Disponibilidade de aceleradores.
- Ao criar pools de nós em um cluster regional, que é recomendado para cargas de trabalho de produção, use a flag
--node-locationspara especificar as zonas dos nós do GKE.
- Escolha uma versão do driver:
- A versão do driver pode ser um dos seguintes valores:
default: instale a versão padrão do driver para a versão do nó do GKE. Para mais informações sobre os requisitos das versões padrão de driver, consulte a seção Requisitos.latest: instale a versão mais recente disponível do driver para a versão do GKE. Essa opção está disponível apenas para nós que usam o Container-Optimized OS.disabled: pule a instalação automática do driver. Você precisa instalar manualmente um driver depois de criar o pool de nós.
- Para mais informações sobre as versões padrão e mais recentes do driver de GPU para versões de nós do GKE, consulte a tabela na seção Instalar manualmente os drivers de GPU NVIDIA.
- A versão do driver pode ser um dos seguintes valores:
Escolha uma afinidade de reserva:
- Você pode encontrar informações sobre sua reserva, como o nome dela ou de um bloco específico. Para encontrar esses valores, consulte Conferir solicitações de reserva adiantada.
- A flag
--reservation-affinitypode ter os valoresspecificouany. No entanto, para cargas de trabalho de IA distribuídas de alta performance, recomendamos usar uma reserva específica. Ao usar uma reserva específica, incluindo reservas compartilhadas, especifique o valor da flag
--reservationno seguinte formato:projects/PROJECT_ID/reservations/RESERVATION_NAME/reservationBlocks/BLOCK_NAMESubstitua os seguintes valores:
PROJECT_ID: o ID do projeto Google Cloud .RESERVATION_NAME: o nome da sua reserva.BLOCK_NAME: o nome de um bloco específico na reserva.
Também recomendamos que você use uma reserva segmentada por sub-bloco para que as instâncias de computação sejam colocadas em um único sub-bloco dentro do
BLOCK_NAME. Adicione o seguinte ao final do caminho:/reservationSubBlocks/SUB_BLOCK_NAMESubstitua
SUB_BLOCK_NAMEpelo nome do sub-bloco.
Criar um cluster do GKE otimizado para IA que usa A4X Max e GPUDirect RDMA
Para cargas de trabalho de IA distribuídas, vários nós de GPU são vinculados para funcionar como um único computador. A A4X Max é uma plataforma de exaescala baseada na arquitetura de rack NVIDIA GB300 NVL72. As instâncias de computação A4X Max usam uma arquitetura de rede hierárquica e multicamadas com um design alinhado a trilhos para otimizar o desempenho de vários tipos de comunicação. Esse tipo de máquina permite escalonamento e colaboração em várias GPUs, oferecendo uma experiência de nuvem de alta performance para cargas de trabalho de IA. Para mais informações sobre a arquitetura de rede do A4X Max, incluindo a largura de banda da rede e o arranjo de NICs, consulte Tipo de máquina A4X Max (bare metal).
Para criar um cluster do GKE Standard com A4X Max que usa GPUDirect RDMA e MNNVL, siga as etapas descritas nas seções a seguir:
- Criar o cluster do GKE
- Criar uma política de carga de trabalho
- Criar um pool de nós com A4X Max
- Configure as NICs do MRDMA com
asapd-lite - Instale o driver NVIDIA Compute Domain CRD e DRA
- Configurar o manifesto da carga de trabalho para RDMA e domínio IMEX
Estas instruções usam perfis de rede de aceleradores para configurar automaticamente redes e sub-redes VPC para seus nós A4X Max. Também é possível especificar explicitamente sua rede VPC e sub-redes.
Criar o cluster do GKE
Crie um cluster do GKE Standard:
gcloud container clusters create CLUSTER_NAME \ --enable-dataplane-v2 \ --enable-ip-alias \ --location=COMPUTE_REGION \ --cluster-version=CLUSTER_VERSION \ --no-enable-shielded-nodes [\ --services-ipv4-cidr=SERVICE_CIDR \ --cluster-ipv4-cidr=POD_CIDR \ --addons=GcpFilestoreCsiDriver=ENABLED]Substitua:
CLUSTER_NAME: o nome do cluster.CLUSTER_VERSION: a versão do novo cluster. Para mais informações sobre qual versão do GKE é compatível com sua configuração, consulte os Requisitos neste documento.COMPUTE_REGION: o nome da região de computação.Se quiser, você pode fornecer explicitamente os intervalos CIDR secundários para serviços e pods. Se você usar essas flags opcionais, substitua as seguintes variáveis:
SERVICE_CIDR: o intervalo CIDR secundário para serviços.POD_CIDR: o intervalo CIDR secundário para pods.
Ao usar essas flags, verifique se os intervalos CIDR não se sobrepõem aos intervalos de sub-rede para redes de nós adicionais. Por exemplo, considere
SERVICE_CIDR=10.65.0.0/19ePOD_CIDR=10.64.0.0/19. Para mais informações, consulte Adicionar intervalos de endereços IPv4 de pods.
Para executar os comandos
kubectlnas próximas seções, conecte-se ao cluster:gcloud container clusters get-credentials CLUSTER_NAME --location=COMPUTE_REGIONSubstitua:
CLUSTER_NAME: o nome do cluster.COMPUTE_REGION: o nome da região de computação.
Para mais informações, consulte Instalar o kubectl e configurar o acesso ao cluster.
Criar uma política de carga de trabalho
É necessário ter uma política de carga de trabalho para criar uma partição. Para mais informações, consulte Política de carga de trabalho para MIGs.
Crie uma política de carga de trabalho HIGH_THROUGHPUT com o campo accelerator_topology definido como 1x72.
gcloud beta compute resource-policies create workload-policy WORKLOAD_POLICY_NAME \
--type HIGH_THROUGHPUT \
--accelerator-topology 1x72 \
--project PROJECT \
--region COMPUTE_REGION
Substitua:
WORKLOAD_POLICY_NAME: o nome da política de carga de trabalho.PROJECT: o nome do projeto.COMPUTE_REGION: o nome da região de computação.
Criar um pool de nós com A4X Max
Crie o seguinte arquivo de configuração para pré-alocar hugepages com o pool de nós:
cat > node_custom.yaml <<EOF linuxConfig: hugepageConfig: hugepage_size2m: 4096 EOF export NODE_CUSTOM=node_custom.yamlCrie um pool de nós do A4X Max:
gcloud container node-pools create NODE_POOL_NAME \ --cluster=CLUSTER_NAME \ --location=COMPUTE_REGION \ --node-locations=COMPUTE_ZONE \ --num-nodes=NODE_COUNT \ --placement-policy=WORKLOAD_POLICY_NAME \ --machine-type=a4x-maxgpu-4g-metal \ --accelerator=type=nvidia-gb300,count=4,gpu-driver-version=latest \ --system-config-from-file=${NODE_CUSTOM} \ --accelerator-network-profile=auto \ --node-labels=cloud.google.com/gke-networking-dra-driver=true,cloud.google.com/gke-dpv2-unified-cni=cni-migration \ --reservation-affinity=specific \ --reservation=RESERVATION_NAME/reservationBlocks/BLOCK_NAME/reservationSubBlocks/SUB_BLOCK_NAMESubstitua:
NODE_POOL_NAME: o nome do pool de nós.CLUSTER_NAME: o nome do cluster.COMPUTE_REGION: a região de computação do cluster.COMPUTE_ZONE: a zona do pool de nós.NODE_COUNT: o número de nós do pool, que precisa ser de 18 ou menos. Recomendamos usar 18 nós para obter a topologia de GPU de1x72em um subbloco usando um domínio NVLink.WORKLOAD_POLICY_NAME: o nome da política de carga de trabalho que você criou anteriormente.RESERVATION_NAME: o nome da sua reserva. Para encontrar esse valor, consulte Conferir futuras solicitações de reserva.BLOCK_NAME: o nome de um bloco específico dentro da reserva. Para encontrar esse valor, consulte Conferir futuras solicitações de reserva.
Esse comando cria automaticamente uma rede que conecta todos os nós do A4X Max em uma única zona usando o perfil de rede do acelerador
auto. Quando você cria um pool de nós com a flag--accelerator-network-profile=auto, o GKE adiciona automaticamente o rótulogke.networks.io/accelerator-network-profile: autoaos nós. Para programar cargas de trabalho nesses nós, inclua esse rótulo no camponodeSelectorda carga de trabalho.
Configure as NICs do MRDMA com asapd-lite
O DaemonSet asapd-lite configura as NICs MRDMA. Um DaemonSet asapd-lite não íntegro pode indicar que não há conectividade RDMA.
Instale o DaemonSet:
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/refs/heads/master/asapd-lite-installer/asapd-lite-installer-a4x-max-bm-cos.yamlValide as réplicas no DaemonSet
asapd-lite:kubectl get daemonset -n kube-system asapd-liteO resultado será o seguinte:
NAME DESIRED CURRENT READY UP-TO-DATE AVAILABLE NODE SELECTOR AGE asapd-lite 18 18 18 18 18 <none> 5mO número de réplicas de
READYprecisa corresponder ao número de nós criados e íntegros no pool de nós.
Instalar o CRD do domínio de computação da NVIDIA e o driver DRA
As etapas a seguir instalam o CRD do domínio de computação da NVIDIA e o driver DRA para permitir o uso do MNNVL. Para mais informações, consulte Driver NVIDIA DRA para GPUs.
Verifique se o Helm está instalado no ambiente de desenvolvimento. O Helm vem pré-instalado no Cloud Shell.
Embora não haja um requisito específico de versão do Helm, você pode usar o comando abaixo para verificar se o Helm está instalado.
helm versionSe a saída for semelhante a
Command helm not found, instale a CLI do Helm:curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/master/scripts/get-helm-3 \ && chmod 700 get_helm.sh \ && ./get_helm.shAdicione o repositório do Helm da NVIDIA:
helm repo add nvidia https://helm.ngc.nvidia.com/nvidia \ && helm repo updateCrie um objeto
ResourceQuotapara o driver da DRA:export POD_QUOTA=POD_QUOTA kubectl create ns nvidia-dra-driver-gpu kubectl apply -n nvidia-dra-driver-gpu -f - << EOF apiVersion: v1 kind: ResourceQuota metadata: name: nvidia-dra-driver-gpu-quota spec: hard: pods: ${POD_QUOTA} scopeSelector: matchExpressions: - operator: In scopeName: PriorityClass values: - system-node-critical - system-cluster-critical EOFSubstitua
POD_QUOTApor um número pelo menos duas vezes maior que o número de nós A4X Max no cluster mais 1. Por exemplo, você precisa definir a variável como pelo menos 37 se tiver 18 nós A4X Max no cluster.Instale o CRD ComputeDomain e o driver DRA:
helm install nvidia-dra-driver-gpu nvidia/nvidia-dra-driver-gpu \ --set controller.args.v=4 --set kubeletPlugin.args.v=4 \ --version="25.8.0" \ --create-namespace \ --namespace nvidia-dra-driver-gpu \ -f <(cat <<EOF nvidiaDriverRoot: /home/kubernetes/bin/nvidia resources: gpus: enabled: false controller: affinity: nodeAffinity: requiredDuringSchedulingIgnoredDuringExecution: nodeSelectorTerms: - matchExpressions: - key: "nvidia.com/gpu" operator: "DoesNotExist" kubeletPlugin: affinity: nodeAffinity: requiredDuringSchedulingIgnoredDuringExecution: nodeSelectorTerms: - matchExpressions: - key: cloud.google.com/gke-accelerator operator: In values: - nvidia-gb300 - key: kubernetes.io/arch operator: In values: - arm64 tolerations: - key: nvidia.com/gpu operator: Equal value: present effect: NoSchedule - key: kubernetes.io/arch operator: Equal value: arm64 effect: NoSchedule EOF )
Configurar o manifesto da carga de trabalho para RDMA e domínio IMEX
Adicione uma regra de afinidade de nó para programar a carga de trabalho em nós do Arm:
spec: affinity: nodeAffinity: requiredDuringSchedulingIgnoredDuringExecution: nodeSelectorTerms: - matchExpressions: - key: kubernetes.io/arch operator: In values: - arm64Adicione o seguinte volume à especificação do pod:
spec: volumes: - name: library-dir-host hostPath: path: /home/kubernetes/bin/nvidiaAdicione as seguintes montagens de volume, variável de ambiente e recurso ao contêiner que solicita GPUs. O contêiner da carga de trabalho precisa solicitar todas as quatro GPUs:
containers: - name: my-container volumeMounts: - name: library-dir-host mountPath: /usr/local/nvidia env: - name: LD_LIBRARY_PATH value: /usr/local/nvidia/lib64 resources: limits: nvidia.com/gpu: 4Crie o recurso
ComputeDomainpara a carga de trabalho:apiVersion: resource.nvidia.com/v1beta1 kind: ComputeDomain metadata: name: a4x-max-compute-domain spec: numNodes: NUM_NODES channel: resourceClaimTemplate: name: a4x-max-compute-domain-channelSubstitua
NUM_NODESpelo número de nós que a carga de trabalho exige.Crie um ResourceClaimTemplate para alocar recursos de rede usando DRANET e solicite dispositivos RDMA para seu pod:
apiVersion: resource.k8s.io/v1 kind: ResourceClaimTemplate metadata: name: all-mrdma spec: spec: devices: requests: - name: req-mrdma exactly: deviceClassName: mrdma.google.com allocationMode: ExactCount count: 8Especifique o ResourceClaimTemplate usado pelo pod:
spec: ... volumes: ... containers: - name: my-container ... resources: limits: nvidia.com/gpu: 4 claims: - name: compute-domain-channel - name: rdma ... resourceClaims: - name: compute-domain-channel resourceClaimTemplateName: a4x-max-compute-domain-channel - name: rdma resourceClaimTemplateName: all-mrdmaVerifique se as bibliotecas do espaço do usuário e os pacotes libnccl estão instalados na imagem do contêiner do usuário:
apt update -y apt install -y curl export DOCA_URL="https://linux.mellanox.com/public/repo/doca/3.1.0/ubuntu22.04/arm64-sbsa/" BASE_URL=$([ "${DOCA_PREPUBLISH:-false}" = "true" ] && echo https://doca-repo-prod.nvidia.com/public/repo/doca || echo https://linux.mellanox.com/public/repo/doca) DOCA_SUFFIX=${DOCA_URL#*public/repo/doca/}; DOCA_URL="$BASE_URL/$DOCA_SUFFIX" curl $BASE_URL/GPG-KEY-Mellanox.pub | gpg --dearmor > /etc/apt/trusted.gpg.d/GPG-KEY-Mellanox.pub echo "deb [signed-by=/etc/apt/trusted.gpg.d/GPG-KEY-Mellanox.pub] $DOCA_URL ./" > /etc/apt/sources.list.d/doca.list apt update apt -y install doca-ofed-userspace # The installed libnccl2 is 2.27.7, to upgrade to 2.28.9 as we recommend apt install --only-upgrade --allow-change-held-packages -y libnccl2 libnccl-dev
Uma especificação de pod completa tem esta aparência:
apiVersion: resource.nvidia.com/v1beta1
kind: ComputeDomain
metadata:
name: a4x-max-compute-domain
spec:
numNodes: NUM_NODES
channel:
resourceClaimTemplate:
name: a4x-max-compute-domain-channel
---
apiVersion: apps/v1
kind: Pod
metadata:
name: my-pod
labels:
k8s-app: my-pod
spec:
...
affinity:
nodeAffinity:
requiredDuringSchedulingIgnoredDuringExecution:
nodeSelectorTerms:
- matchExpressions:
- key: kubernetes.io/arch
operator: In
values:
- arm64
volumes:
- name: library-dir-host
hostPath:
path: /home/kubernetes/bin/nvidia
hostNetwork: true
containers:
- name: my-container
volumeMounts:
- name: library-dir-host
mountPath: /usr/local/nvidia
env:
- name: LD_LIBRARY_PATH
value: /usr/local/nvidia/lib64
resources:
limits:
nvidia.com/gpu: 4
claims:
- name: compute-domain-channel
- name: rdma
...
resourceClaims:
- name: compute-domain-channel
resourceClaimTemplateName: a4x-max-compute-domain-channel
- name: rdma
resourceClaimTemplateName: all-mrdma
Testar o desempenho da rede
Recomendamos que você valide a funcionalidade dos clusters provisionados. Para isso, use os testes NCCL/gIB, que são testes da NVIDIA Collective Communications Library (NCCL) otimizados para o ambiente do Google.
Para mais informações, consulte Executar o NCCL em clusters personalizados do GKE que usam o A4X Max.
A seguir
- Para saber como agendar cargas de trabalho nos clusters do GKE usando o TAS e o Kueue, consulte Agendar cargas de trabalho do GKE com o Agendamento com reconhecimento de topologia.
- Para saber como gerenciar eventos comuns relevantes para clusters do GKE e cargas de trabalho de IA, consulte Gerenciar clusters do GKE otimizados para IA.