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

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

H4D ist eine Maschinenserie in der Computing-optimierten Maschinenfamilie für Compute Engine. Die Maschinenreihe 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.

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 dem Befehl gcloud components update ab. In früheren gcloud CLI-Versionen werden die Befehle in diesem Dokument möglicherweise nicht unterstützt.

GKE-Cluster und Netzwerke konfigurieren

Mit dem Cluster Toolkit können Sie schnell einen produktionsbereiten GKE-Cluster erstellen, in dem reservierungsgebundene H4D-VMs verwendet werden. In den Cluster Toolkit-Anleitungen in diesem Abschnitt wird der GKE H4D-Blueprint verwendet.

Alternativ können Sie die Google Cloud CLI verwenden, um Ihre Clusterumgebung mit reservierungsgebundenen oder Flex-Start-VMs zu konfigurieren.

Cluster Toolkit

  1. Cluster Toolkit einrichten Wir empfehlen, Cloud Shell dafür zu verwenden, da die Abhängigkeiten für Cluster Toolkit bereits vorinstalliert sind.

  2. Rufen Sie die IP-Adresse des Hostcomputers ab, auf dem Sie Cluster Toolkit installiert haben:

    curl ifconfig.me

    Speichern Sie diese IP-Adresse, um sie in einem späteren Schritt für die Variable IP_ADDRESS zu verwenden.

  3. Erstellen Sie einen Cloud Storage-Bucket zum Speichern des Status der Terraform-Bereitstellung:

    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

    Ersetzen Sie die folgenden Variablen:

    • BUCKET_NAME: Der Name des neuen Cloud Storage-Bucket.
    • PROJECT_ID: Projekt-ID in Google Cloud .
    • COMPUTE_REGION_TERRAFORM_STATE: die Computing-Region, in der Sie den Zustand der Terraform-Bereitstellung speichern möchten.

  4. Füllen Sie im examples/gke-h4d/gke-h4d-deployment.yaml-Blueprint aus dem GitHub-Repository die folgenden Einstellungen in den Abschnitten terraform_backend_defaults und vars entsprechend den spezifischen Werten für Ihre Bereitstellung aus:

    • DEPLOYMENT_NAME: ein eindeutiger Name für die Bereitstellung, der zwischen 6 und 30 Zeichen lang sein muss. Wenn der Bereitstellungsname innerhalb eines Projekts nicht eindeutig ist, schlägt die Clustererstellung fehl. Der Standardwert ist gke-h4d.
    • BUCKET_NAME: der Name des Cloud Storage-Bucket, den Sie im vorherigen Schritt erstellt haben.
    • PROJECT_ID: Projekt-ID in Google Cloud .
    • COMPUTE_REGION: Die Compute-Region für den Cluster. Sie muss mit der Region übereinstimmen, in der Maschinen für Ihre Reservierung verfügbar sind.
    • COMPUTE_ZONE: die Computing-Zone für den Knotenpool von H4D-Maschinen. Diese Zone muss mit der Zone übereinstimmen, in der Maschinen in Ihrer Reservierung verfügbar sind.
    • NODE_COUNT: Die Anzahl der H4D-Knoten in Ihrem Cluster.
    • IP_ADDRESS/SUFFIX: Der IP-Adressbereich, der eine Verbindung mit dem Cluster herstellen darf. Dieser CIDR-Block muss die IP-Adresse des Computers enthalten, den Sie zum Aufrufen von Terraform verwenden möchten. Weitere Informationen finden Sie unter Funktionsweise autorisierter Netzwerke.

    • Verwenden Sie für das Feld reservation einen der folgenden Werte, je nachdem, ob Sie beim Bereitstellen des Knotenpools auf bestimmte Blöcke in einer Reservierung abzielen möchten:

      • Wenn Sie den Knotenpool an einer beliebigen Stelle in der Reservierung platzieren möchten, geben Sie den Namen Ihrer Reservierung (RESERVATION_NAME) an.

      • Wenn Sie einen bestimmten Block in Ihrer Reservierung ansprechen möchten, verwenden Sie die Reservierungs- und Blocknamen im folgenden Format:

          RESERVATION_NAME/reservationBlocks/BLOCK_NAME

        Wenn Sie nicht wissen, welche Blöcke in Ihrer Reservierung verfügbar sind, lesen Sie den Abschnitt Reservierungstopologie ansehen.

  5. Standardanmeldedaten für Anwendungen (Application Default Credentials, ADC) generieren, um Zugriff auf Terraform zu gewähren. Wenn Sie Cloud Shell verwenden, können Sie den folgenden Befehl ausführen:

    gcloud auth application-default login

  6. Stellen Sie den Blueprint bereit, um die GKE-Infrastruktur mit den H4D-Maschinentypen bereitzustellen:

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

  7. Wählen Sie bei entsprechender Aufforderung Anwenden aus, um das Blueprint bereitzustellen.

  8. Außerdem wird mit diesem Blueprint eine Filestore-Instanz bereitgestellt und über ein nichtflüchtiges Volume (Persistent Volume, PV) mit dem GKE-Cluster verbunden. In diesem Blueprint ist eine Beispiel-Jobvorlage enthalten. Mit dieser Vorlage wird ein paralleler Job ausgeführt, der Daten in diesen freigegebenen Speicher liest und schreibt. In den Bereitstellungsausgaben wird ein kubectl create angezeigt, mit dem der Beispieljob ausgelöst werden kann.

Google Cloud CLI

Ersetzen Sie die folgenden Werte für die Befehle in diesem Abschnitt:

  • PROJECT_ID: Ihre Google 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. Wenn Sie eine Reservierung verwenden, müssen Region und Zone mit der Region und Zone der Reservierung übereinstimmen.
  • COMPUTE_ZONE: die Zone des Knotenpools. Dies muss eine Zone sein, in der H4D verfügbar ist. Wenn Sie eine Reservierung verwenden, müssen die Region und Zone mit der Region und Zone der Reservierung übereinstimmen. Sie können keinen Knotenpool mit mehreren Zonen erstellen, wenn die H4D-Knoten mit Cloud 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).

So erstellen Sie einen Cluster mit der gcloud CLI:

  1. VPCs und Subnetze erstellen: Konfigurieren Sie die Standard-Virtual Private Cloud (VPC) und das Subnetz für den Cluster. Erstellen Sie für die IRDMA-Netzwerkkarte (Network Interface Card, NIC) eine dedizierte VPC und ein dediziertes Subnetz. Für die VPC, die mit der folgenden Anleitung erstellt wird, wird bei Bedarf ein Falcon-VPC-Netzwerk-Netzwerkprofil verwendet.

    1. Erstellen Sie ein VPC für die IRDMA-Netzwerkschnittstelle, die das RDMA-over-Falcon-Transportprotokoll verwendet:

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

    2. Erstellen Sie ein Subnetz für das Falcon-VPC-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

  2. GKE-Cluster mit mehreren Netzwerken erstellen: Erstellen Sie den Cluster. 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.

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

  4. H4D-Knotenpool erstellen: Erstellen Sie einen Knotenpool, der H4D verwendet und eine Verbindung zum Falcon-VPC-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 Option für die Nutzung entspricht:

    Reservierungsgebunden

    1. 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. Dazu wird dafür gesorgt, dass die Knoten innerhalb einer Zone physisch nahe beieinander 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.

    2. 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 H4D-Knoten verwendet, die mit Flex-Start bereitgestellt werden, und eine Verbindung zum Falcon-VPC-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 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

Weitere Informationen dazu, welche Images IRDMA unterstützen, finden Sie in den Tabellen unter Details zu Betriebssystemen auf dem Tab Schnittstellen.

Manifeste für RDMA konfigurieren

Aktivieren Sie Cloud RDMA, indem Sie die folgenden Annotationen zu den Pod-Metadaten 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 Cloud RDMA-Funktionalität, indem Sie rping zwischen einem Server- und einem Client-Pod ausführen:

  1. Führen Sie auf dem Server-Pod den Befehl rping aus:

    rping -s

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