Esegui workload di computing ad alte prestazioni (HPC) con H4D

Questo documento spiega come eseguire workload di computing ad alte prestazioni (HPC) sui cluster Google Kubernetes Engine (GKE) che utilizzano la serie di macchine H4D e l'accesso diretto alla memoria remota (RDMA).

H4D è una serie di macchine della famiglia di macchine ottimizzate per il calcolo per Compute Engine. La serie di macchine è ottimizzata per prestazioni elevate, costi contenuti e scalabilità. H4D è ideale per le applicazioni che scalano su più nodi. Le istanze H4D configurate per l'utilizzo di RDMA supportano una larghezza di banda di rete fino a 200 Gbps tra i nodi.

Prima di iniziare

Prima di iniziare, assicurati di aver eseguito le seguenti attività:

  • Abilita l'API Google Kubernetes Engine.
    • Abilita l'API Google Kubernetes Engine
  • Se vuoi utilizzare Google Cloud CLI per questa attività, installala e poi inizializza gcloud CLI. Se hai già installato gcloud CLI, scarica l'ultima versione eseguendo il gcloud components update comando. Le versioni precedenti di gcloud CLI potrebbero non supportare l'esecuzione dei comandi in questo documento.

Configura il cluster GKE e le reti

Puoi utilizzare Cluster Toolkit per creare rapidamente un cluster GKE pronto per la produzione che utilizza VM H4D con prenotazione. Le istruzioni di Cluster Toolkit in questa sezione utilizzano il progetto GKE H4D.

In alternativa, puoi utilizzare Google Cloud CLI per la massima flessibilità nella configurazione dell'ambiente cluster con VM con prenotazione o con avvio flessibile.

Cluster Toolkit

  1. Configura Cluster Toolkit. Ti consigliamo di utilizzare Cloud Shell perché le dipendenze sono già preinstallate per Cluster Toolkit.

  2. Recupera l'indirizzo IP della macchina host su cui hai installato Cluster Toolkit:

    curl ifconfig.me

    Salva questo indirizzo IP da utilizzare per la variabile IP_ADDRESS in un passaggio successivo.

  3. Crea un bucket Cloud Storage per archiviare lo stato del deployment di Terraform:

    gcloud storage buckets create gs://BUCKET_NAME \
    --default-storage-class=STANDARD \
    --project=PROJECT_ID \
    --location=COMPUTE_REGION_TERRAFORM_STATE \
    --uniform-bucket-level-access
gcloud storage buckets update gs://BUCKET_NAME --versioning

    Sostituisci le seguenti variabili:

    • BUCKET_NAME: il nome del nuovo bucket Cloud Storage.
    • PROJECT_ID: il tuo Google Cloud ID progetto.
    • COMPUTE_REGION_TERRAFORM_STATE: la regione di Compute in cui vuoi archiviare lo stato del deployment di Terraform.

  4. Nel progetto examples/gke-h4d/gke-h4d-deployment.yaml del repository GitHub, inserisci le seguenti impostazioni nelle sezioni terraform_backend_defaults e vars in modo che corrispondano ai valori specifici del tuo deployment:

    • DEPLOYMENT_NAME: un nome univoco per il deployment, che deve avere una lunghezza compresa tra 6 e 30 caratteri. Se il nome del deployment non è univoco all'interno di un progetto, la creazione del cluster non riesce. Il valore predefinito è gke-h4d.
    • BUCKET_NAME: il nome del bucket Cloud Storage che hai creato nel passaggio precedente.
    • PROJECT_ID: il tuo Google Cloud ID progetto.
    • COMPUTE_REGION: la regione di Compute per il cluster, che deve corrispondere alla regione in cui le macchine sono disponibili per la prenotazione.
    • COMPUTE_ZONE: la zona di computing per il node pool di macchine H4D. Tieni presente che questa zona deve corrispondere alla zona in cui le macchine sono disponibili nella prenotazione.
    • NODE_COUNT: il numero di nodi H4D nel cluster.
    • IP_ADDRESS/SUFFIX: l'intervallo di indirizzi IP a cui vuoi consentire di connettersi al cluster. Questo blocco CIDR deve includere l'indirizzo IP della macchina che vuoi utilizzare per chiamare Terraform. Per saperne di più, consulta Come funzionano le reti autorizzate lavorano.

    • Per il campo reservation, utilizza uno dei seguenti valori, a seconda che tu voglia scegliere come target blocchi specifici in una prenotazione durante il provisioning del pool di nodi:

      • Per inserire il pool di nodi in un punto qualsiasi della prenotazione, fornisci il nome della prenotazione (RESERVATION_NAME).

      • Per scegliere come target un blocco specifico all'interno della prenotazione, utilizza i nomi della prenotazione e del blocco nel seguente formato:

          RESERVATION_NAME/reservationBlocks/BLOCK_NAME

        Se non sai quali blocchi sono disponibili nella prenotazione, consulta Visualizzare la topologia di una prenotazione.

  5. Genera le Credenziali predefinite dell'applicazione (ADC) per fornire l'accesso a Terraform. Se utilizzi Cloud Shell, puoi eseguire il seguente comando:

    gcloud auth application-default login

  6. Esegui il deployment del progetto per eseguire il provisioning dell'infrastruttura GKE utilizzando i tipi di macchine H4D:

    ./gcluster deploy -d examples/gke-h4d/gke-h4d-deployment.yaml examples/gke-h4d/gke-h4d.yaml

  7. Quando richiesto, seleziona (A)pply per eseguire il deployment del progetto.

  8. Inoltre, questo progetto esegue il provisioning di un'istanza Filestore e la connette al cluster GKE con un volume permanente (PV). Questo progetto include un modello di job di esempio. Questo modello esegue un job parallelo che legge e scrive dati in questo spazio di archiviazione condiviso. Negli output del deployment viene visualizzato un comando kubectl create che può essere utilizzato per attivare il job di esempio.

Google Cloud CLI

Sostituisci i seguenti valori per i comandi in questa sezione:

  • PROJECT_ID: il tuo Google Cloud ID progetto.
  • CLUSTER_NAME: il nome del cluster.
  • CONTROL_PLANE_LOCATION: la località di Compute Engine del control plane del cluster. Fornisci una regione per i cluster regionali o una zona per i cluster zonali. I cluster regionali sono consigliati per i workload di produzione. Per i cluster regionali, la regione deve includere una zona in cui è disponibile H4D. Per i cluster zonali, la zona deve avere la disponibilità di H4D. Se utilizzi una prenotazione, la regione e la zona devono corrispondere alla regione e alla zona della prenotazione.
  • COMPUTE_ZONE: la zona del pool di nodi. Deve essere una zona in cui è disponibile H4D. Se utilizzi una prenotazione, la regione e la zona devono corrispondere alla regione e alla zona della prenotazione. Non puoi creare un node pool multizona se vuoi che i nodi H4D funzionino con Cloud RDMA.
  • RDMA_NETWORK_PREFIX: il prefisso della rete RDMA (ad esempio, h4d-rdma).
  • RDMA_SUBNET_CIDR: l'intervallo CIDR della subnet RDMA. Assicurati che questo intervallo non si sovrapponga alle reti predefinite del cluster.
  • NODE_POOL_NAME: il nome del pool di nodi H4D.
  • NODE_COUNT: il numero di nodi H4D da creare nel pool di nodi.
  • H4D_MACHINE_TYPE: il tipo di macchina H4D da utilizzare (ad esempio, h4d-highmem-192-lssd).

Crea un cluster con gcloud CLI seguendo questi passaggi:

  1. Crea VPC e subnet: configura il Virtual Private Cloud (VPC) e la subnet predefiniti per il cluster. Per la scheda di interfaccia di rete (NIC) IRDMA, crea un VPC e una subnet dedicati. Il VPC creato con le seguenti istruzioni utilizza, come richiesto, un profilo di rete VPC Falcon.

    1. Crea un VPC per l'interfaccia di rete IRDMA che utilizza il protocollo di trasporto RDMA su Falcon:

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

    2. Crea una subnet per la rete VPC Falcon:

      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

  2. Crea un cluster GKE con multi-networking: crea il cluster. Facoltativamente, con questo comando puoi fornire in modo esplicito gli intervalli CIDR secondari per servizi e pod.

    Esegui questo 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 utilizzi questi flag facoltativi, sostituisci i seguenti valori aggiuntivi:

    • SERVICE_CIDR: l'intervallo CIDR secondario per i servizi.
    • POD_CIDR: l'intervallo CIDR secondario per i pod.

    Quando utilizzi questi flag, verifica che gli intervalli CIDR non si sovrappongano agli intervalli di subnet per le reti di nodi aggiuntive. Ad esempio, SERVICE_CIDR=10.65.0.0/19 e POD_CIDR=10.64.0.0/19.

  3. Crea oggetti di rete GKE: configura la rete VPC utilizzando i set di parametri di rete GKE. Applica gli oggetti 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

  4. Crea un node pool H4D: crea un pool di nodi che utilizza H4D e si connette alla rete VPC Falcon. Puoi utilizzare i nodi H4D con prenotazione e il posizionamento compatto. In alternativa, puoi utilizzare i nodi H4D di cui è stato eseguito il provisioning con avvio flessibile. Seleziona la scheda corrispondente all'opzione di consumo:

    Con prenotazione

    1. Crea una policy di risorse per il posizionamento compatto. Il posizionamento compatto ottimizza le prestazioni per i workload HPC ad alto accoppiamento, che vengono eseguiti su più nodi, assicurando che i nodi siano posizionati fisicamente l'uno rispetto all'altro all'interno di una zona.

      Esegui questo comando:

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

      Sostituisci i seguenti valori:

      • POLICY_NAME: il nome della policy di risorse (ad esempio, h4d-compact).
      • REGION: la regione del cluster.

    2. Crea un pool di nodi che utilizza H4D e si connette alla rete 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

      Sostituisci MAX_UNAVAILABLE con il numero massimo di nodi che possono non essere disponibili contemporaneamente durante un upgrade del node pool. Per il posizionamento compatto, ti consigliamo di eseguire upgrade rapidi senza sovraccarico per ottimizzare la probabilità di trovare nodi in colocation durante gli upgrade.

    Avvio flessibile

    Crea un pool di nodi che utilizza i nodi H4D di cui è stato eseguito il provisioning con avvio flessibile e si connette alla rete VPC Falcon:

    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

    Sostituisci MAX_NODES con il numero massimo di nodi per la scalabilità automatica del pool di nodi specificato per zona.

Prepara l'immagine Docker

Prepara l'immagine utilizzando il seguente Dockerfile di esempio:

FROM docker.io/rockylinux/rockylinux:8.10

RUN dnf -y install https://depot.ciq.com/public/download/ciq-sigcloud-next-8/ciq-sigcloud-next-8.x86_64/Packages/c/ciq-sigcloud-next-release-6-1.el8_10.cld_next.noarch.rpm
    && dnf -y update ciq-sigcloud-next-release
    && dnf clean all

RUN dnf install rdma-core libibverbs-utils librdmacm-utils infiniband-diags perftest -y

Per saperne di più sulle immagini che supportano IRDMA, consulta le schede Interfacce nelle tabelle in Dettagli del sistema operativo.

Configura i manifest per RDMA

Abilita Cloud RDMA aggiungendo le seguenti annotazioni ai metadati del pod:

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

Testa RDMA con rping

Verifica la funzionalità di Cloud RDMA eseguendo rping tra un pod server e un pod client:

  1. Nel pod server, esegui il comando rping:

    rping -s

  2. Nel pod client, esegui il comando rping:

    rping -c -C 2 -d -a SERVER_IP

    Sostituisci SERVER_IP con l'indirizzo IP del pod server.

    Se l'operazione va a buon fine, l'output sarà simile al seguente:

    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

Passaggi successivi