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

Questo documento spiega come eseguire carichi di lavoro di computing ad alte prestazioni (HPC) su cluster Google Kubernetes Engine (GKE) che utilizzano la serie di macchine H4D e l'accesso diretto alla memoria remoto (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 ridotti e scalabilità. H4D funziona bene per le applicazioni che scalano su più nodi. Le istanze H4D configurate per utilizzare 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 operazioni:

  • Attiva l'API Google Kubernetes Engine.
    • Attiva 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 comando gcloud components update. 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 associate a una prenotazione. Le istruzioni di Cluster Toolkit in questa sezione utilizzano il blueprint GKE H4D.

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

Cluster Toolkit

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

  2. Ottieni l'indirizzo IP della macchina host in 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 ID progetto Google Cloud .
    • COMPUTE_REGION_TERRAFORM_STATE: la regione di Compute in cui vuoi memorizzare lo stato del deployment Terraform.

  4. Nel progetto base examples/gke-h4d/gke-h4d-deployment.yaml dal repository GitHub, inserisci le seguenti impostazioni nelle sezioni terraform_backend_defaults e vars in modo che corrispondano ai valori specifici per la tua implementazione:

    • DEPLOYMENT_NAME: un nome univoco per il deployment, che deve essere compreso tra 6 e 30 caratteri. Se il nome del deployment non è univoco all'interno di un progetto, la creazione del cluster non va a buon fine. Il valore predefinito è gke-h4d.
    • BUCKET_NAME: il nome del bucket Cloud Storage creato nel passaggio precedente.
    • PROJECT_ID: il tuo ID progetto Google Cloud .
    • COMPUTE_REGION: la regione di calcolo per il cluster, che deve corrispondere alla regione in cui le macchine sono disponibili per la prenotazione.
    • COMPUTE_ZONE: la zona di computing del pool di nodi di macchine H4D. Tieni presente che questa zona deve corrispondere a quella 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.

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

      • Per posizionare 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 tua 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 questo comando:

    gcloud auth application-default login

  6. Esegui il deployment del blueprint 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 Applica per eseguire il deployment del blueprint.

  8. Inoltre, questo blueprint esegue il provisioning di un'istanza Filestore e la connette al cluster GKE con un volume permanente (PV). In questo blueprint è incluso un modello di job di esempio. Questo modello esegue un job parallelo che legge e scrive dati in questo spazio di archiviazione condiviso. Un kubectl create viene visualizzato negli output del deployment e 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 posizione 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 disponibilità H4D. Se utilizzi una prenotazione, la regione e la zona devono corrispondere a quelle 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 a quelle della prenotazione. Non puoi creare un node pool multi-zona se vuoi che i nodi H4D funzionino con Cloud RDMA.
  • RDMA_NETWORK_PREFIX: il prefisso di 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 tuo 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 una rete VPC e una subnet dedicate. 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 over 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. Se vuoi, con questo comando puoi fornire esplicitamente 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 nodi H4D associati a prenotazioni e posizionamento compatto. In alternativa, puoi utilizzare i nodi H4D di cui è stato eseguito il provisioning con l'avvio flessibile. Seleziona la scheda che corrisponde all'opzione di consumo:

    Con prenotazione

    1. Crea una policy delle risorse per il posizionamento compatto. Il posizionamento compatto ottimizza le prestazioni per i workload HPC ad accoppiamento stretto, che vengono eseguiti su più nodi, garantendo che i nodi siano fisicamente posizionati 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 del criterio della risorsa (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 essere non disponibili contemporaneamente durante un upgrade del pool di nodi. Per il posizionamento compatto, consigliamo aggiornamenti rapidi senza picchi per ottimizzare la probabilità di trovare nodi collocati insieme durante gli aggiornamenti.

    Avvio flessibile

    Crea un pool di nodi che utilizzi nodi H4D di cui è stato eseguito il provisioning con flex-start e che si connetta 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 a cui scalare automaticamente per il 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.

Configurare i manifest per RDMA

Attiva 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"},
      ]

Testare RDMA con rping

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

  1. Nel pod del 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 del server.

    Se l'operazione va a buon fine, l'output è 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