Diese Seite wurde von der Cloud Translation API übersetzt.

HPC-Arbeitslasten (Hochleistungs-Computing) mit H4D ausführen

Standard

In diesem Dokument wird beschrieben, wie Sie HPC-Arbeitslasten (High Performance Computing) in Google Kubernetes Engine-Clustern (GKE) ausführen, die die H4D-Rechnerreihe und Remote Direct Memory Access (RDMA) verwenden.

H4D ist eine Maschinenserie in der für HPC optimierten Maschinenfamilie für Compute Engine. Die Maschinenserie ist für hohe Leistung, niedrige Kosten und Skalierbarkeit optimiert. H4D eignet sich gut für Anwendungen, die über mehrere Knoten hinweg skaliert werden. H4D-Instanzen, die für die Verwendung von RDMA konfiguriert sind, unterstützen eine Netzwerkbandbreite von bis zu 200 Gbit/s zwischen Knoten.

In der Anleitung auf dieser Seite wird die Google Cloud CLI verwendet. So haben Sie maximale Flexibilität bei der Konfiguration Ihrer Clusterumgebung. Alternativ können Sie mit dem Cluster Toolkit schnell einen produktionsreifen GKE-Cluster erstellen, der H4D verwendet. Weitere Informationen finden Sie im GKE H4D-Blueprint.

Hinweise

Führen Sie die folgenden Aufgaben aus, bevor Sie beginnen:

Aktivieren Sie die Google Kubernetes Engine API.

Google Kubernetes Engine API aktivieren

Wenn Sie die Google Cloud CLI für diesen Task verwenden möchten, müssen Sie die gcloud CLI installieren und dann initialisieren. Wenn Sie die gcloud CLI bereits installiert haben, rufen Sie die neueste Version mit gcloud components update ab.
Hinweis: Legen Sie für vorhandene Installationen der gcloud CLI das compute/region-Attribut fest. Wenn Sie hauptsächlich zonale Cluster verwenden, legen Sie stattdessen compute/zone fest. Wenn Sie einen standardmäßigen Speicherort festlegen, können Sie in der gcloud CLI Fehler wie diesen vermeiden: One of [--zone, --region] must be supplied: Please specify location. Bei bestimmten Befehlen müssen Sie möglicherweise den Speicherort angeben, wenn er sich von dem von Ihnen festgelegten Standard unterscheidet.

Verwenden Sie den Flex-Start-Bereitstellungsmodus, um H4D-VMs zu erhalten. Wenn Sie Ressourcen für mehr als 90 Tage oder mehr als 256 H4D-VMs in einer Anfrage benötigen, wenden Sie sich an Ihr Account-Management-Team. Sie können H4D-VMs auch bei Bedarf bereitstellen, sofern in Ihrer Region Kapazität verfügbar ist.
Verwenden Sie GKE-Version 1.32.6-gke.1060000 oder höher, um einen Knotenpool mit reservierten H4D-VMs im GKE-Standardmodus zu erstellen.
Verwenden Sie die GKE-Version 1.33.2-gke.4731000 oder höher, um Folgendes zu erstellen:
- H4D-Knoten mit Flex-Start
- H4D-Knoten mit Autopilot
- H4D-Knoten mit Cluster-Autoscaling in Standardclustern
- H4D-Knoten mit automatischer Knotenbereitstellung in Standardclustern
Verwenden Sie nur Standorte, an denen der H4D-Maschinentyp verfügbar ist. Weitere Informationen finden Sie in der Tabelle unter Verfügbare Regionen und Zonen. Filtern Sie nach H4D.
Verwenden Sie nur Knoten-Images für Container-Optimized OS.
Einschränkungen von H4D
Lesen Sie nach, wie Sie die Hostwartung handhaben, da H4D-Maschinentypen keine Live-Migration unterstützen. Weitere Informationen finden Sie unter Wartung von H4D-Instanzen.
Ersetzen Sie die folgenden Werte für die Befehle in den nächsten Abschnitten:
- PROJECT_ID: IhreGoogle Cloud -Projekt-ID.
- CLUSTER_NAME: Der Name Ihres Clusters.
- CONTROL_PLANE_LOCATION: der Compute Engine-Standort der Steuerungsebene Ihres Clusters. Geben Sie für regionale Cluster eine Region und für zonale Cluster eine Zone an. Regionale Cluster werden für Produktionsarbeitslasten empfohlen. Bei regionalen Clustern muss die Region eine Zone enthalten, in der H4D verfügbar ist. Bei zonalen Clustern muss die Zone H4D-Verfügbarkeit haben.
- COMPUTE_ZONE: Die Zone des Knotenpools. Dies muss eine Zone sein, in der H4D verfügbar ist. Sie können keinen Knotenpool mit mehreren Zonen erstellen, wenn die H4D-Knoten mit RDMA funktionieren sollen.
- RDMA_NETWORK_PREFIX: Das RDMA-Netzwerkpräfix, z. B. h4d-rdma.
- RDMA_SUBNET_CIDR: der CIDR-Bereich des RDMA-Subnetzes. Achten Sie darauf, dass sich dieser Bereich nicht mit den Standardnetzwerken des Clusters überschneidet.
- NODE_POOL_NAME: Der Name des H4D-Knotenpools.
- NODE_COUNT: Die Anzahl der H4D-Knoten, die im Knotenpool erstellt werden sollen.
- H4D_MACHINE_TYPE: Der zu verwendende H4D-Maschinentyp (z. B. h4d-highmem-192-lssd).

VPCs und Subnetze erstellen

Konfigurieren Sie die Standard-Virtual Private Cloud (VPC) und das Standardsubnetz für den Cluster. Erstellen Sie für die RDMA-Netzwerkschnittstellenkarte (NIC) eine dedizierte VPC und ein dediziertes Subnetz. Für die VPC, die mit der folgenden Anleitung erstellt wird, wird bei Bedarf ein RDMA-Netzwerkprofil verwendet.

Erstellen Sie eine HPC-VPC für die RDMA-NICs:

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

Erstellen Sie ein Subnetz für das RDMA-Netzwerk:

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

GKE-Cluster mit mehreren Netzwerken erstellen

Erstellen Sie den GKE-Cluster mit aktiviertem Multi-Networking. Optional können Sie mit diesem Befehl die sekundären CIDR-Bereiche für Dienste und Pods explizit angeben.

Führen Sie dazu diesen Befehl aus:

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]

Wenn Sie diese optionalen Flags verwenden, ersetzen Sie die folgenden zusätzlichen Werte:

SERVICE_CIDR: der sekundäre CIDR-Bereich für Dienste.
POD_CIDR: der sekundäre CIDR-Bereich für Pods.

Wenn Sie diese Flags verwenden, prüfen Sie, ob sich die CIDR-Bereiche mit Subnetzbereichen für zusätzliche Knotennetzwerke überschneiden. Beispiel: SERVICE_CIDR=10.65.0.0/19 und POD_CIDR=10.64.0.0/19.

GKE-Netzwerkobjekte erstellen

Konfigurieren Sie das VPC-Netzwerk mit GKE-Netzwerkparametersätzen. Wenden Sie die Objekte GKENetworkParamSet und Network an:

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

H4D-Knotenpool erstellen

Erstellen Sie einen Knotenpool, der H4D verwendet und eine Verbindung zum RDMA-Netzwerk herstellt. Sie können reservierungsgebundene H4D-Knoten und kompakte Platzierung verwenden. Alternativ können Sie H4D-Knoten verwenden, die mit Flex-Start bereitgestellt wurden. Wählen Sie den Tab aus, der Ihrer Verbrauchsoption entspricht:

Reservierungsgebunden

Erstellen Sie eine Ressourcenrichtlinie für die kompakte Platzierung. Die kompakte Platzierung optimiert die Leistung für eng gekoppelte HPC-Arbeitslasten, die auf mehreren Knoten ausgeführt werden, indem dafür gesorgt wird, dass die Knoten innerhalb einer Zone physisch relativ zueinander platziert werden.

Führen Sie dazu diesen Befehl aus:
```
gcloud compute resource-policies create group-placement POLICY_NAME \
    --region REGION --collocation collocated
```
Ersetzen Sie die folgenden Werte:
- POLICY_NAME: Der Name der Ressourcenrichtlinie, z. B. h4d-compact.
- REGION: Die Region Ihres Clusters.

Erstellen Sie einen Knotenpool, der H4D verwendet und eine Verbindung zum RDMA-Netzwerk herstellt:

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

Ersetzen Sie MAX_UNAVAILABLE durch die maximale Anzahl von Knoten, die während eines Knotenpool-Upgrades gleichzeitig nicht verfügbar sein können. Für eine kompakte Platzierung empfehlen wir schnelle Surge-Upgrades, um die Wahrscheinlichkeit zu verbessern, dass sich Knoten während der Upgrades an einem anderen Ort befinden.

Flex-Start

Erstellen Sie einen Knotenpool, der mit Flex-Start bereitgestellte H4D-Knoten verwendet und eine Verbindung zum RDMA-Netzwerk herstellt:

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

Ersetzen Sie MAX_NODES durch die maximale Anzahl von Knoten, die automatisch für den angegebenen Knotenpool pro Zone skaliert werden sollen.

Docker-Image vorbereiten

Bereiten Sie Ihr Image mit dem folgenden Beispiel-Dockerfile vor:

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 ist das empfohlene containerbasierte Image, das RDMA unterstützt. Der iRDMA-Treiber ist möglicherweise noch nicht in anderen Linux-Distributionen verfügbar.

Manifeste für RDMA konfigurieren

Aktivieren Sie RDMA, indem Sie den Pod-Metadaten die folgenden Annotationen hinzufügen:

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

RDMA mit „rping“ testen

Prüfen Sie die RDMA-Funktionalität, indem Sie rping zwischen einem Server- und einem Client-Pod ausführen:

Führen Sie auf dem Server-Pod den Befehl rping aus:
```
rping -s
```

Führen Sie auf dem Client-Pod den Befehl rping aus:

rping -c -C 2 -d -a SERVER_IP

Ersetzen Sie SERVER_IP durch die IP-Adresse des Server-Pods.

Bei Erfolg sieht die Ausgabe etwa so aus:

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

Nächste Schritte

Weitere Informationen zum Hochleistungs-Computing
Für einige HPC-Arbeitslasten ist ein Message Passing Interface (MPI) erforderlich, um eng gekoppelte Arbeitslasten mit mehreren Knoten mit RDMA auszuführen. Weitere Informationen zum Einrichten von MPI in Ihrem Cluster für Ihre H4D-Knoten finden Sie unter MPI-Arbeitslasten in GKE H4D ausführen.