Netzwerkressourcen mit dem von GKE verwalteten DRANET zuweisen

Google Kubernetes Engine (GKE) DRANET ist ein verwaltetes GKE-Feature, das auf dem Open-Source DRANET-Projekt basiert, in dem die Kubernetes DRA API für Netzwerkressourcen implementiert ist. Mit DRANET können Sie leistungsstarke Netzwerkressourcen für Ihre Pods anfordern und zuweisen, einschließlich Netzwerkschnittstellen, die Remote Direct Memory Access (RDMA) unterstützen. Dieser Ansatz bietet eine portable, Upstream-konforme API für die Verwaltung von Netzwerkressourcen.

In diesem Dokument finden Sie eine konzeptionelle Übersicht über GKE DRANET und erfahren, wie Sie Arbeitslasten in Ihren GKE-Clustern Netzwerkressourcen zuweisen.

Dieses Dokument richtet sich an Cloud-Architekten und Netzwerkspezialisten, die Netzwerke für ihre Organisationen entwerfen. Eine Übersicht über die gesamte GKE-Dokumentation finden Sie unter GKE Dokumentation. Informationen zu häufig verwendeten Rollen und Aufgaben, auf die in Google Cloud Inhalten verwiesen wird, finden Sie unter Häufig verwendete GKE-Nutzerrollen und Aufgaben.

Bevor Sie dieses Dokument lesen, sollten Sie mit Folgendem vertraut sein:

Funktionsweise von GKE DRANET

GKE DRANET wird über ein networking-dra-driver-DaemonSet implementiert. Dieses DaemonSet wird auf Knoten mit GPUs oder TPUs ausgeführt, auf denen GKE DRANET aktiviert ist.

Es fungiert als Agent auf Knotenebene, um Netzwerkschnittstellen über die Kubernetes Dynamic Resource Allocation (DRA) APIs für Pods auffindbar und zuweisbar zu machen.

In GKE-Version 1.34.1-gke.1829001 und höher installiert GKE automatisch DeviceClass-Ressourcen für die Vernetzung. Diese Klassen definieren die Arten von Netzwerkgeräten, die Sie anfordern können. GKE erstellt beispielsweise die Klasse mrdma.google.com für RDMA-fähige Geräte und die Klasse netdev.google.com für andere Netzwerkgeräte.

Wenn Sie GKE DRANET verwenden möchten, müssen Sie zuerst den GKE DRANET-Treiber in einem Knotenpool mit GPUs oder TPUs aktivieren.

Um Netzwerkgeräte für eine Arbeitslast anzufordern, definieren Sie ein ResourceClaimTemplate. In dieser Vorlage werden die DeviceClass und der Zuweisungsmodus angegeben, z. B. das Anfordern aller verfügbaren Geräte auf einem Knoten. Verweisen Sie in der Pod-Spezifikation in einem resourceClaims-Feld auf diese Vorlage, um Ihrem Pod Zugriff auf die angeforderten Netzwerkschnittstellen auf dem Knoten zu gewähren.

Wann sollte GKE DRANET verwendet werden?

GKE DRANET bietet eine standardisierte Möglichkeit, Netzwerkressourcen zu verwalten, die Topologie und Abhängigkeiten berücksichtigen. Diese Standardisierung macht es zu einer geeigneten Lösung für KI- und ML-Arbeitslasten, die eine leistungsstarke Vernetzung erfordern.

Häufige Anwendungsfälle für das Anfordern von Netzwerkschnittstellen für einen Pod sind:

  • Alle verfügbaren RDMA-fähigen Schnittstellen anfordern.
  • Eine bestimmte Anzahl von RDMA-fähigen Schnittstellen anfordern.
  • Alle verfügbaren Nicht-RDMA-Schnittstellen anfordern.
  • Eine bestimmte Anzahl von Nicht-RDMA-Schnittstellen anfordern.

Wichtige Überlegungen bei der Verwendung von GKE DRANET für die Vernetzung

Beachten Sie bei der Verwendung von GKE DRANET für die Vernetzung die folgenden Punkte:

  • Dedizierte Netzwerkschnittstellen

    Wenn Sie GKE DRANET verwenden, um eine Netzwerkschnittstelle für einen Pod anzufordern, ist diese Schnittstelle ausschließlich für diesen Pod bestimmt. Andere Pods auf demselben Knoten können sie nicht gemeinsam nutzen. Dieser Ansatz sorgt dafür, dass der Pod alleinigen Zugriff auf die volle Bandbreite und die Ressourcen dieser Schnittstelle hat. Das ist ein wichtiger Vorteil für leistungsempfindliche Arbeitslasten.

  • GKE DRANET-Treiber unabhängig verwenden

    Sie können den GKE DRA-Treiber aktivieren, um Netzwerkressourcen zu verwalten, ohne andere GKE DRANET-Treiber zu aktivieren. Fügen Sie dazu einem Knotenpool mit GPUs und TPUs das Label cloud.google.com/gke-networking-dra-driver=true hinzu.

  • Andere GKE DRA-Treiber verwenden

    Um einen höheren Durchsatz bei anspruchsvollen KI/ML-Arbeitslasten zu erzielen, kombinieren Sie die DRA API für Beschleuniger (z. B. GPUs und TPUs) mit der von GKE DRANET verwalteten Vernetzung. Dieser kombinierte Ansatz verbessert die Ressourcenausrichtung und die Topologieerkennung. Weitere Informationen zur Verwendung von DRA für andere Ressourcen finden Sie unter GKE-Infrastruktur für DRA Arbeitslasten vorbereiten.

  • Konfliktkonfigurationen vermeiden

    Der GKE DRANET-Treiber verwaltet RDMA-Schnittstellen und gVNICs, für die keine sekundären IP-Adressbereiche konfiguriert sind. Verwenden Sie nicht sowohl den GKE DRANET-Treiber als auch die GKE Multi-Network API mit einer Netzwerkressource vom Typ Device im selben Cluster. Die gemeinsame Verwendung von Treiber und API wird nicht unterstützt, da beide APIs versuchen, denselben Satz von NICs zu verwalten. Das kann zu einer falschen Einrichtung und zu unvorhersehbarem Verhalten führen.

  • Verwalteter Lebenszyklus des DRANET-Treibers

    In GKE-Version 1.34 und höher erstellt GKE automatisch den verwalteten Namespace gke-managed-networking-dra-driver in Ihrem Cluster. Ähnlich wie bei mehreren anderen GKE-Systemarbeitslasten werden die Pods des DRANET-Treibers nur auf Knoten ausgeführt, auf denen sie relevant sind (z. B. Knoten mit GPUs, TPUs und anderer spezialisierter Hardware). Auf Knoten, auf denen der Treiber nicht relevant ist, werden keine Pods für diesen Treiber ausgeführt. Ändern Sie das networking-dra-driver DaemonSet nicht manuell. Manuelle Änderungen, z. B. das Aktualisieren des Felds nodeAffinity, können die Verwaltung des DRANET-Features durch GKE beeinträchtigen und dazu führen, dass die DRANET-Daemon-Pods auf nicht unterstützten Knoten geplant werden.

Voraussetzungen

Für die Verwendung von GKE DRANET muss Ihre Umgebung die folgenden Anforderungen erfüllen:

  • Standard: 1.34.1-gke.1829001 oder höher.
  • Autopilot: 1.35.2-gke.1842000 oder höher.
  • GKE Dataplane V2 ist im Cluster aktiviert.

Sie müssen einen der folgenden beschleunigeroptimierten Maschinentypen verwenden:

Maschinenserie Maschinentyp Beschleunigermodell Netzwerktechnologie
A3 Ultra a3-ultragpu-8g NVIDIA H200-GPU RDMA
A4 a4-highgpu-8g NVIDIA B200-GPU RDMA
A4X a4x-highgpu-4g NVIDIA GB200-GPU RDMA
A4X Max a4x-maxgpu-4g-metal NVIDIA B300-GPU RDMA
TPU v7 tpu7x-standard-4t TPU v7 NetDevice
TPU v6e ct6e-standard-8t Trillium-TPU NetDevice
TPU v6e ct6e-standard-4t Trillium-TPU NetDevice
TPU v6e ct6e-standard-1t Trillium-TPU NetDevice

Beschränkungen

Für GKE DRANET gelten die folgenden Einschränkungen:

  • Sie können GKE DRANET nicht verwenden, um die Standardnetzwerkkarte (NIC) oder virtuelle NICs (z. B. veth) zuzuweisen.
  • Bestimmte Instanztypen, insbesondere Bare-Metal-Knoten wie a4x-max, sind nicht mit Autoscaling- und Autopilot-Clustern kompatibel.

Maschinenspezifische Überlegungen

A4X Max Bare Metal

  • asapd-lite bereitstellen: Wenn Sie Bare-Metal-GPU-Knoten wie A4X Max verwenden, müssen Sie das asapd-lite DaemonSet in Ihrem Cluster bereitstellen. Das asapd-lite-DaemonSet konfiguriert die RDMA-Netzwerkkarten (NICs). Ohne dieses DaemonSet werden keine untergeordneten Schnittstellen erstellt und der dranet-Treiber filtert die RDMA-NICs heraus, wodurch die RDMA-Funktionalität in Ihren Pods verhindert wird. Eine vollständige Einrichtungsanleitung finden Sie unter MRDMA-NICs mit asapd-lite konfigurieren.

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 diese Aufgabe 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 gcloud CLI-Versionen unterstützen möglicherweise nicht die Ausführung der Befehle in diesem Dokument.

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die Kubernetes Engine-Administrator (roles/container.admin) IAM-Rolle für Ihr Projekt zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Erstellen von Knotenpools und zum Zuweisen von Netzwerkressourcen benötigen. Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Sie können die erforderlichen Berechtigungen auch über benutzerdefinierte Rollen oder andere vordefinierte Rollen erhalten.

Cluster erstellen

Erstellen Sie einen GKE-Standardcluster, der GKE Dataplane V2 verwendet:

gcloud container clusters create CLUSTER_NAME \
    --enable-dataplane-v2 \
    --region=CONTROL_PLANE_LOCATION \
    --project=PROJECT_ID \
    --cluster-version=CLUSTER_VERSION

Ersetzen Sie Folgendes:

  • CLUSTER_NAME: Der Name des neuen Clusters.
  • CONTROL_PLANE_LOCATION: Die Region oder Zone für die Clustersteuerungsebene, z. B. us-central1 oder us-central1-a.
  • PROJECT_ID: Ihre Google Cloud Projekt-ID.
  • CLUSTER_VERSION: Die GKE-Version für Ihren Cluster. Diese Version muss 1.34.1-gke.1829001 oder höher sein.

RDMA-Schnittstellen aus einem GPU-Knotenpool verwenden

In den folgenden Abschnitten wird beschrieben, wie Sie einen GPU-Knotenpool und eine Arbeitslast so konfigurieren, dass RDMA-Netzwerkschnittstellen mit GKE DRANET verwendet werden.

GKE DRANET-Treiber in einem GPU-Knotenpool aktivieren

Wenn Sie den GKE DRANET-Treiber in einem GPU-Knotenpool aktivieren möchten, der RDMA unterstützt, fügen Sie beim Erstellen des Knotenpools das Label cloud.google.com/gke-networking-dra-driver=true hinzu.

gcloud beta container node-pools create NODE_POOL_NAME \
  --region=REGION \
  --cluster=CLUSTER_NAME \
  --node-locations=NODE_LOCATIONS \
  --accelerator type=ACCELERATOR_TYPE,count=ACCELERATOR_COUNT,gpu-driver-version=DRIVER_VERSION \
  --machine-type=MACHINE_TYPE \
  --num-nodes=NUM_NODES \
  --reservation-affinity=specific \
  --reservation=projects/RESERVATION_PROJECT/reservations/RESERVATION_NAME/reservationBlocks/RESERVATION_BLOCK \
  --accelerator-network-profile=auto \
  --node-labels=cloud.google.com/gke-networking-dra-driver=true

Ersetzen Sie Folgendes:

  • NODE_POOL_NAME: Der Name des neuen Knotenpools.
  • REGION: die Google Cloud Region für Ihren Cluster.
  • CLUSTER_NAME: Der Name Ihres Clusters.

  • ACCELERATOR_TYPE: Der Typ des GPU-Beschleunigers:

    Beispiel:

    • A4-VMs: Geben Sie nvidia-b200 ein.
    • A3-Ultra-VMs: Geben Sie nvidia-h200-141gb ein.

  • ACCELERATOR_COUNT: Die Anzahl der GPUs, die an Knoten im Knotenpool angehängt werden sollen. Für die VMs „a4-highgpu-8g“ und „a3-ultragpu-8g“ beträgt die Anzahl der GPUs beispielsweise 8.

  • DRIVER_VERSION: Die zu verwendende GPU-Treiberversion. Beispiel: default oder latest.

  • MACHINE_TYPE: Der Maschinentyp für den Knotenpool, z. B. a3-ultragpu-8g.

  • NUM_NODES: Die Anzahl der Knoten für den Knotenpool. Für den flexiblen Start muss dieser Wert auf 0 festgelegt sein.

  • RESERVATION_PROJECT: Die Projekt-ID der Reservierung.

  • RESERVATION_NAME: Der Name Ihrer Reservierung. Diesen Wert finden Sie unter Zukünftige Reservierungsanfragen ansehen.

  • RESERVATION_BLOCK: Der Name eines bestimmten Blocks innerhalb der Reservierung. Diesen Wert finden Sie unter Zukünftige Reservierungsanfragen ansehen.

Mit diesem Befehl werden Beschleunigernetzwerkprofile verwendet, um VPC-Netzwerke und -Subnetze für Ihre Beschleuniger-VMs automatisch zu konfigurieren. Alternativ können Sie Ihr VPC-Netzwerk und Ihre Subnetze explizit angeben.

RDMA-Ressourcen für eine Arbeitslast bereitstellen

Wenn Sie RDMA-Ressourcen für einen Pod zuweisen möchten, geben Sie ein ResourceClaimTemplate an.

  1. Erstellen Sie ein ResourceClaimTemplate, um festzulegen, wie die RDMA-Geräte zugewiesen werden sollen. Das folgende Manifest fordert alle verfügbaren mrdma-Geräte auf dem Knoten an. Speichern Sie das Manifest als all-mrdma-template.yaml:

    apiVersion: resource.k8s.io/v1
kind: ResourceClaimTemplate
metadata:
  name: all-mrdma
spec:
  spec:
    devices:
      requests:
      - name: req-mrdma
        exactly:
          deviceClassName: mrdma.google.com
          allocationMode: All

  2. Wenden Sie das Manifest an:

    kubectl apply -f all-mrdma-template.yaml

  3. Stellen Sie Ihre Arbeitslast bereit und verweisen Sie auf das ResourceClaimTemplate. Das folgende Manifest stellt einen Pod bereit, der auf die Vorlage all-mrdma verweist. Dadurch erhält der Pod Zugriff auf die RDMA-Schnittstellen auf dem Knoten. Speichern Sie das Manifest als agnhost-rdma-pod.yaml:

    apiVersion: v1
kind: Pod
metadata:
  name: agnhost-rdma
  namespace: default
  labels:
    app: agnhost
spec:
  containers:
  - name: agnhost
    image: registry.k8s.io/e2e-test-images/agnhost:2.39
    args: ["netexec", "--http-port", "80"]
    ports:
    - name: agnhost-port
      containerPort: 80
    resources:
      claims:
      - name: rdma
      limits:
        nvidia.com/gpu: 1
  resourceClaims:
  - name: rdma
    resourceClaimTemplateName: all-mrdma

  4. Wenden Sie das Manifest an:

    kubectl apply -f agnhost-rdma-pod.yaml

  5. Prüfen Sie, ob die zusätzlich zugewiesenen Netzwerkschnittstellen im Pod sichtbar sind.

    kubectl exec agnhost-rdma -- ls /sys/class/net

    Die folgende Beispielausgabe zeigt die Standardschnittstellen eth0 und lo sowie die zugewiesenen RDMA-Schnittstellen, z. B. gpu0rdma0. Die Anzahl und die Namen der Netzwerkschnittstellen (NICs) variieren je nach Maschinentyp des GKE-Knotens.

    eth0
gpu0rdma0
gpu1rdma0
gpu2rdma0
gpu3rdma0
lo

Nicht-RDMA-Netzwerkschnittstellen in einem TPU-Knotenpool verwenden

In den folgenden Abschnitten wird beschrieben, wie Sie einen TPU-Knotenpool und eine Arbeitslast so konfigurieren, dass Nicht-RDMA-Netzwerkschnittstellen mit GKE DRANET verwendet werden.

DeviceClasses für die Vernetzung prüfen

Prüfen Sie, ob die DeviceClass-Ressourcen für die Vernetzung in Ihrem Cluster vorhanden sind.

kubectl get deviceclass netdev.google.com

Die Ausgabe sieht etwa so aus:

NAME                AGE
netdev.google.com   2d22h

GKE DRANET-Treiber in einem TPU-Slice-Knotenpool aktivieren

Wenn Sie den GKE DRANET-Treiber beim Erstellen eines TPU-Slice-Knotenpools aktivieren möchten, fügen Sie das Label cloud.google.com/gke-networking-dra-driver=true hinzu.

gcloud beta container node-pools create NODE_POOL_NAME \
    --location=LOCATION \
    --cluster=CLUSTER_NAME \
    --node-locations=NODE_LOCATIONS \
    --machine-type=MACHINE_TYPE \
    --tpu-topology=TPU_TOPOLOGY \
    --num-nodes=NUM_NODES \
    --accelerator-network-profile=auto \
    --node-labels=cloud.google.com/gke-networking-dra-driver=true

Ersetzen Sie Folgendes:

  • NODE_POOL_NAME: Der Name des neuen Knotenpools.
  • LOCATION: Die Google Cloud Region oder Zone für Ihren Cluster.
  • CLUSTER_NAME: Der Name Ihres Clusters.
  • NODE_LOCATIONS: Die Google Cloud Zonen für die Knoten im Knotenpool.
  • MACHINE_TYPE: Der Maschinentyp, der für Knoten verwendet werden soll. Weitere Informationen zu TPU-kompatiblen Maschinentypen finden Sie unter TPU-Version auswählen.
  • TPU_TOPOLOGY: Die TPU-Topologie, z. B. 2x4x4. Das Format der Topologie hängt von der TPU-Version ab. Weitere Informationen zu TPU-Topologien finden Sie unter Topologie auswählen.
  • NUM_NODES: Die Anzahl der Knoten im Knotenpool.

Weitere Informationen finden Sie unter TPU-Slice-Knotenpool mit einem Host erstellen.

Arbeitslast bereitstellen, die alle Netzwerkgeräte anfordert

Wenn Sie Nicht-RDMA-Netzwerkgeräte für einen Pod zuweisen möchten, geben Sie ein ResourceClaimTemplate an.

  1. Erstellen Sie ein ResourceClaimTemplate, das auf die DeviceClass netdev.google.com verweist. Das folgende Manifest fordert alle verfügbaren Nicht-RDMA-Netzwerkgeräte auf dem Knoten an.

    Speichern Sie das Manifest als all-netdev-template.yaml:

    apiVersion: resource.k8s.io/v1
kind: ResourceClaimTemplate
metadata:
  name: all-netdev
spec:
  spec:
    devices:
      requests:
      - name: req-netdev
        exactly:
          deviceClassName: netdev.google.com
          allocationMode: All

  2. Wenden Sie das Manifest an:

    kubectl apply -f all-netdev-template.yaml

  3. Stellen Sie Ihre Arbeitslast bereit und verweisen Sie auf das ResourceClaimTemplate. Das folgende Manifest stellt einen Pod bereit, der die Vorlage all-netdev verwendet, um dem Pod Zugriff auf alle Nicht-RDMA-Netzwerkgeräte auf dem Knoten zu gewähren. Speichern Sie das Manifest als netdev-pod.yaml:

    apiVersion: v1
kind: Pod
metadata:
  name: agnhost-netdev
  namespace: default
  labels:
    app: agnhost
spec:
  containers:
  - name: agnhost
    image: registry.k8s.io/e2e-test-images/agnhost:2.39
    args: ["netexec", "--http-port", "80"]
    ports:
    - name: agnhost-port
      containerPort: 80
    resources:
      claims:
      - name: netdev
      limits:
        google.com/tpu: 4
  nodeSelector:
    cloud.google.com/gke-tpu-accelerator: TPU_ACCELERATOR
    cloud.google.com/gke-tpu-topology: TPU_TOPOLOGY
  resourceClaims:
  - name: netdev
    resourceClaimTemplateName: all-netdev

    Ersetzen Sie Folgendes:

    • TPU_ACCELERATOR: Der TPU-Beschleunigertyp, z. B. tpu-v5p-slice.
    • TPU_TOPOLOGY: Die TPU-Topologie, z. B. 2x4x4.

  4. Wenden Sie das Manifest an:

    kubectl apply -f netdev-pod.yaml

  5. Prüfen Sie, ob die zusätzlich zugewiesenen Netzwerkschnittstellen im Pod sichtbar sind.

    kubectl exec agnhost-netdev -- ls /sys/class/net

    Die folgende Beispielausgabe zeigt die Standardschnittstellen eth0 und lo sowie die zugewiesenen Netzwerkgeräte mit Namen wie eth1 und eth2. Die Anzahl der NICs und ihre Namen variieren je nach Maschinentyp des GKE-Knotens.

    eth0
eth1
eth2
lo

Dranet mit benutzerdefinierter ComputeClass aktivieren

Wenn Sie GKE DRANET in Autopilot-Clustern oder mit der automatischen Knotenbereitstellung in Standardclustern verwenden möchten, müssen Sie eine benutzerdefinierte ComputeClass-Ressource verwenden, um sich für das Feature anzumelden.

  1. Erstellen Sie ein ComputeClass-Manifest, das den DRANET-Treiber aktiviert und das Beschleunigernetzwerkprofil auf auto festlegt:

    apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: dranet-compute-class
spec:
  nodePoolAutoCreation:
    enabled: true
  nodePoolConfig:
    dra:
      networking:
        enabled: true
  priorities:
  - machineType: MACHINE_TYPE
    gpu:
      count: GPU_COUNT
      type: GPU_TYPE
    acceleratorNetworkProfile: auto

    Ersetzen Sie Folgendes:

    • MACHINE_TYPE: Der Maschinentyp für den Knotenpool, z. B. a3-ultragpu-8g.
    • GPU_COUNT: Die Anzahl der GPUs für den Maschinentyp.
    • GPU_TYPE: Der Typ der GPU, z. B. nvidia-h200.

  2. Wenden Sie das Manifest an:

    kubectl apply -f COMPUTE_CLASS_FILENAME.yaml

  3. Verweisen Sie in der Pod-Spezifikation mit der Knotenauswahl cloud.google.com/compute-class auf die ComputeClass:

    apiVersion: v1
kind: Pod
metadata:
  name: dranet-pod
spec:
  nodeSelector:
    cloud.google.com/compute-class: "dranet-compute-class"
  ...

Eine bestimmte Anzahl von Netzwerkgeräten anfordern

In den vorherigen Beispielen wird gezeigt, wie Sie alle verfügbaren Netzwerkgeräte eines bestimmten Typs anfordern, indem Sie allocationMode auf All festlegen. Wenn Sie stattdessen eine bestimmte Anzahl von Geräten anfordern müssen, können Sie allocationMode in Ihrem ResourceClaimTemplate auf ExactCount festlegen.

Im folgenden Beispiel werden zwei RDMA-Netzwerkgeräte angefordert:

apiVersion: resource.k8s.io/v1
kind: ResourceClaimTemplate
metadata:
  name: two-mrdma
spec:
  spec:
    devices:
      requests:
      - name: req-mrdma
        exactly:
          deviceClassName: mrdma.google.com
          allocationMode: ExactCount
          count: 2

Nächste Schritte