GPUs in GKE-Standardknotenpools ausführen

Standard

---

Auf dieser Seite erfahren Sie, wie Sie NVIDIA®-Grafikprozessoren (GPUs) zur Hardwarebeschleunigung in den Knoten Ihrer GKE-Standardcluster (Google Kubernetes Engine) verwenden. Weitere Informationen zu GPUs in GKE finden Sie unter GPUs in GKE.

Sie können GPUs auch direkt in Ihren Autopilot-Pods verwenden. Eine Anleitung finden Sie unter GPU-Arbeitslasten in Autopilot bereitstellen.

Übersicht

Mit GKE können Sie Knotenpools erstellen, die mit den NVIDIA Tesla® GPUs K80, P100, P4, V100, T4 und A100 ausgestattet sind. GPUs bieten Rechenleistung für Deep-Learning-Aufgaben wie Bilderkennung, Natural Language Processing und andere rechenintensive Aufgaben wie Videotranscodierung und Bildverarbeitung.

Hinweis: Weitere Informationen zu Anwendungsfällen für GPUs finden Sie auf der Google Cloud-Seite GPUs.

Sie können GPUs auch mit Spot VMs verwenden, wenn Ihre Arbeitslasten häufige Knotenunterbrechungen tolerieren können. Bei Verwendung von Spot-VMs reduziert sich der Preis für die Ausführung von GPUs. Weitere Informationen finden Sie unter Spot-VMs mit GPU-Knotenpools verwenden.

Voraussetzungen

GPUs in GKE setzen Folgendes voraus:

• Kubernetes-Version: Für Knotenpools, die das Knoten-Image Container-Optimized OS verwenden, sind GPU-Knoten ab GKE-Version 1.9 verfügbar. Für Knotenpools, die das Ubuntu-Knoten-Image verwenden, sind GPU-Knoten ab GKE-Version 1.11.3 verfügbar.

• GPU-Kontingent: Sie müssen ein Compute Engine-GPU-Kontingent in der gewünschten Zone haben, bevor Sie GPU-Knoten erstellen können. Auf der Seite Kontingente der Google Cloud Console können Sie prüfen, ob in Ihrem Projekt ein ausreichendes GPU-Kontingent vorhanden ist.

  Wenn Sie ein höheres GPU-Kontingent benötigen, können Sie in der Google Cloud Console eine Aufstockung des GPU-Kontingents anfordern. Falls Sie ein Abrechnungskonto eingerichtet haben, müsste Ihr Projekt nach dem Einreichen Ihrer Kontingentanfrage automatisch ein Kontingent erhalten.

  Hinweis: Kostenlose Testkonten erhalten standardmäßig kein GPU-Kontingent.

• NVIDIA-GPU-Treiber: Sie müssen NVIDIA-GPU-Treiber manuell auf Ihren Knoten installieren. Weiter unten auf dieser Seite wird erläutert, wie Sie die Treiber installieren.

• A100-GPUs: A100-GPUs werden nur auf a2-Maschinentypen unterstützt. Dafür ist die GKE-Version 1.18.6-gke.3504 oder höher erforderlich. Prüfen Sie, ob Ihr Kontingent für den zugrunde liegenden A2-Maschinentyp ausreicht, um die A100-GPU zu verwenden.

Beschränkungen

Beachten Sie vor Verwendung von GPUs in GKE die folgenden Beschränkungen:

• Sie können vorhandenen Knotenpools keine GPUs hinzufügen.
• Innerhalb von Wartungsereignissen ist eine Live-Migration von GPU-Knoten nicht möglich.
• Der GPU-Typ, den Sie verwenden können, hängt von der Maschinenserie ab:
  • A2-Serie: A100-GPUs.
  • N1-Maschinenserie: Alle GPUs außer A100.
• GPUs werden in Windows Server-Knotenpools nicht unterstützt.

Verfügbarkeit

GPUs sind in bestimmten Regionen und Zonen verfügbar. Berücksichtigen Sie also bei Ihrer GPU-Kontingentanfrage die Regionen, in denen Sie Ihre Cluster ausführen möchten.

Eine vollständige Liste der betreffenden Regionen und Zonen finden Sie unter GPUs in Compute Engine.

Mit dem Google Cloud CLI können Sie auch GPUs aufrufen, die in Ihrer Zone verfügbar sind. Führen Sie folgenden Befehl aus, um eine Liste aller GPU-Beschleunigertypen aufzurufen, die in den einzelnen Zonen unterstützt werden:

gcloud compute accelerator-types list

Preise

Informationen zu GPU-Preisen finden Sie in der Preistabelle auf der GPU-Seite von Google Cloud.

GPU-Kontingent

Ihr GPU-Kontingent entspricht der Gesamtzahl der GPUs, die in Ihrem Google Cloud-Projekt ausgeführt werden können. Damit Sie Cluster mit GPUs erstellen können, muss in Ihrem Projekt ein ausreichend hohes GPU-Kontingent vorhanden sein.

Ihr GPU-Kontingent sollte mindestens der Gesamtzahl der GPUs entsprechen, die Sie in Ihrem Cluster ausführen möchten. Wenn Sie Cluster-Autoscaling aktivieren, sollte das angeforderte GPU-Kontingent mindestens der maximalen Anzahl von Knoten in Ihrem Cluster multipliziert mit der Anzahl von GPUs pro Knoten entsprechen.

Wenn Sie beispielsweise einen Cluster mit drei Knoten erstellen, auf dem zwei GPUs pro Knoten ausgeführt werden, benötigt Ihr Projekt mindestens ein Kontingent von sechs GPUs.

GPU-Kontingent anfordern

Zum Anfordern eines GPU-Kontingents verwenden Sie die Google Cloud Console. Weitere Informationen zum Anfordern von Kontingenten finden Sie in der Compute Engine-Dokumentation unter Weitere Kontingente anfordern.

Nach GPU-Kontingenten suchen

Führen Sie die folgenden Schritte in der Google Cloud Console aus, um nach GPU-Kontingenten zu suchen:

1. Rufen Sie in der Google Cloud Console die Seite Kontingente von „IAM und Verwaltung“ auf.

   Kontingente aufrufen

2. Klicken Sie im Drop-down-Menü Messwerte auf Keine und geben Sie dann "gpus" in das Suchfeld ein.

3. Wählen Sie im Suchergebnis die gewünschten GPUs aus:

   

4. Schließen Sie das Drop-down-Menü Messwert.

Kontingentanfrage senden

Führen Sie die folgenden Schritte in der Google Cloud Console aus, um eine Kontingentanfrage zu senden:

1. Wählen Sie aus der Liste der GPU-Kontingente die Kontingente für die gewünschten Regionen wie us-central1 aus.
2. Klicken Sie auf Kontingente bearbeiten. Ein Anfrageformular wird geöffnet.
3. Füllen Sie das Feld Neues Kontingentlimit für jede Kontingentanfrage aus.
4. Geben Sie im Feld Beschreibung der Anfrage die Details zur Anfrage ein.
5. Klicken Sie auf Fertig.
6. Klicken Sie auf Anfrage senden.

GPUs ausführen

In den folgenden Abschnitten wird erläutert, wie GPUs in GKE-Standardclustern ausgeführt werden.

GPU-Knotenpool mit automatischer Skalierung erstellen

Damit Sie GPUs in GKE so kosteneffizient wie möglich einsetzen und vom Cluster-Autoscaling profitieren können, sollten Sie separate GPU-Knotenpools in Ihren Clustern erstellen.

Wenn Sie einen GPU-Knotenpool in einen vorhandenen Cluster aufnehmen, der bereits einen Knotenpool ohne GPUs ausführt, kennzeichnet GKE die GPU-Knoten automatisch mit folgender Knotenmarkierung:

• Schlüssel: nvidia.com/gpu
• Auswirkung: NoSchedule

Hinweis: Wenn ein GPU-Knotenpool in einen Cluster aufgenommen wird, dessen vorhandene Knotenpools alle GPU-Knotenpools sind, oder wenn Sie einen neuen Cluster mit einem angehängten GPU-Standardpool erstellen, wird die obige Kennzeichnung den GPU-Knoten nicht hinzugefügt. Die Kennzeichnung wird den vorhandenen GPU-Knoten auch nicht nachträglich hinzugefügt, wenn später ein Nicht-GPU-Knotenpool hinzugefügt wird.

Außerdem wendet GKE automatisch die entsprechenden Toleranzen für Pods an, die GPUs anfordern. Hierfür wird der Admission-Controller ExtendedResourceToleration ausgeführt.

Dadurch werden nur Pods, die GPUs anfordern, auf GPU-Knoten eingeplant, was eine effizientere automatische Skalierung ermöglicht: Ihre GPU-Knoten können schnell herunter skaliert werden, wenn nicht genug Pods GPUs anfordern.

Sie können einen GPU-Knotenpool in einem vorhandenen Cluster mithilfe der Google Cloud Console oder der Google Cloud CLI erstellen.

gcloud

Führen Sie zum Erstellen eines Knotenpools mit GPUs folgenden Befehl aus:

gcloud container node-pools create POOL_NAME \
  --accelerator type=GPU_TYPE,count=AMOUNT \
  --zone COMPUTE_ZONE --cluster CLUSTER_NAME \
  [--num-nodes 3 --min-nodes 0 --max-nodes 5 --enable-autoscaling
  --machine-type a2-highgpu-1g]

Ersetzen Sie Folgendes:

• POOL_NAME: Der Name, den Sie für den Knotenpool auswählen.
• GPU_TYPE: Den GPU-Typ, entweder nvidia-tesla-k80, nvidia-tesla-p100, nvidia-tesla-p4, nvidia-tesla-v100, nvidia-tesla-t4, nvidia-tesla-a100 oder nvidia-a100-80gb.
• AMOUNT: Die Anzahl der GPUs, die an Knoten im Knotenpool angehängt werden sollen.
• COMPUTE_ZONE: Die Computing-Zone, in der der Knotenpool erstellt werden soll, z. B. us-central1-c. Der Cluster muss bereits in der angegebenen Zone ausgeführt werden.
• CLUSTER_NAME: Der Name des Clusters, in dem der Knotenpool erstellt werden soll.

Weitere Optionen:

• --num-nodes gibt die anfängliche Anzahl der Knoten an, die erstellt werden sollen.
• --min-nodes gibt die Mindestanzahl der Knoten an, die an einem beliebigen angegebenen Zeitpunkt ausgeführt werden sollen.
• --max-nodes gibt die Höchstanzahl der Knoten an, die ausgeführt werden können.
• --enable-autoscaling ermöglicht, dass der Knotenpool automatisch skaliert wird, wenn sich die Arbeitslast ändert.
• --machine-type gibt den Maschinentyp für die Knoten an. Erforderlich für nvidia-tesla-a100- und nvidia-a100-80gb-GPUs, die nur auf A2-Maschinentypen ausgeführt werden können.

Der folgende Befehl erstellt beispielsweise einen Autoscaling-Knotenpool p100 und zwei P100-GPUs im Cluster p100-cluster:

gcloud container node-pools create p100 \
  --accelerator type=nvidia-tesla-p100,count=2 \
  --zone us-central1-c --cluster p100-cluster \
  --num-nodes 3 --min-nodes 0 --max-nodes 5 --enable-autoscaling

Console

So erstellen Sie einen Knotenpool mit GPUs:

1. Rufen Sie in der Google Cloud Console die Seite Google Kubernetes Engine auf.

   Zur Seite "Google Kubernetes Engine"

2. Klicken Sie in der Clusterliste auf den Namen des Clusters, den Sie ändern möchten.

3. Klicken Sie auf Knotenpool hinzufügen .

4. Klicken Sie optional auf der Seite Knotenpooldetails das Kästchen Autoscaling aktivieren an.

5. Konfigurieren Sie den Knotenpool wie gewünscht.

6. Wählen Sie im Navigationsbereich Knoten aus.

7. Klicken Sie unter Maschinenfamilie auf GPU.

8. Wählen Sie einen GPU-Typ und eine Anzahl an GPUs aus, die auf jedem Knoten ausgeführt werden sollen.

9. Lesen Sie die Warnung und wählen Sie Ich habe die Einschränkungen verstanden aus.

10. Konfigurieren Sie die Maschine wie gewünscht.

11. Klicken Sie auf Erstellen.

Neuen zonalen Cluster mit GPUs erstellen

Zonale Cluster, die GPUs ausführen, können mit der Google Cloud Console oder der Google Cloud CLI erstellt werden.

gcloud

Führen Sie folgenden Befehl aus, um einen zonalen Cluster mit GPUs zu erstellen, die im Standardknotenpool des Clusters ausgeführt werden:

gcloud container clusters create CLUSTER_NAME \
  --accelerator type=GPU_TYPE,count=AMOUNT \
  --zone COMPUTE_ZONE

Ersetzen Sie Folgendes:

• CLUSTER_NAME: Der Name, den Sie für den Cluster auswählen.
• GPU_TYPE: Den GPU-Typ, entweder nvidia-tesla-k80, nvidia-tesla-p100, nvidia-tesla-p4, nvidia-tesla-v100, nvidia-tesla-t4, nvidia-tesla-a100 oder nvidia-a100-80gb.
• AMOUNT: Die Anzahl der GPUs, die im Standardknotenpool ausgeführt werden sollen.
• COMPUTE_ZONE: Die Computing-Zone des Clusters, z. B. us-central1-c.

Der folgende Befehl erstellt beispielsweise den Cluster p100 mit drei Knoten (der Standardwert, wenn --num-nodes weggelassen wird) und zwei P100-GPUs pro Knoten:

gcloud container clusters create p100 \
  --accelerator type=nvidia-tesla-p100,count=2 \
  --zone us-central1-c

Console

1. Öffnen Sie die Clustervorlage GPU-beschleunigtes Computing.

   Zur Vorlage "GPU-beschleunigtes Computing"

2. Konfigurieren Sie den Cluster wie gewünscht. Passen Sie dann den GPU-Knotenpool an oder fügen Sie weitere GPU-Knotenpools hinzu.

3. Lesen Sie die Warnung und wählen Sie Ich habe die Einschränkungen verstanden aus.

4. Klicken Sie auf Erstellen.

Neuen regionalen Cluster mit GPUs erstellen

Regionale Cluster werden standardmäßig mit Knoten in drei Zonen einer Region erstellt. Wenn Sie einen regionalen Cluster mit GPUs erstellen, müssen Sie Zonen mit dem Flag --node-locations angeben. Sie können diesen Befehl auch verwenden, nachdem Sie den Cluster erstellt haben. Unter Verfügbarkeit erfahren Sie, welche Zonen GPUs bieten.

Sie erstellen einen regionalen GPU-Cluster mit der Google Cloud CLI oder der Google Cloud Console.

gcloud

Führen Sie folgenden Befehl aus, um einen regionalen Cluster mit GPUs zu erstellen:

gcloud container clusters create CLUSTER_NAME \
  --accelerator type=GPU_TYPE,count=AMOUNT \
  --region COMPUTE_REGION \
  --node-locations COMPUTE_ZONE,COMPUTE_ZONE1

Ersetzen Sie Folgendes:

• CLUSTER_NAME: Der Name, den Sie für den Cluster auswählen.
• GPU_TYPE: Der GPU-Typ, entweder nvidia-tesla-k80, nvidia-tesla-p100, nvidia-tesla-p4, nvidia-tesla-v100, nvidia-tesla-t4, nvidia-tesla-a100 oder nvidia-a100-80gb.
• AMOUNT: Die Anzahl der pro Knoten auszuführenden GPUs.
• COMPUTE_REGION: Die Region des Clusters, z. B. us-central1.
• COMPUTE_ZONE,COMPUTE_ZONE1,[...]: die Zonen, in denen die Knoten erstellt werden sollen. Die Zonen müssen sich im selben COMPUTE_REGION wie die Steuerungsebene des Clusters befinden, die durch das Flag --region angegeben wird. Diese Zonen müssen die von Ihnen angegebenen GPU-Typen enthalten.

Der folgende Befehl erstellt beispielsweise den Cluster p100 mit drei Knoten (der Standardwert, wenn --num-nodes weggelassen wird) und zwei P100-GPUs pro Knoten in zwei Zonen innerhalb von us-central1:

gcloud container clusters create p100 \
  --accelerator type=nvidia-tesla-p100,count=2 \
  --region us-central1 \
  --node-locations us-central1-a,us-central1-c

Console

1. Öffnen Sie die Clustervorlage GPU-beschleunigtes Computing.

   Zur Vorlage "GPU-beschleunigtes Computing"

2. Wählen Sie unter Standorttyp die Option Regional aus.

3. Wählen Sie in der Drop-down-Liste Region die gewünschte Region aus.

4. Konfigurieren Sie den Cluster wie gewünscht. Passen Sie dann den GPU-Knotenpool an oder fügen Sie weitere GPU-Knotenpools hinzu.

5. Lesen Sie die Warnung und wählen Sie Ich habe die Einschränkungen verstanden aus.

6. Klicken Sie auf Erstellen.

NVIDIA-GPU-Gerätetreiber installieren

Nachdem Sie Ihrem Cluster GPU-Knoten hinzugefügt haben, müssen Sie die NVIDIA-Gerätetreiber auf den Knoten installieren. Google stellt ein DaemonSet bereit, das Sie zur Installation der Treiber anwenden können. Auf GPU-Knoten, die Container-Optimized OS-Images verwenden, können Sie auch zwischen der Standard-GPU-Treiberversion oder einer neueren Version auswählen. In der folgenden Tabelle werden die GPU-Treiberversionen beschrieben, die für bestimmte GKE-Versionen verfügbar sind.

Im folgenden Abschnitt finden Sie Installationsanleitungen für COS- (Container-Optimized OS) und Ubuntu-Knoten.

Hinweis: Zum Ausführen des DaemonSets für die Installation ist für den GPU-Knotenpool der Bereich https://www.googleapis.com/auth/devstorage.read_only für die Kommunikation mit gcr.io (Registry-Name) erforderlich. Ohne diesen Bereich schlägt das Herunterladen des DaemonSet-Manifests für die Installation fehl. Dieser Bereich ist einer der Standardbereiche, der beim Erstellen des Clusters normalerweise hinzugefügt wird.

COS

Führen Sie den folgenden Befehl aus, um das DaemonSet für die Installation bereitzustellen und die Standardversion des GPU-Treibers zu installieren:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml

Alternativ können Sie über folgenden Befehl die neuere GPU-Treiberversion installieren (siehe Tabelle unten):

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded-latest.yaml

Die Installation kann mehrere Minuten dauern. Sobald das NVIDIA-GPU-Geräte-Plug-in installiert ist, wird die Kapazität der NVIDIA-GPU über die Kubernetes-APIs angezeigt.

Jede Version eines Container-Optimized OS-Images hat mindestens eine unterstützte NVIDIA GPU-Treiberversion. In den Versionshinweisen zu den wichtigsten LTS-Meilensteinen für Container-Optimized OS finden Sie die standardmäßig unterstützte Version.

In der folgenden Tabelle sind die von den Nvidia-Treiberversionen unterstützten GKE-Versionen aufgeführt:

GKE-Version	Nvidia-Treiber
1.26	R470(Standard), R510
1.25	R470(Standard), R510
1.24	R470(Standard), R510
1.23	R450(Standard), R470 oder R510
1.22	R450(Standard), R470 oder R510
1.21	R450(Standard), R470 oder R510
1.20	R450(default), R470

Hinweis: R510 ist in GKE-Versionen in 2022-R24 oder höher verfügbar.

Ubuntu

GPU-Unterstützung erfordert v1.11.3 oder höher für Ubuntu-Knoten.

Führen Sie den folgenden Befehl aus, um das DaemonSet für die Installation bereitzustellen:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/ubuntu/daemonset-preloaded.yaml

Die Installation kann mehrere Minuten dauern. Sobald das NVIDIA-GPU-Geräte-Plug-in installiert ist, wird die Kapazität der NVIDIA-GPU über die Kubernetes-APIs angezeigt.

In der folgenden Tabelle sind die von den Nvidia-Treiberversionen unterstützten GKE-Versionen aufgeführt:

GKE-Version	Nvidia-Treiber
1.26	R470
1.25	R470
1.24	R470
1.23	R470
1.22	R450
1.21	R450
1.20	R450

Automatische Knotenbereitstellung mit GPUs verwenden

Wenn Sie die automatische Knotenbereitstellung mit GPUs verwenden, haben die automatisch bereitgestellten Knotenpools standardmäßig nicht genügend Bereiche, um das DaemonSet für die Installation auszuführen. Ändern Sie zum Zuweisen der erforderlichen Bereiche die Standardbereiche für die automatische Knotenbereitstellung, um logging.write, monitoring, devstorage.read_only und compute hinzuzufügen. Beispiel:

gcloud container clusters update CLUSTER_NAME --enable-autoprovisioning \
    --min-cpu=1 --max-cpu=10 --min-memory=1 --max-memory=32 \
    --autoprovisioning-scopes=https://www.googleapis.com/auth/logging.write,https://www.googleapis.com/auth/monitoring,https://www.googleapis.com/auth/devstorage.read_only,https://www.googleapis.com/auth/compute

Weitere Informationen zur automatischen Bereitstellung finden Sie unter Automatische Knotenbereitstellung verwenden.

Pods zur Nutzung von GPUs konfigurieren

Für die Nutzung von GPUs durch Pods konfigurieren Sie ein Ressourcenlimit. Dieses Ressourcenlimit geben Sie in einer Pod-Spezifikation mit folgendem Schlüssel/Wert-Paar an:

• Schlüssel: nvidia.com/gpu
• Wert: Anzahl der zu nutzenden GPUs

Hinweis: alpha.kubernetes.io/nvidia-gpu wird in GKE nicht als Ressourcenname unterstützt. Verwenden Sie stattdessen nvidia.com/gpu.

Im Folgenden finden Sie ein Beispiel für eine Pod-Spezifikation, die GPUs nutzt:

apiVersion: v1
kind: Pod
metadata:
  name: my-gpu-pod
spec:
  containers:
  - name: my-gpu-container
    image: nvidia/cuda:11.0.3-runtime-ubuntu20.04
    command: ["/bin/bash", "-c", "--"]
    args: ["while true; do sleep 600; done;"]
    resources:
      limits:
       nvidia.com/gpu: 2

Mehrere GPU-Typen nutzen

Wenn Sie mehrere GPU-Beschleunigertypen pro Cluster verwenden möchten, müssen Sie mehrere Knotenpools mit jeweils eigenem Beschleunigertyp erstellen. GKE fügt GPU-Knoten einen eindeutigen Knotenselektor hinzu, um GPU-Arbeitslasten auf Knoten mit bestimmten GPU-Typen zu verteilen:

• Schlüssel: cloud.google.com/gke-accelerator
• Wert: nvidia-tesla-k80, nvidia-tesla-p100, nvidia-tesla-p4, nvidia-tesla-v100, nvidia-tesla-t4, nvidia-tesla-a100 oder nvidia-a100-80gb.

Sie können bestimmte GPU-Typen gezielt auswählen. Dazu fügen Sie diesen Knotenselektor der Pod-Spezifikation Ihrer Arbeitslast hinzu. Beispiel:

apiVersion: v1
kind: Pod
metadata:
  name: my-gpu-pod
spec:
  containers:
  - name: my-gpu-container
    image: nvidia/cuda:11.0.3-runtime-ubuntu20.04
    command: ["/bin/bash", "-c", "--"]
    args: ["while true; do sleep 600; done;"]
    resources:
      limits:
       nvidia.com/gpu: 2
  nodeSelector:
    cloud.google.com/gke-accelerator: nvidia-tesla-k80

CUDA-Bibliotheken

CUDA® ist die NVIDIA-Plattform für paralleles Computing und das Programmiermodell für GPUs. Die NVIDIA-Gerätetreiber, die Sie im Cluster installieren, beinhalten die CUDA-Bibliotheken.

CUDA-Bibliotheken und Dienstprogramme zur Fehlerbehebung werden im Container unter /usr/local/nvidia/lib64 bzw. /usr/local/nvidia/bin zur Verfügung gestellt.

CUDA-Anwendungen, die in Pods ausgeführt werden, die NVIDIA-GPUs verwenden, müssen CUDA-Bibliotheken dynamisch erkennen. Hierfür muss /usr/local/nvidia/lib64 in der Umgebungsvariable LD_LIBRARY_PATH angegeben werden.

Informationen zum Prüfen der für Ihre CUDA-Version erforderlichen Mindest-GPU-Treiberversion finden Sie unter CUDA-Toolkit und kompatible Treiberversionen. Prüfen Sie, ob die auf den Knoten ausgeführte GKE-Patchversion eine GPU-Treiberversion enthält, die mit der ausgewählten CUDA-Version kompatibel ist. Eine Liste der GPU-Treiberversionen, die mit der GKE-Version verknüpft sind, finden Sie auf der entsprechenden Seite von Container-Optimized OS, die in der Tabelle der aktuellen GKE-Versionen verknüpft ist.

GPU-Knoten überwachen

Wenn für Ihren GKE-Cluster Systemmesswerte aktiviert sind, stehen in Cloud Monitoring die folgenden Messwerte zur Überwachung der GPU-Arbeitslastleistung zur Verfügung:

• Arbeitszyklus (container/accelerator/duty_cycle): Prozentsatz der Zeit im vergangenen Beispielzeitraum (10 Sekunden), während dessen der Beschleuniger aktiv verarbeitet wurde. Liegt zwischen 1 und 100.
• Arbeitsspeichernutzung (container/accelerator/memory_used): Menge des dem Beschleuniger zugeteilten Arbeitsspeichers in Byte.
• Speicherkapazität (container/accelerator/memory_total): Gesamter Arbeitsspeicher des Beschleunigers in Byte.

Weitere Informationen zum Überwachen Ihrer Cluster und der zugehörigen Ressourcen finden Sie unter Monitoring.

Nutzungsmesswerte ansehen

Sie können Ihre GPU-Nutzungsmesswerte für Arbeitslasten im Dashboard Arbeitslasten der Google Cloud Console aufrufen.

Gehen Sie zum Abrufen der GPU-Nutzung Ihrer Arbeitslast so vor:

1. Rufen Sie in der Google Cloud Console die Seite Arbeitslasten auf.

   Zu Arbeitslasten
2. Wählen Sie eine Arbeitslast aus.

Im Dashboard „Arbeitslasten” werden die Arbeitsspeichernutzung und -kapazität der GPUs sowie der GPU-Arbeitszyklus in Form von Diagrammen angezeigt.

Nächste Schritte

• Mehr über Knotenpools erfahren
• Minimale CPU-Plattform für Knoten verwenden