Executar cargas de trabalho de computação de alto desempenho (HPC) com o H4D

Este documento explica como executar cargas de trabalho de computação de alta performance (HPC) em clusters do Google Kubernetes Engine (GKE) que usam a série de máquinas H4D e o acesso direto à memória remota (RDMA).

O H4D é uma série de máquinas na família de máquinas otimizada para HPC do Compute Engine. A série de máquinas é otimizada para alto desempenho, baixo custo e escalonabilidade. O H4D funciona bem para aplicativos que escalonam em vários nós. As instâncias H4D configuradas para usar RDMA oferecem suporte a até 200 Gbps de largura de banda de rede entre nós.

As instruções nesta página usam a Google Cloud CLI e oferecem a máxima flexibilidade na configuração do ambiente de cluster. Como alternativa, use o Cluster Toolkit para criar rapidamente um cluster do GKE pronto para produção que usa o H4D. Para mais informações, consulte o blueprint do GKE H4D.

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 gcloud components update.
  • Use o modo de provisionamento de início flexível para receber VMs H4D. Se você precisar de recursos por mais de 90 dias ou mais de 256 VMs H4D em uma solicitação, entre em contato com sua equipe de conta. Também é possível provisionar VMs H4D sob demanda, sujeitas à capacidade disponível na sua região.
  • Use a versão 1.32.6-gke.1060000 ou mais recente do GKE para criar um pool de nós com VMs H4D reservadas no modo GKE Standard.

  • Use a versão 1.33.2-gke.4731000 ou mais recente do GKE para criar o seguinte:

  • Use apenas locais em que o tipo de máquina H4D está disponível. Para mais informações, consulte a tabela em Regiões e zonas disponíveis, filtrando por H4D.

  • Use apenas imagens de nó do Container-Optimized OS.

  • Confira as limitações do H4D.

  • Revise como lidar com a manutenção do host, porque os tipos de máquina H4D não são compatíveis com a migração em tempo real. Para mais informações, consulte Experiência de manutenção para instâncias H4D.

  • Substitua os seguintes valores nos comandos das próximas seções:

    • PROJECT_ID: o ID do projetoGoogle Cloud .
    • CLUSTER_NAME: o nome do cluster.
    • CONTROL_PLANE_LOCATION: o local do Compute Engine do plano de controle do cluster. Forneça uma região para clusters regionais ou uma zona para clusters zonais. Os clusters regionais são recomendados para cargas de trabalho de produção. Para clusters regionais, a região precisa incluir uma zona em que o H4D esteja disponível. Para clusters zonais, a zona precisa ter disponibilidade de H4D.
    • COMPUTE_ZONE: a zona do pool de nós. Precisa ser uma zona em que o H4D esteja disponível. Não é possível criar um pool de nós de várias zonas se você quiser que os nós H4D funcionem com RDMA.
    • RDMA_NETWORK_PREFIX: o prefixo da rede RDMA (por exemplo, h4d-rdma).
    • RDMA_SUBNET_CIDR: o intervalo CIDR da sub-rede RDMA. Verifique se esse intervalo não se sobrepõe às redes padrão do cluster.
    • NODE_POOL_NAME: o nome do pool de nós H4D.
    • NODE_COUNT: o número de nós H4D a serem criados no pool de nós.
    • H4D_MACHINE_TYPE: o tipo de máquina H4D a ser usado (por exemplo, h4d-highmem-192-lssd).

Criar VPCs e sub-redes

Configure a nuvem privada virtual (VPC) e a sub-rede padrão do cluster. Para a placa de interface de rede (NIC) RDMA, crie uma VPC e uma sub-rede dedicadas. A VPC criada com as instruções a seguir usa, conforme necessário, um perfil de rede RDMA.

  1. Crie uma VPC de HPC para as NICs de RDMA:

    gcloud compute --project=PROJECT_ID \
  networks create RDMA_NETWORK_PREFIX-net \
  --network-profile=COMPUTE_ZONE-vpc-falcon \
  --subnet-mode=custom

  2. Crie uma sub-rede para a rede RDMA:

    gcloud compute --project=PROJECT_ID \
  networks subnets create \
  RDMA_NETWORK_PREFIX-sub-0 \
  --network=RDMA_NETWORK_PREFIX-net \
  --region=CONTROL_PLANE_LOCATION \
  --range=RDMA_SUBNET_CIDR

Criar um cluster do GKE com várias redes

Crie o cluster do GKE com várias redes ativadas. Se quiser, com esse comando, você pode fornecer explicitamente os intervalos CIDR secundários para serviços e pods.

Execute este comando:

gcloud container clusters create CLUSTER_NAME --project PROJECT_ID \
  --enable-dataplane-v2 --enable-ip-alias --location=CONTROL_PLANE_LOCATION \
  --enable-multi-networking \
  [--services-ipv4-cidr=SERVICE_CIDR \
  --cluster-ipv4-cidr=POD_CIDR]

Se você usar essas flags opcionais, substitua os seguintes valores adicionais:

  • 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, SERVICE_CIDR=10.65.0.0/19 e POD_CIDR=10.64.0.0/19.

Criar objetos de rede do GKE

Configure a rede VPC usando conjuntos de parâmetros de rede do GKE. Aplique os objetos GKENetworkParamSet e Network:

kubectl apply -f - <<EOF
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
EOF

Criar um pool de nós H4D

Crie um pool de nós que use H4D e se conecte à rede RDMA. É possível usar nós H4D vinculados a reservas e posicionamento compacto. Ou use nós H4D provisionados com início flexível. Selecione a guia que corresponde à sua opção de consumo:

Vinculada à reserva

  1. Crie uma política de recursos para posicionamento compacto. O posicionamento compacto otimiza o desempenho para cargas de trabalho de HPC com acoplamento rígido, que são executadas em vários nós, garantindo que eles estejam localizados fisicamente uns em relação aos outros em uma zona.

    Execute este comando:

    gcloud compute resource-policies create group-placement POLICY_NAME \
    --region REGION --collocation collocated

    Substitua os seguintes valores:

    • POLICY_NAME: o nome da política de recursos (por exemplo, h4d-compact).
    • REGION: a região do cluster.

  2. Crie um pool de nós que use H4D e se conecte à rede RDMA:

    gcloud container node-pools create NODE_POOL_NAME --project PROJECT_ID \
  --location=CONTROL_PLANE_LOCATION --cluster CLUSTER_NAME --num-nodes=NODE_COUNT \
  --node-locations=COMPUTE_ZONE \
  --machine-type H4D_MACHINE_TYPE \
  --additional-node-network network=RDMA_NETWORK_PREFIX-net,subnetwork=RDMA_NETWORK_PREFIX-sub-0 \
  --placement-policy POLICY_NAME \
  --max-surge-upgrade 0  \
  --max-unavailable-upgrade MAX_UNAVAILABLE

    Substitua MAX_UNAVAILABLE pelo número máximo de nós que podem estar indisponíveis ao mesmo tempo durante um upgrade do pool de nós. Para posicionamento compacto, recomendamos upgrades rápidos sem sobrecarga para otimizar a probabilidade de encontrar nós colocados durante os upgrades.

Início flexível

Crie um pool de nós que use nós H4D provisionados com flex-start e se conecte à rede RDMA:

gcloud container node-pools create NODE_POOL_NAME --project PROJECT_ID \
    --location=CONTROL_PLANE_LOCATION --cluster CLUSTER_NAME \
    --node-locations=COMPUTE_ZONE \
    --machine-type H4D_MACHINE_TYPE \
    --additional-node-network network=RDMA_NETWORK_PREFIX-net,subnetwork=RDMA_NETWORK_PREFIX-sub-0 \
    --flex-start --enable-autoscaling --reservation-affinity=none \
    --min-nodes=0 --max-nodes=MAX_NODES --num-nodes=0

Substitua MAX_NODES pelo número máximo de nós a serem escalonados automaticamente para o pool de nós especificado por zona.

Preparar a imagem do Docker

Prepare sua imagem usando o exemplo de Dockerfile a seguir:

FROM rockylinux:8.9

RUN dnf install https://depot.ciq.com/public/files/gce-accelerator/irdma-kernel-modules-el8-x86_64/irdma-repos.rpm -y

RUN dnf install rdma-core libibverbs-utils librdmacm-utils infiniband-diags perftest -y
Prática recomendada:

O Rocky 8 é a imagem recomendada baseada em contêineres que oferece suporte ao RDMA. O driver iRDMA ainda não está disponível em outras distribuições do Linux.

Configurar seus manifestos para RDMA

Para ativar o RDMA, adicione as seguintes anotações aos metadados do pod:

metadata:
  annotations:
    networking.gke.io/default-interface: 'eth0'
    networking.gke.io/interfaces: |
      [
        {"interfaceName":"eth0","network":"default"},
        {"interfaceName":"eth1","network":"rdma-0"},
      ]

Testar RDMA com rping

Verifique a funcionalidade do RDMA executando rping entre um pod de servidor e um de cliente:

  1. No pod do servidor, execute o comando rping:

    rping -s

  2. No pod do cliente, execute o comando rping:

    rping -c -C 2 -d -a SERVER_IP

    Substitua SERVER_IP pelo endereço IP do pod do servidor.

    Se a operação for bem-sucedida, a saída será semelhante a esta:

    created cm_id 0x5b597bf94800
cma_event type RDMA_CM_EVENT_ADDR_RESOLVED cma_id 0x5b597bf94800 (parent)
cma_event type RDMA_CM_EVENT_ROUTE_RESOLVED cma_id 0x5b597bf94800 (parent)
rdma_resolve_addr - rdma_resolve_route successful
created pd 0x5b597bf94fa0
created channel 0x5b597bf96830
created cq 0x5b597bf94ff0
created qp 0x5b597bf96c00
rping_setup_buffers called on cb 0x5b597bf8c820
allocated & registered buffers...
cq_thread started.
cma_event type RDMA_CM_EVENT_ESTABLISHED cma_id 0x5b597bf94800 (parent)
ESTABLISHED
rdma_connect successful
RDMA addr 5b597bf8cd80 rkey dadac8c4 len 64
send completion
recv completion
RDMA addr 5b597bf8cff0 rkey 86ef015f len 64
send completion
recv completion
RDMA addr 5b597bf8cd80 rkey dadac8c4 len 64
send completion
recv completion
RDMA addr 5b597bf8cff0 rkey 86ef015f len 64
send completion
recv completion
rping_free_buffers called on cb 0x5b597bf8c820
destroy cm_id 0x5b597bf94800

A seguir