Questa pagina è stata tradotta dall'API Cloud Translation.

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

Standard

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 l'HPC 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.

Le istruzioni riportate in questa pagina utilizzano Google Cloud CLI e ti consentono la massima flessibilità nella configurazione dell'ambiente cluster. In alternativa, puoi utilizzare Cluster Toolkit per creare rapidamente un cluster GKE pronto per la produzione che utilizza H4D. Per maggiori informazioni, consulta il progetto GKE H4D.

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 gcloud components update.
Nota:per le installazioni esistenti di gcloud CLI, assicurati di impostare la proprietà compute/region. Se utilizzi principalmente cluster di zona, imposta invece compute/zone. Se imposti una località predefinita, puoi evitare errori in gcloud CLI come il seguente: One of [--zone, --region] must be supplied: Please specify location. Potresti dover specificare la posizione in determinati comandi se la posizione del cluster è diversa da quella predefinita che hai impostato.

Utilizza la modalità di provisioning con avvio flessibile per ottenere VM H4D. In alternativa, se hai bisogno di risorse per più di 90 giorni o di più di 256 VM H4D in una richiesta, contatta il team dedicato al tuo account. Puoi anche eseguire il provisioning delle VM H4D on demand, in base alla capacità disponibile nella tua regione.
Utilizza GKE 1.32.6-gke.1060000 o versioni successive per creare un pool di nodi con VM H4D riservate in modalità GKE Standard.
Utilizza GKE 1.33.2-gke.4731000 o versioni successive per creare quanto segue:
- Nodi H4D con avvio flessibile
- Nodi H4D con Autopilot
- Nodi H4D con scalabilità automatica del cluster nei cluster Standard
- Nodi H4D con provisioning automatico dei nodi nei cluster Standard
Utilizza solo località in cui è disponibile il tipo di macchina H4D. Per ulteriori informazioni, consulta la tabella in Regioni e zone disponibili, filtrando per H4D.
Utilizza solo immagini nodo Container-Optimized OS.
Esamina le limitazioni di H4D.
Esamina come gestire la manutenzione dell'host, perché i tipi di macchine H4D non supportano la migrazione live. Per saperne di più, consulta Esperienza di manutenzione per le istanze H4D.
Sostituisci i seguenti valori per i comandi nelle sezioni successive:
- PROJECT_ID: il tuo Google Cloud ID progetto.
- CLUSTER_NAME: il nome del tuo 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 carichi di lavoro di produzione. Per i cluster regionali, la regione deve includere una zona in cui è disponibile H4D. Per i cluster a livello di zona, la zona deve avere disponibilità H4D.
- COMPUTE_ZONE: la zona del pool di nodi. Deve essere una zona in cui è disponibile H4D. Non puoi creare un pool di nodi multizona se vuoi che i nodi H4D funzionino con 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 VPC e subnet

Configura il Virtual Private Cloud (VPC) e la subnet predefiniti per il cluster. Per la scheda di interfaccia di rete (NIC) RDMA, crea una subnet e un VPC dedicati. La rete VPC creata con le seguenti istruzioni utilizza, se necessario, un profilo di rete RDMA.

Crea un VPC HPC per le NIC RDMA:

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

Crea una subnet per la rete 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

Crea un cluster GKE con networking multiplo

Crea il cluster GKE con il networking multiplo abilitato. (Facoltativo) 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.

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

Crea un pool di nodi H4D

Crea un pool di nodi che utilizza H4D e si connette alla rete RDMA. Puoi utilizzare nodi H4D associati a prenotazioni e posizionamento compatto. In alternativa, puoi utilizzare nodi H4D di cui è stato eseguito il provisioning con avvio flessibile. Seleziona la scheda corrispondente all'opzione di consumo:

Con prenotazione

Crea una policy delle risorse per il posizionamento compatto. Il posizionamento compatto ottimizza il rendimento per i workload HPC ad accoppiamento stretto, che vengono eseguiti su più nodi, garantendo 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 del criterio di risorsa (ad esempio, h4d-compact).
- REGION: la regione del cluster.

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

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

Best practice:

Rocky 8 è l'immagine basata su container consigliata che supporta RDMA. Il driver iRDMA potrebbe non essere ancora ampiamente disponibile in altre distribuzioni Linux.

Configurare i manifest per RDMA

Attiva 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à RDMA eseguendo rping tra un pod server e un pod client:

Nel pod del server, esegui il comando rping:
```
rping -s
```

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

Scopri di più sul computing ad alte prestazioni.
Alcuni workload HPC richiedono una Message Passing Interface (MPI) per eseguire workload multi-nodo strettamente accoppiati con RDMA. Per saperne di più sull'impostazione di MPI nel cluster per i nodi H4D, consulta Esegui carichi di lavoro MPI su GKE H4D.