Criar um cluster personalizado do GKE otimizado para IA que usa A4 ou A3 Ultra

Nesta página, mostramos como criar um cluster do Google Kubernetes Engine (GKE) otimizado para IA que usa máquinas virtuais (VMs) A4 ou A3 Ultra para oferecer suporte às suas cargas de trabalho de IA e ML. Para o A4X, consulte Criar um cluster do GKE personalizado otimizado para IA que usa o A4X.

As séries de máquinas A4 e A3 Ultra foram projetadas para permitir executar clusters de IA/ML em grande escala com recursos como posicionamento de carga de trabalho direcionado, controles avançados de manutenção de cluster e programação com reconhecimento de topologia. Para mais informações, consulte Visão geral do gerenciamento de clusters.

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, disponibilização de aplicativos e serviços de suporte.

Nesta página, você vai aprender a criar um cluster do GKE com a Google Cloud CLI para ter a máxima flexibilidade na configuração do cluster com base nas necessidades da sua carga de trabalho. 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 instruções sobre como fazer isso, consulte Criar um cluster do GKE otimizado para IA com a configuração padrão.

Opções de configuração de cluster com GPUDirect RDMA

Para criar seu cluster com a Google Cloud CLI, escolha uma das seguintes opções de configuração:

• Se você não planeja executar cargas de trabalho de IA distribuídas: crie um cluster do GKE sem usar o GPUDirect RDMA.
• Se você planeja executar cargas de trabalho de IA distribuídas: crie um cluster do GKE com RDMA do GPUDirect.

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.
  Observação: em instalações prévias da gcloud CLI, defina a propriedade compute/region. Se você usa principalmente clusters zonais, defina compute/zone. Ao definir um local padrão, é possível evitar erros na gcloud CLI como: One of [--zone, --region] must be supplied: Please specify location. Talvez seja necessário especificar o local em determinados comandos se o local do cluster for diferente do padrão definido.

Funções exigidas

Para receber as permissões necessárias para criar e gerenciar um cluster do GKE, peça ao administrador para conceder a você os seguintes papéis do IAM no projeto:

• Administrador do Kubernetes Engine (roles/container.admin)
• Editor do Cloud Build (roles/cloudbuild.builds.editor)
• Administrador do Compute (roles/compute.admin)
• Administrador de projetos do IAM (roles/resourcemanager.projectIamAdmin)
• Administrador da conta de serviço (roles/iam.serviceAccountAdmin)
• Usuário da conta de serviço (roles/iam.serviceAccountUser)
• Consumidor do Service Usage (roles/serviceusage.serviceUsageConsumer)
• Administrador de armazenamento (roles/storage.admin)

Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Também é possível conseguir as permissões necessárias usando papéis personalizados ou outros papéis predefinidos.

Escolher uma opção de consumo e obter capacidade

1. Escolha uma opção de consumo. Faça sua escolha com base em como você quer receber e usar recursos de GPU. Para mais informações, consulte Escolher uma opção de consumo.

   Para o GKE, considere as seguintes informações adicionais ao escolher uma opção de consumo:

   • Para mais informações sobre o início flexível (prévia) e o GKE, consulte Sobre a disponibilidade de GPU com início flexível.
   • O início flexível usa a melhor colocação compacta possível. Para examinar sua topologia, consulte Ver a topologia física dos nós no cluster do GKE.
   • Só é possível receber informações de topologia ao usar VMs do Spot se você configurar o posicionamento compacto.

2. Obter capacidade. Saiba como adquirir capacidade para sua opção de consumo.

Requisitos

Os seguintes requisitos se aplicam a um cluster do GKE otimizado para IA:

• Para usar o modelo de provisionamento de início flexível, é necessário usar o GKE versão 1.32.2-gke.1652000 ou mais recente.

• Use a versão mínima do driver de GPU, dependendo do tipo de máquina:

  • A4: as GPUs B200 em VMs A4 exigem uma versão mínima do driver de GPU R570. Por padrão, o GKE instala automaticamente essa versão do driver em todos os nós A4 que executam a versão mínima necessária para A4, que é 1.32.1-gke.1729000 ou mais recente.
  • A3 Ultra: as GPUs H200 em VMs A3 Ultra exigem no mínimo a versão R550 do driver de GPU, que está disponível no GKE versão 1.31 como a versão do driver latest. Para VMs A3 Ultra, é necessário definir o valor do campo gpu-driver-version=latest com a versão 1.31 do GKE. Para o GKE versão 1.31.5-gke.1169000 ou mais recente, o GKE instala automaticamente versões do driver de GPU R550 em nós A3 Ultra por padrão, inclusive quando você omite a flag gpu-driver-version.

• Para usar o GPUDirect RDMA, os seguintes requisitos adicionais se aplicam:

  • Use as seguintes versões mínimas, dependendo do tipo de máquina:
    • A4: use a versão 1.32.2-gke.1475000 ou mais recente.
    • A3 Ultra: use a versão 1.31.4-gke.1183000 ou mais recente.
  • 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 seu pod precisa usar todas as placas de interface de rede (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.
  • Essa configuração executa um teste da NCCL. Para executar esse teste do NCCL, você precisa ter uma cota mínima de VM de 2 (ou seja, 16 GPUs se usar os tipos de máquina a4-highgpu-8g ou a3-ultragpu-8g).
  • O GPUDirect RDMA não é compatível com o NCCL Fast Socket ou o GPUDirect TCPX/TCPXO. Não ative o Fast Socket do NCCL nem instale o plug-in TCPX/TCPXO em clusters que usam o GPUDirect RDMA.

• Verifique se você está usando um local que tem disponibilidade para o tipo de máquina escolhido. Para mais informações, consulte Locais de GPU.

Criar um cluster do GKE otimizado para IA

Siga as instruções nesta seção para criar um cluster do GKE que atenda aos requisitos dos clusters do GKE otimizados para IA. É possível criar um cluster com ou sem GPUDirect RDMA.

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 Locais de GPU.
  • Para reservas densas, é possível criar um cluster zonal. Nesse caso, substitua a flag --region pela flag --zone=COMPUTE_ZONE, em que COMPUTE_ZONE é a zona do plano de controle.
  • Para cargas de trabalho executadas em mais de mil nós e que exigem baixa latência de rede entre eles, crie um cluster regional. Para fazer a colocalização física dos nós sensíveis à performance, crie os pools de nós de GPU em uma única zona usando a flag --node-locations.
• 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 Instalar manualmente os drivers de GPU NVIDIA.

• 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-affinity pode ter os valores specific ou any. 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 --reservation no seguinte formato:

    projects/PROJECT_ID/reservations/RESERVATION_NAME/reservationBlocks/BLOCK_NAME
    

    Substitua:

    • 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.
  Dica: se a reserva estiver no projeto atual, omita projects/PROJECT_ID/reservations/do valor da reserva.

Criar um cluster sem GPUDirect RDMA

Para criar um cluster sem GPUDirect RDMA, siga estas instruções para criar um cluster com um pool de nós padrão baseado em CPU e outros pools de nós com GPUs. Essa abordagem permite que o pool de nós padrão execute outros serviços.

1. Crie o cluster:

     gcloud container clusters create CLUSTER_NAME \
         --cluster-version=CLUSTER_VERSION \
         --region=COMPUTE_REGION
   

   Substitua:

   • CLUSTER_NAME: o nome do novo 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 a seção Requisitos.
   • COMPUTE_REGION: a região do novo cluster. Se você planeja criar um cluster zonal, use a flag --zone em vez de --region. Por exemplo: --zone=COMPUTE_ZONE. Substitua COMPUTE_ZONE pela zona do plano de controle.

2. Crie o pool de nós baseado em GPU com um dos seguintes comandos. O comando que você precisa executar depende da opção de consumo usada na implantação. Selecione a guia que corresponde ao modelo de provisionamento da sua opção de consumo.

   Vinculada à reserva

   Para o provisionamento vinculado à reserva, execute o seguinte comando:

     gcloud container node-pools create NODE_POOL_NAME \
         --region COMPUTE_REGION --cluster CLUSTER_NAME \
         --node-locations COMPUTE_ZONE \
         --accelerator type=GPU_TYPE,count=AMOUNT,gpu-driver-version=DRIVER_VERSION \
         --machine-type MACHINE_TYPE \
         --num-nodes=NUM_NODES \
         --reservation-affinity=specific \
         --reservation=RESERVATION_NAME/reservationBlocks/BLOCK_NAME
   

   Substitua:

   • NODE_POOL_NAME: o nome do pool de nós.
   • COMPUTE_REGION: a região do novo cluster.
   • CLUSTER_NAME: o nome do novo cluster;
   • COMPUTE_ZONE: a zona do pool de nós.

   • GPU_TYPE: o tipo de acelerador de GPU:

     • VMs A4: insira nvidia-b200.
     • VMs A3 Ultra: insira nvidia-h200-141gb.

   • AMOUNT: o número de GPUs que serão anexadas aos nós no pool de nós. Por exemplo, para VMs a4-highgpu-8g e a3-ultragpu-8g, a quantidade de GPUs é 8.

   • DRIVER_VERSION: a versão do driver NVIDIA a ser instalado. Ele pode ser um dos seguintes valores: default, latest ou disabled.

   • MACHINE_TYPE: o tipo de máquina do Compute Engine para os nós. Por exemplo, use a4-highgpu-8g para VMs A4 e a3-ultragpu-8g para VMs A3 Ultra.

   • NUM_NODES: o número de nós do pool de nós.

   • 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 na reserva. Para encontrar esse valor, consulte Ver solicitações de reserva adiantada.

   Início flexível

   Pré-lançamento

   Este produto ou recurso está sujeito aos "Termos das Soluções Pré-GA" na seção Termos Gerais de Serviço dos Termos Específicos de Serviço. Os produtos e recursos pré-GA estão disponíveis no estado em que se encontram e podem ter assistência limitada. Para mais informações, consulte as descrições das fases de lançamento.

   Para o provisionamento de início flexível, execute o seguinte comando:

     gcloud container node-pools create NODE_POOL_NAME \
         --region COMPUTE_REGION --cluster CLUSTER_NAME \
         --node-locations COMPUTE_ZONE \
         --accelerator type=GPU_TYPE,count=AMOUNT,gpu-driver-version=DRIVER_VERSION \
         --machine-type MACHINE_TYPE \
         --flex-start --enable-autoscaling --num-nodes=0 \
         --total-max-nodes TOTAL_MAX_NODES \
         --no-enable-autorepair --location-policy=ANY \
         --reservation-affinity=none [\
         --enable-queued-provisioning]
   

   Substitua:

   • NODE_POOL_NAME: o nome do pool de nós.
   • COMPUTE_REGION: a região do novo cluster.
   • CLUSTER_NAME: o nome do novo cluster;
   • COMPUTE_ZONE: a zona do pool de nós.

   • GPU_TYPE: o tipo de acelerador de GPU:

     • VMs A4: insira nvidia-b200.
     • VMs A3 Ultra: insira nvidia-h200-141gb.

   • AMOUNT: o número de GPUs que serão anexadas aos nós no pool de nós. Por exemplo, para VMs a4-highgpu-8g e a3-ultragpu-8g, a quantidade de GPUs é 8.

   • DRIVER_VERSION: a versão do driver NVIDIA a ser instalado. Ele pode ser um dos seguintes valores: default, latest ou disabled.

   • MACHINE_TYPE: o tipo de máquina do Compute Engine para os nós. Por exemplo, use a4-highgpu-8g para VMs A4 e a3-ultragpu-8g para VMs A3 Ultra.

   • TOTAL_MAX_NODES: o número máximo de nós a serem escalonados automaticamente para todo o pool de nós.

     Se você quiser usar "flex-start" com provisionamento em fila, inclua a flag --enable-queued-provisioning.

     Para mais informações sobre como usar o início flexível, consulte Executar uma carga de trabalho em grande escala com início flexível e provisionamento em fila.

   Spot

   Para o provisionamento spot, execute o seguinte comando:

     gcloud container node-pools create NODE_POOL_NAME \
         --region COMPUTE_REGION --cluster CLUSTER_NAME \
         --node-locations COMPUTE_ZONE \
         --accelerator type=GPU_TYPE,count=AMOUNT,gpu-driver-version=DRIVER_VERSION \
         --machine-type MACHINE_TYPE \
         --num-nodes=NUM_NODES \
         --spot
   

   Substitua:

   • NODE_POOL_NAME: o nome do pool de nós.
   • COMPUTE_REGION: a região do novo cluster.
   • CLUSTER_NAME: o nome do novo cluster;
   • COMPUTE_ZONE: a zona do pool de nós.

   • GPU_TYPE: o tipo de acelerador de GPU:

     • VMs A4: insira nvidia-b200.
     • VMs A3 Ultra: insira nvidia-h200-141gb.

   • AMOUNT: o número de GPUs que serão anexadas aos nós no pool de nós. Por exemplo, para VMs a4-highgpu-8g e a3-ultragpu-8g, a quantidade de GPUs é 8.

   • DRIVER_VERSION: a versão do driver NVIDIA a ser instalado. Ele pode ser um dos seguintes valores: default, latest ou disabled.

   • MACHINE_TYPE: o tipo de máquina do Compute Engine para os nós. Por exemplo, use a4-highgpu-8g para VMs A4 e a3-ultragpu-8g para VMs A3 Ultra.

   • NUM_NODES: o número de nós do pool de nós.

     Para mais informações sobre como criar clusters com VMs do Spot, consulte Executar cargas de trabalho tolerantes a falhas a custos mais baixos com VMs do Spot.

3. Conecte-se ao cluster para executar os comandos kubectl nas próximas seções:

     gcloud container clusters get-credentials CLUSTER_NAME --location=COMPUTE_REGION
   

   Substitua:

   • 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 um cluster com 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. As VMs A4 e A3 Ultra vêm com o adaptador de rede Titanium ML, que é criado em NICs NVIDIA ConnectX-7 (CX7). As VMs A4 e A3 Ultra oferecem 3,2 Tbps sem bloqueio de tráfego entre nós de GPU para GPU 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.

Para mais informações sobre como criar clusters do GKE usando a Google Cloud CLI e o GPUDirect TCPX (VMs A3 High) ou TCPXO (VMs A3 Mega), consulte maximizar a largura de banda da rede da GPU em clusters no modo Autopilot ou maximizar a largura de banda da rede da GPU em clusters no modo Standard.

Para criar clusters do GKE no modo Autopilot ou Standard com GPUDirect RDMA, siga as etapas descritas nas seções a seguir:

1. Criar VPCs e sub-redes
2. Criar o cluster do GKE com várias redes
3. Criar objetos de rede do GKE
4. Instalar o binário RDMA e configurar o NCCL
5. Implantar e executar um teste da NCCL
6. Configurar manifestos de pod para GPUDirect-RDMA

Criar VPCs e sub-redes

As VMs A4 e A3 Ultra têm a seguinte configuração:

• Oito GPUs NVIDIA B200 (A4) ou H200 (A3 Ultra) por máquina virtual conectadas com NVLink
• Duas CPUs Intel Emerald Rapids
• Oito NICs CX-7 de 400 Gbps para rede GPU para GPU
• Duas NICs Google Titanium de 200 Gbps para serviços externos

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 de jobs. 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, o que usa de maneira mais eficiente a largura de banda de rede disponível. O GPUDirect RDMA foi projetado para melhorar significativamente a capacidade de processamento em escala em comparação com GPUs que não usam GPUDirect.

Uma das NICs do Google Titanium associadas à CPU usa a rede padrão no GKE. Não é necessário criar uma nova VPC para essa NIC se você tiver intervalos de endereços IP suficientes para a rede padrão.

É possível criar uma VPC para a segunda NIC Titanium da CPU (gVNIC) e outra para as oito NICs CX-7 RDMA usando estes comandos.

1. Defina as variáveis de ambiente para corresponder à sua implantação:

   export REGION="COMPUTE_REGION"
   export ZONE="COMPUTE_ZONE"
   export PROJECT="PROJECT_ID"
   export GVNIC_NETWORK_PREFIX="GVNIC_NETWORK_PREFIX"
   export RDMA_NETWORK_PREFIX="RDMA_NETWORK_PREFIX"
   

   Substitua as seguintes variáveis:

   • COMPUTE_REGION: a região do cluster.
   • COMPUTE_ZONE: a zona do pool de nós.
   • PROJECT_ID: o ID do projeto Google Cloud .
   • GVNIC_NETWORK_PREFIX: a4high-gvnic para VMs A4 ou a3ultra-gvnic para VMs A3 Ultra.
   • RDMA_NETWORK_PREFIX: a4high-rdma para VMs A4 ou a3ultra-rdma para VMs A3 Ultra.

2. Crie duas redes VPC:

   # Create a VPC for the additional Google Titanium CPU NIC
   gcloud compute --project=${PROJECT} \
     networks create \
     ${GVNIC_NETWORK_PREFIX}-net \
     --subnet-mode=custom
   
   gcloud compute --project=${PROJECT} \
     networks subnets create \
     ${GVNIC_NETWORK_PREFIX}-sub \
     --network=${GVNIC_NETWORK_PREFIX}-net \
     --region=${REGION} \
     --range=192.168.0.0/24
   
   gcloud compute --project=${PROJECT} \
     firewall-rules create \
     ${GVNIC_NETWORK_PREFIX}-internal \
     --network=${GVNIC_NETWORK_PREFIX}-net \
     --action=ALLOW \
     --rules=tcp:0-65535,udp:0-65535,icmp \
     --source-ranges=192.168.0.0/16
   
   # Create HPC VPC for the RDMA NICs with 8 subnets.
   gcloud beta compute --project=${PROJECT} \
     networks create ${RDMA_NETWORK_PREFIX}-net \
     --network-profile=${ZONE}-vpc-roce \
     --subnet-mode=custom
   
   # Create subnets for the HPC VPC.
   for N in $(seq 0 7); do
     gcloud compute --project=${PROJECT} \
       networks subnets create \
       ${RDMA_NETWORK_PREFIX}-sub-$N \
       --network=${RDMA_NETWORK_PREFIX}-net \
       --region=${REGION} \
       --range=192.168.$((N+1)).0/24 &  # offset to avoid overlap with gvnics
   done
   

Criar o cluster do GKE com várias redes

Piloto automático

1. Criar um cluster do GKE Autopilot com várias redes:

   gcloud container clusters create-auto CLUSTER_NAME \
       --enable-multi-networking \
       --cluster-version=CLUSTER_VERSION \
       --region=COMPUTE_REGION
   

   Substitua:

   • CLUSTER_NAME: o nome do cluster.
   • CLUSTER_VERSION: a versão do novo cluster. Para saber qual versão do GKE é compatível com sua configuração, consulte a seção Requisitos.
   • COMPUTE_REGION: o nome da região de computação.

2. Conecte-se ao cluster para executar os comandos kubectl nas próximas seções:

   gcloud container clusters get-credentials CLUSTER_NAME --location=COMPUTE_REGION
   

   Substitua:

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

Padrão

Crie um cluster do GKE Standard e um pool de nós de GPU com várias redes:

1. Crie o cluster:

   gcloud container clusters create CLUSTER_NAME \
     --region=COMPUTE_REGION \
     --cluster-version=CLUSTER_VERSION \
     --enable-dataplane-v2 --enable-ip-alias --enable-multi-networking [\
     --services-ipv4-cidr=SERVICE_CIDR \
     --cluster-ipv4-cidr=POD_CIDR]
   

   Substitua:

   • CLUSTER_NAME: o nome do cluster.
   • CLUSTER_VERSION: a versão do novo cluster. Para saber qual versão do GKE é compatível com sua configuração, consulte a seção Requisitos.
   • 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, os intervalos nos valores SERVICE_CIDR=10.65.0.0/19 e POD_CIDR=10.64.0.0/19 não se sobrepõem. Para mais informações, consulte Adicionar intervalos de endereços IPv4 do pod.

2. Crie o pool de nós. O comando que você precisa executar depende da opção de consumo que você usa para sua implantação. Selecione a guia que corresponde ao modelo de provisionamento da sua opção de consumo.

   Vinculada à reserva

   Para o provisionamento vinculado à reserva, execute o seguinte comando:

   gcloud container node-pools create NODE_POOL_NAME \
     --region COMPUTE_REGION --cluster CLUSTER_NAME \
     --node-locations COMPUTE_ZONE \
     --accelerator type=GPU_TYPE,count=AMOUNT,gpu-driver-version=DRIVER_VERSION \
     --machine-type MACHINE_TYPE \
     --num-nodes=NUM_NODES \
     --reservation-affinity=specific \
     --reservation=RESERVATION_NAME/reservationBlocks/BLOCK_NAME  \
     --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
   

   Substitua:

   • NODE_POOL_NAME: o nome do pool de nós.
   • COMPUTE_REGION: a região do novo cluster.
   • CLUSTER_NAME: o nome do novo cluster;
   • COMPUTE_ZONE: a zona do pool de nós.

   • GPU_TYPE: o tipo de acelerador de GPU:

     • VMs A4: insira nvidia-b200.
     • VMs A3 Ultra: insira nvidia-h200-141gb.

   • AMOUNT: o número de GPUs que serão anexadas aos nós no pool de nós. Por exemplo, para VMs a4-highgpu-8g e a3-ultragpu-8g, a quantidade de GPUs é 8.

   • DRIVER_VERSION: a versão do driver NVIDIA a ser instalado. Ele pode ser um dos seguintes valores: default, latest ou disabled.

   • MACHINE_TYPE: o tipo de máquina do Compute Engine para os nós. Por exemplo, use a4-highgpu-8g para VMs A4 e a3-ultragpu-8g para VMs A3 Ultra.

   • MACHINE_TYPE: o tipo de máquina do Compute Engine para os nós. Por exemplo, use a4-highgpu-8g para VMs A4 e a3-ultragpu-8g para VMs A3 Ultra.

   • NUM_NODES: o número de nós do pool de nós. Para "flex-start", esse valor precisa ser definido como 0.

   • 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 na reserva. Para encontrar esse valor, consulte Ver solicitações de reserva adiantada.

   Início flexível

   Pré-lançamento

   Este produto ou recurso está sujeito aos "Termos das Soluções Pré-GA" na seção Termos Gerais de Serviço dos Termos Específicos de Serviço. Os produtos e recursos pré-GA estão disponíveis no estado em que se encontram e podem ter assistência limitada. Para mais informações, consulte as descrições das fases de lançamento.

   Para o provisionamento de início flexível, execute o seguinte comando:

   gcloud container node-pools create NODE_POOL_NAME \
     --region COMPUTE_REGION --cluster CLUSTER_NAME \
     --node-locations COMPUTE_ZONE \
     --accelerator type=GPU_TYPE,count=AMOUNT,gpu-driver-version=DRIVER_VERSION \
     --machine-type MACHINE_TYPE \
     --num-nodes=NUM_NODES \
     --flex-start --num-nodes=0 --enable-autoscaling \
     --total-max-nodes TOTAL_MAX_NODES \
     --no-enable-autorepair --location-policy=ANY \
     --reservation-affinity=none \
     [--enable-queued-provisioning \]
     --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
   

   Substitua:

   • NODE_POOL_NAME: o nome do pool de nós.
   • COMPUTE_REGION: a região do novo cluster.
   • CLUSTER_NAME: o nome do novo cluster;
   • COMPUTE_ZONE: a zona do pool de nós.

   • GPU_TYPE: o tipo de acelerador de GPU:

     • VMs A4: insira nvidia-b200.
     • VMs A3 Ultra: insira nvidia-h200-141gb.

   • AMOUNT: o número de GPUs que serão anexadas aos nós no pool de nós. Por exemplo, para VMs a4-highgpu-8g e a3-ultragpu-8g, a quantidade de GPUs é 8.

   • DRIVER_VERSION: a versão do driver NVIDIA a ser instalado. Ele pode ser um dos seguintes valores: default, latest ou disabled.

   • MACHINE_TYPE: o tipo de máquina do Compute Engine para os nós. Por exemplo, use a4-highgpu-8g para VMs A4 e a3-ultragpu-8g para VMs A3 Ultra.

   • MACHINE_TYPE: o tipo de máquina do Compute Engine para os nós. Por exemplo, use a4-highgpu-8g para VMs A4 e a3-ultragpu-8g para VMs A3 Ultra.

   • NUM_NODES: o número de nós do pool de nós. Para "flex-start", esse valor precisa ser definido como 0.

   • TOTAL_MAX_NODES: o número máximo de nós a serem escalonados automaticamente para todo o pool de nós.

   Se você quiser usar "flex-start" com provisionamento em fila, inclua a flag --enable-queued-provisioning.

   Para mais informações sobre como usar o início flexível, consulte Executar uma carga de trabalho em grande escala com início flexível e provisionamento em fila.

3. Conecte-se ao cluster para executar os comandos kubectl nas próximas seções:

   gcloud container clusters get-credentials CLUSTER_NAME --location=COMPUTE_REGION
   

   Substitua:

   • 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 os objetos de rede do GKE

As redes VPC criadas na seção anterior precisam ser configuradas com conjuntos de parâmetros de rede do GKE. Especificamente, a segunda NIC Titanium (gVNIC) da CPU precisa ser configurada no modo NetDevice, e cada uma das oito NICs RDMA CX-7 precisa ser configurada no modo RDMA.

Esse comando usa os seguintes nomes:

• A VPC da NIC Titanium da CPU (gVNIC) é chamada de ${GVNIC_NETWORK_PREFIX}-net com a sub-rede chamada ${GVNIC_NETWORK_PREFIX}-sub
• A VPC das NICs RDMA CX-7 é chamada de ${RDMA_NETWORK_PREFIX}-net com sub-redes chamadas ${RDMA_NETWORK_PREFIX}-sub-[0…7]

Crie os objetos de rede do GKE executando o seguinte comando:

kubectl apply -f - <<EOF
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: gvnic-1
spec:
  vpc: ${GVNIC_NETWORK_PREFIX}-net
  vpcSubnet: ${GVNIC_NETWORK_PREFIX}-sub
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: gvnic-1
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: gvnic-1
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-0
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-0
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-0
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-0
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-1
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-1
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-1
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-1
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-2
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-2
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-2
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-2
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-3
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-3
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-3
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-3
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-4
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-4
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-4
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-4
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-5
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-5
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-5
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-5
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-6
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-6
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-6
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-6
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-7
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-7
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-7
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-7
EOF

Instalar o binário RDMA e configurar o NCCL

Aplique o seguinte DaemonSet para instalar os binários do RDMA e a biblioteca NCCL em cada nó. Em cada VM subjacente, os binários RDMA são instalados no diretório /home/kubernetes/bin/gib, e a biblioteca NCCL é instalada no diretório /home/kubernetes/bin/nvidia/lib64.

Piloto automático

Para o modo Autopilot do GKE, execute o seguinte comando:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/refs/heads/master/gpudirect-rdma/nccl-rdma-installer-autopilot.yaml

Padrão

Para o modo Standard do GKE, execute o seguinte comando:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/refs/heads/master/gpudirect-rdma/nccl-rdma-installer.yaml

Executar testes da NCCL

Para validar a funcionalidade do cluster provisionado, execute um teste do NCCL. Para instruções, consulte Implantar e executar um teste do NCCL.

Configurar manifestos de pod para GPUDirect RDMA

Para executar suas cargas de trabalho usando o GPUDirect RDMA, configure os manifestos do pod com as seguintes etapas:

Observação:os arquivos de dispositivo RDMA são montados apenas no primeiro contêiner (não init) no pod. Se o pod tiver vários contêineres, verifique se o contêiner que exige acesso RDMA é o primeiro da lista.

1. Adicione as seguintes anotações aos metadados do pod.

   Piloto automático

   Use a seguinte anotação para o modo do Autopilot do GKE:

   metadata:
   annotations:
     networking.gke.io/default-interface: 'eth0'
     networking.gke.io/interfaces: |
       [
         {"interfaceName":"eth0","network":"default"},
         {"interfaceName":"eth1","network":"gvnic-1"},
         {"interfaceName":"eth2","network":"rdma-0"},
         {"interfaceName":"eth3","network":"rdma-1"},
         {"interfaceName":"eth4","network":"rdma-2"},
         {"interfaceName":"eth5","network":"rdma-3"},
         {"interfaceName":"eth6","network":"rdma-4"},
         {"interfaceName":"eth7","network":"rdma-5"},
         {"interfaceName":"eth8","network":"rdma-6"},
         {"interfaceName":"eth9","network":"rdma-7"}
       ]
   

   Padrão

   A anotação a seguir para o modo GKE Standard não inclui uma especificação degvnic-1, mas você pode adicioná-la se as cargas de trabalho exigirem.

   Use a seguinte anotação para o modo GKE Standard:

   metadata:
   annotations:
     networking.gke.io/default-interface: 'eth0'
     networking.gke.io/interfaces: |
       [
         {"interfaceName":"eth0","network":"default"},
         {"interfaceName":"eth2","network":"rdma-0"},
         {"interfaceName":"eth3","network":"rdma-1"},
         {"interfaceName":"eth4","network":"rdma-2"},
         {"interfaceName":"eth5","network":"rdma-3"},
         {"interfaceName":"eth6","network":"rdma-4"},
         {"interfaceName":"eth7","network":"rdma-5"},
         {"interfaceName":"eth8","network":"rdma-6"},
         {"interfaceName":"eth9","network":"rdma-7"}
       ]
   

2. Especifique o tipo de GPU escolhido e a reserva específica usando seletores de nós:

   spec:
     nodeSelector:
       cloud.google.com/gke-accelerator: ACCELERATOR
       cloud.google.com/reservation-name: RESERVATION_NAME
       cloud.google.com/reservation-affinity: "specific"
   

   Substitua:

   • ACCELERATOR: o acelerador que você reservou na reserva de capacidade do Compute Engine. Use um dos seguintes valores:
     • nvidia-b200: NVIDIA B200 (180 GB) para VMs A4
     • nvidia-h200-141gb: NVIDIA H200 (141 GB) para VMs A3 Ultra
   • RESERVATION_NAME: o nome da reserva de capacidade do Compute Engine.

   Para consumir reservas compartilhadas ou blocos e sub-blocos específicos de reservas, consulte as respectivas seções em Consumir recursos de caminho zonal reservados.

3. Adicione os seguintes volumes à especificação do pod:

   spec:
     volumes:
       - name: library-dir-host
         hostPath:
           path: /home/kubernetes/bin/nvidia
       - name: gib
         hostPath:
           path: /home/kubernetes/bin/gib
   

4. Adicione as seguintes montagens de volume, variáveis de ambiente e recursos ao contêiner que solicita GPUs. O contêiner da carga de trabalho precisa solicitar todas as oito GPUs:

   Piloto automático

   Para o modo Autopilot do GKE, configure os seguintes recursos:

   containers:
     - name: my-container
       volumeMounts:
         - name: library-dir-host
           mountPath: /usr/local/nvidia
           readOnly: true
         - name: gib
           mountPath: /usr/local/gib
           readOnly: true
       env:
         - name: LD_LIBRARY_PATH
           value: /usr/local/nvidia/lib64
       resources:
         limits:
           nvidia.com/gpu: 8
   

   Padrão

   Para o modo GKE Standard, configure os seguintes recursos:

   containers:
     - name: my-container
       volumeMounts:
         - name: library-dir-host
           mountPath: /usr/local/nvidia
         - name: gib
           mountPath: /usr/local/gib
       env:
         - name: LD_LIBRARY_PATH
           value: /usr/local/nvidia/lib64
       resources:
         limits:
           nvidia.com/gpu: 8
   

5. Defina todas as variáveis de ambiente necessárias para configurar o NCCL usando o seguinte script shell do contêiner de carga de trabalho:

   source /usr/local/gib/scripts/set_nccl_env.sh
   

As guias a seguir incluem exemplos de manifestos de pod concluídos.

Piloto automático

Para o modo Autopilot do GKE, um manifesto de pod concluído é semelhante a este:

apiVersion: apps/v1
kind: Pod
metadata:
  name: my-pod
  labels:
    k8s-app: my-pod
  annotations:
    networking.gke.io/default-interface: 'eth0'
    networking.gke.io/interfaces: |
      [
        {"interfaceName":"eth0","network":"default"},
        {"interfaceName":"eth1","network":"gvnic-1"},
        {"interfaceName":"eth2","network":"rdma-0"},
        {"interfaceName":"eth3","network":"rdma-1"},
        {"interfaceName":"eth4","network":"rdma-2"},
        {"interfaceName":"eth5","network":"rdma-3"},
        {"interfaceName":"eth6","network":"rdma-4"},
        {"interfaceName":"eth7","network":"rdma-5"},
        {"interfaceName":"eth8","network":"rdma-6"},
        {"interfaceName":"eth9","network":"rdma-7"}
      ]
spec:
  ...
  volumes:
    - name: library-dir-host
      hostPath:
        path: /home/kubernetes/bin/nvidia
    - name: gib
      hostPath:
        path: /home/kubernetes/bin/gib
  containers:
    - name: my-container
      volumeMounts:
        - name: library-dir-host
          mountPath: /usr/local/nvidia
          readOnly: true
        - name: gib
          mountPath: /usr/local/gib
          readOnly: true
      env:
        - name: LD_LIBRARY_PATH
          value: /usr/local/nvidia/lib64
      resources:
        limits:
          nvidia.com/gpu: 8
          ...

Padrão

No modo Standard do GKE, um manifesto de pod concluído é semelhante a este:

apiVersion: apps/v1
kind: Pod
metadata:
  name: my-pod
  labels:
    k8s-app: my-pod
  annotations:
    networking.gke.io/default-interface: 'eth0'
    networking.gke.io/interfaces: |
      [
        {"interfaceName":"eth0","network":"default"},
        {"interfaceName":"eth2","network":"rdma-0"},
        {"interfaceName":"eth3","network":"rdma-1"},
        {"interfaceName":"eth4","network":"rdma-2"},
        {"interfaceName":"eth5","network":"rdma-3"},
        {"interfaceName":"eth6","network":"rdma-4"},
        {"interfaceName":"eth7","network":"rdma-5"},
        {"interfaceName":"eth8","network":"rdma-6"},
        {"interfaceName":"eth9","network":"rdma-7"}
      ]
spec:
  ...
  volumes:
    - name: library-dir-host
      hostPath:
        path: /home/kubernetes/bin/nvidia
    - name: gib
      hostPath:
        path: /home/kubernetes/bin/gib
  containers:
    - name: my-container
      volumeMounts:
        - name: library-dir-host
          mountPath: /usr/local/nvidia
        - name: gib
          mountPath: /usr/local/gib
      env:
        - name: LD_LIBRARY_PATH
          value: /usr/local/nvidia/lib64
      resources:
        limits:
          nvidia.com/gpu: 8
          ...

Testar o desempenho da rede para clusters que usam o GPUDirect RDMA

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.

A seguir

• Para mais informações sobre como programar cargas de trabalho nos clusters do GKE usando o Agendamento com reconhecimento de topologia (TAS) e o Kueue, consulte Programar cargas de trabalho do GKE com o Agendamento com reconhecimento de topologia.
• Para mais informações sobre como gerenciar eventos comuns relevantes para clusters do GKE e cargas de trabalho de IA, consulte Gerenciar clusters do GKE otimizados para IA.
• Para informações sobre como testar seu ambiente para configuração e otimização adequadas, consulte Otimizar a rede de clusters usando NCCL/gIB.