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

In diesem Dokument wird erläutert, wie Sie Hochleistungs-Computing-Arbeitslasten (HPC) in GKE-Clustern (Google Kubernetes Engine) ausführen, die die H4D-Maschinenreihe und RDMA (Remote Direct Memory Access) verwenden.

H4D ist eine Maschinenserie in der computing-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 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.

Hinweis

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, installieren und dann initialisieren Sie die gcloud CLI. Wenn Sie die gcloud CLI bereits installiert haben, rufen Sie die neueste Version mit dem gcloud components update Befehl ab. Ältere Versionen der gcloud CLI unterstützen möglicherweise nicht die Ausführung der Befehle in diesem Dokument.

GKE-Cluster und -Netzwerke konfigurieren

Mit Cluster Toolkit können Sie schnell einen produktionsbereiten GKE-Cluster erstellen, der reservierungsgebundene H4D-VMs verwendet. In der Cluster Toolkit Anleitung 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 maximal flexibel zu konfigurieren.

Cluster Toolkit

  1. Richten Sie Cluster Toolkit ein. Wir empfehlen, dazu Cloud Shell zu verwenden, da die Abhängigkeiten für Cluster Toolkit bereits vorinstalliert sind.

  2. Rufen Sie die IP-Adresse für den Hostcomputer 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, um den Status der Terraform-Bereitstellung zu speichern:

    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: Ihre Google Cloud Projekt-ID.
    • COMPUTE_REGION_TERRAFORM_STATE: Die Compute-Region, in der Sie den Status der Terraform-Bereitstellung speichern möchten.

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

    • DEPLOYMENT_NAME: Ein eindeutiger Name für die Bereitstellung, der zwischen 6 und 30 Zeichen lang sein muss. Wenn der Bereitstellungsname in einem Projekt 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: Ihre Google Cloud Projekt-ID.
    • 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 Compute-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, für den Sie Verbindungen zum Cluster zulassen möchten. Dieser CIDR-Block muss die IP-Adresse der Maschine enthalten, die Sie zum Aufrufen von Terraform verwenden möchten. Weitere Informationen finden Sie unter Autorisierte Netzwerke .

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

      • 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 verwenden möchten, verwenden Sie die Namen der Reservierung und des Blocks im folgenden Format:

          RESERVATION_NAME/reservationBlocks/BLOCK_NAME

        Wenn Sie nicht wissen, welche Blöcke in Ihrer Reservierung verfügbar sind, siehe Reservierungstopologie anzeigen.

  5. Generieren Sie Standardanmeldedaten für Anwendungen (Application Default Credentials, ADC) 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 (A)nwenden aus, um den Blueprint bereitzustellen.

  8. Außerdem wird mit diesem Blueprint eine Filestore-Instanz bereitgestellt und mit einem nichtflüchtigen Volume (Persistent Volume, PV) mit dem GKE-Cluster verbunden. Dieser Blueprint enthält eine Beispielvorlage für Jobs. 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-Befehl angezeigt, mit dem Sie den Beispieljob auslösen können.

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 oder 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 aufweisen. Wenn Sie eine Reservierung verwenden, müssen die Region und die Zone mit der Region und der Zone der Reservierung übereinstimmen.
  • COMPUTE_ZONE: Die Zone Ihres Knotenpools. Dies muss eine Zone sein, in der H4D verfügbar ist. Wenn Sie eine Reservierung verwenden, müssen die Region und die Zone mit der Region und der Zone der Reservierung übereinstimmen. Sie können keinen Knotenpool mit mehreren Zonen erstellen, wenn die H4D-Knoten mit Cloud RDMA verwendet werden 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 Ihres 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- VPC (Virtual Private Cloud) und das Standard-Subnetz für den Cluster. Erstellen Sie für die IRDMA-Netzwerkkarte (NIC) eine dedizierte VPC und ein dediziertes Subnetz. Die mit der folgenden Anleitung erstellte VPC verwendet bei Bedarf ein Falcon VPC-Netzwerk profil.

    1. Erstellen Sie eine 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 Multi-Networking 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 nicht 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 GKENetworkParamSet und Network Objekte 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 Nutzungsoption 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 sich Knoten innerhalb einer Zone physisch nah beieinander befinden.

      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 wurden, 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, auf die für den angegebenen Knotenpool pro Zone automatisch skaliert werden soll.

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 auf den Schnittstellen Tabs in den Tabellen unter Details zu Betriebssystemen.

Manifeste für RDMA konfigurieren

Aktivieren Sie Cloud 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 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.

    Die Ausgabe sieht im Erfolgsfall 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