GPUs in GKE-Standardknotenpools ausführen

Auf dieser Seite erfahren Sie, wie Sie rechenintensive Arbeitslasten wie künstliche Intelligenz (KI) und Grafikbearbeitung ausführen und optimieren, indem Sie NVIDIA®-GPU-Hardwarebeschleuniger an die Knoten Ihrer GKE-Standardcluster (Google Kubernetes Engine) anschließen und verwenden. Wenn Sie stattdessen Autopilot-Pods verwenden, lesen Sie den Abschnitt GPU-Arbeitslasten in Autopilot bereitstellen.

Wenn Sie Cluster mit NVIDIA B200- oder NVIDIA H200-GPUs mit 141 GB bereitstellen möchten, lesen Sie stattdessen die folgenden Ressourcen:

Übersicht

Mit GKE können Sie Knotenpools erstellen, die mit GPUs ausgestattet sind. GPUs bieten Rechenleistung für Deep-Learning-Aufgaben wie Bilderkennung, Natural Language Processing und andere rechenintensive Aufgaben wie Videotranscodierung und Bildverarbeitung. Im GKE Standardmodus können Sie GPU-Hardware an Knoten in Ihren Clustern anhängen und dann GPU-Ressourcen zu containerisierten Arbeitslasten zuweisen, die auf diesen Knoten ausgeführt werden.

Weitere Informationen zu Anwendungsfällen für GPUs finden Sie auf der Seite GPUs von Google Cloud. Weitere Informationen zu GPUs in GKE und den Unterschieden zwischen dem Standardmodus und dem Autopilot-Modus finden Sie unter GPUs in GKE.

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.

Ab Version 1.29.2-gke.1108000 können Sie jetzt GPU-Knotenpools in GKE Sandbox erstellen. Weitere Informationen finden Sie unter GKE Sandbox und GKE Sandbox konfigurieren.

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.

Voraussetzungen für GPUs in GKE

GPUs in GKE setzen Folgendes voraus:

  • Kubernetes-Version: Die verfügbaren Versionen hängen davon ab, welches Knoten-Image die GPUs verwenden:

  • GPU-Kontingent: Sie müssen ein Compute Engine-GPU-Kontingent in der gewählten 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, erhält Ihr Projekt nach dem Einreichen Ihrer Kontingentanfrage automatisch ein Kontingent.

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

  • NVIDIA-GPU-Treiber: Wenn Sie einen Cluster oder einen Knotenpool erstellen, können Sie GKE anweisen, automatisch eine Treiberversion basierend auf Ihrer GKE-Version zu installieren. Wenn Sie GKE nicht anweisen, GPU-Treiber automatisch zu installieren, müssen Sie die Treiber manuell installieren.

  • Maschinenserie: Der GPU-Typ, den Sie verwenden können, hängt von der Maschinenserie ab:

    Prüfen Sie, ob in Ihrem Projekt ein ausreichendes Kontingent für die Maschinenserie vorhanden ist, die dem ausgewählten GPU-Typ und der ausgewählten Menge entspricht.

  • GPUs auf Ubuntu-Knoten: Wenn Sie GPUs mit Ubuntu-Knoten verwenden, gelten die folgenden Anforderungen:

    • Treiberkompatibilität:

      • L4-GPUs und H100-GPUs: NVIDIA-Treiberversion 535 oder höher

      • H200-GPUs: NVIDIA-Treiberversion 550 oder höher

      • B200-GPUs: NVIDIA-Treiberversion 570 oder höher

      Wenn eine erforderliche Treiberversion oder eine höhere Version nicht die Standardversion in Ihrer GKE-Version ist, müssen Sie einen unterstützten Treiber auf Ihren Knoten manuell installieren.

    • Versionskompatibilität:

      Wenn Sie die A4-Maschinenserie in Ubuntu-Knotenpools verwenden, müssen Sie eine GKE-Version verwenden, die das ubuntu-gke-2404-1-32-amd64-v20250730-Image oder eine neuere Version des Knoten-Images enthält. Die Mindestversionen für GKE sind:

      • 1.32.7-gke.1067000 oder höher für GKE-Version 1.32
      • 1.33.3-gke.1247000 oder höher für GKE-Version 1.33
Best Practice:

Verwenden Sie Container-Optimized OS für GPU-Knoten. Container-Optimized OS enthält die erforderlichen Treiber zur Unterstützung der jeweiligen GKE-Version für GPU-Knoten.

Einschränkungen bei der Verwendung von GPUs in GKE

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.
  • GPUs werden in Windows Server-Knotenpools nicht unterstützt.
  • GKE-Standardcluster mit Version 1.28.2-gke.1098000 oder früher unterstützen keine automatische Knotenbereitstellung zum Erstellen von Knotenpools mit L4-GPUs. Cluster mit früheren Versionen unterstützen jedoch Cluster Autoscaler, um vorhandene Knotenpools zu skalieren.

Verfügbarkeit von GPUs nach Regionen und Zonen

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 Google Cloud GPU-Seite.

Ausreichendes GPU-Kontingent sicherstellen

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 Anzahl von GPUs pro Knoten multipliziert mit der maximalen Anzahl von Knoten in Ihrem Cluster 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 GPU-Kontingente.

Verwenden Sie die Google Cloud Console, um nach GPU-Kontingenten zu suchen und eine Kontingentanfrage zu senden:

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

    Kontingente aufrufen

  2. Gehen Sie im Feld Filter folgendermaßen vor:

    1. Wählen Sie das Attribut Kontingent aus, geben Sie den Namen des GPU-Modells ein und drücken Sie die Eingabetaste.
    2. Optional: Wenn Sie erweiterte Filter anwenden möchten, um die Ergebnisse einzugrenzen, wählen Sie das Attribut Dimensionen (z. B. Standorte) aus, fügen Sie den Namen der Region oder Zone, die Sie verwenden, hinzu und drücken Sie die Eingabetaste.

  3. Wählen Sie in der Liste der GPU-Kontingente das Kontingent aus, das Sie ändern möchten.

  4. Klicken Sie auf Kontingente bearbeiten. Ein Anfrageformular wird geöffnet.

  5. Füllen Sie das Feld Neues Kontingentlimit für jede Kontingentanfrage aus.

  6. Geben Sie im Feld Beschreibung der Anfrage die Details zur Anfrage ein.

  7. Klicken Sie auf Weiter.

  8. Klicken Sie im Dialogfeld zur Bestätigung der Überschreibung auf Bestätigen.

  9. Geben Sie im Bildschirm Kontaktdetails Ihren Namen und eine Telefonnummer ein, mit denen die Genehmiger Ihre Anfrage zur Kontingentänderung bearbeiten können.

  10. Klicken Sie auf Anfrage senden.

  11. Sie erhalten eine Bestätigungs-E-Mail, um die Kontingentänderung zu verfolgen.

GPUs in GKE Standard-Clustern ausführen

Wenn Sie GPUs in GKE Standard-Clustern ausführen möchten, erstellen Sie einen Knotenpool mit angehängten GPUs.

Best Practice:

Um die Kosteneffizienz, Zuverlässigkeit und Verfügbarkeit von GPUs in GKE zu verbessern, führen Sie die folgenden Aktionen aus:

  • Erstellen Sie separate GPU-Knotenpools. Beschränken Sie für jeden Knotenpool den Knotenstandort auf die Zonen, in denen die gewünschten GPUs verfügbar sind.
  • Aktivieren Sie Autoscaling in jedem Knotenpool.
  • Verwenden Sie regionale Cluster, um die Verfügbarkeit zu verbessern, indem Sie die Kubernetes-Steuerungsebene zonenübergreifend in der Region replizieren.
  • Konfigurieren Sie GKE so, dass die standardmäßigen oder neuesten GPU-Treiber auf den Knotenpools automatisch installiert werden, sodass Sie Ihre Treiberversionen nicht manuell installieren und verwalten müssen.

Wie in den folgenden Abschnitten beschrieben, verwendet GKE Knotenmarkierungen und Toleranzen, damit Pods nicht auf ungeeigneten Knoten geplant werden.

GPU-Knotenpools kennzeichnen, um eine unangemessene Planung zu vermeiden

Mit einer Knotenmarkierung können Sie einen Knoten so markieren, dass der Planer dessen Verwendung für bestimmte Pods vermeidet oder unterbindet. Je nach den folgenden Szenarien fügt GKE automatisch Taints hinzu oder Sie können sie manuell hinzufügen:

  • 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

    GKE fügt diese Markierung nur hinzu, wenn im Cluster mindestens ein Knotenpool ohne GPU vorhanden ist.

  • Wenn Sie einen GPU-Knotenpool zu einem Cluster hinzufügen, der nur GPU-Knotenpools enthält, oder wenn Sie einen neuen Cluster erstellen, bei dem GPUs an den Standardknotenpool angehängt sind, können Sie Markierungen für den neuen Knotenpool manuell festlegen. Verwenden Sie dazu die folgenden Werte:

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

  • Wenn Sie dem Cluster in Zukunft einen Knotenpool ohne GPUs hinzufügen, wendet GKE diese Markierung nicht rückwirkend auf vorhandene GPU-Knoten an. Sie müssen Markierungen manuell für den neuen Knotenpool festlegen.

Planung mithilfe einer Toleranz automatisch einschränken

Mithilfe von Toleranzen können Sie Pods festlegen, die auf markierten Knoten verwendet werden können. GKE wendet automatisch eine Toleranz an, sodass nur Pods, die GPUs anfordern, auf GPU-Knoten geplant werden. Dadurch wird effizienteres Autoscaling ermöglicht, da Ihre GPU-Knoten schnell herunterskaliert werden können, wenn nicht genügend Pods GPUs anfordern. Dazu führt GKE den Admission-Controller ExtendedResourceToleration aus.

GPU-Knotenpool erstellen

Zum Erstellen eines separaten GPU-Knotenpools in einem vorhandenen Cluster können Sie dieGoogle Cloud Console oder die Google Cloud CLI verwenden. Sie können Terraform auch zur Bereitstellung Ihrer GKE-Cluster und Ihres GPU-Knotenpools verwenden.

GKE unterstützt die automatische Installation von NVIDIA-Treibern in den folgenden Szenarien:

  • Bei GKE-Clustern mit der Steuerungsebenenversion 1.32.2-gke.1297000 und höher installiert GKE automatisch die standardmäßige NVIDIA-Treiberversion für alle GPU-Knoten, einschließlich der Knoten, die mit der automatischen Knotenbereitstellung erstellt wurden.
  • Bei GKE-Clustern mit der Steuerungsebenenversion 1.30.1-gke.1156000 bis 1.32.2-gke.1297000 installiert GKE automatisch die standardmäßige NVIDIA-Treiberversion für Knoten, die nicht mit der automatischen Knotenbereitstellung erstellt wurden.
  • Sie können optional die neueste verfügbare Treiberversion auswählen oder die automatische Treiberinstallation explizit deaktivieren. In Versionen vor 1.30.1-gke.1156000 installiert GKE standardmäßig keinen Treiber, wenn Sie beim Erstellen oder Aktualisieren des Knotenpools keine Treiberversion angeben.

gcloud

Führen Sie zum Erstellen eines Knotenpools mit GPUs in einem Cluster den folgenden Befehl aus:

gcloud container node-pools create POOL_NAME \
  --accelerator type=GPU_TYPE,count=AMOUNT,gpu-driver-version=DRIVER_VERSION \
  --machine-type MACHINE_TYPE \
  --cluster CLUSTER_NAME \
  --location CONTROL_PLANE_LOCATION \
  --node-locations COMPUTE_ZONE1[,COMPUTE_ZONE2] \
  [--sandbox=type=gvisor]
  [--enable-autoscaling \
   --min-nodes MIN_NODES \
   --max-nodes MAX_NODES] \
  [--scopes=SCOPES] \
  [--service-account=SERVICE_ACCOUNT] \
  [--reservation-affinity=specific --reservation=RESERVATION_NAME]

Dabei gilt:

  • POOL_NAME: Der Name, den Sie für den Knotenpool auswählen.
  • GPU_TYPE: Der Typ des von Ihnen verwendeten GPU-Beschleunigers. Beispiel: nvidia-tesla-t4
  • AMOUNT: Die Anzahl der GPUs, die an Knoten im Knotenpool angehängt werden sollen.

  • DRIVER_VERSION: die zu installierende NVIDIA-Treiberversion. Kann eines der Folgenden sein:

    • default: Installieren Sie die Standardtreiberversion für die GKE-Version Ihrer Knoten. In der GKE-Version 1.30.1-gke.1156000 und höher ist dies die Standardoption, wenn Sie das Flag gpu-driver-version weglassen. In früheren Versionen installiert GKE keinen Treiber, wenn Sie dieses Flag weglassen.
    • latest: Installieren Sie die neueste verfügbare Treiberversion für Ihre GKE-Version. Nur für Knoten verfügbar, die Container-Optimized OS verwenden.
    • disabled: Automatische Treiberinstallation überspringen. Sie müssen einen Treiber manuell installieren, nachdem Sie den Knotenpool erstellt haben. In GKE-Versionen vor 1.30.1-gke.1156000 ist dies die Standardoption.

    Die Option gpu-driver-version ist nur für die GKE-Version 1.27.2-gke.1200 und höher verfügbar. In früheren Versionen lassen Sie dieses Flag weg und installieren Sie einen Treiber manuell, nachdem Sie den Knotenpool erstellt haben. Wenn Sie einen vorhandenen Cluster oder Knotenpool auf diese Version oder höher aktualisieren, installiert GKE automatisch die Standardtreiberversion, die der GKE-Version entspricht, es sei denn, Sie geben beim Start des Upgrades etwas anderes an.

  • MACHINE_TYPE: Der Compute Engine-Maschinentyp für die Knoten. Erforderlich für die folgenden GPU-Typen:

    • NVIDIA B200-GPUs (dem Beschleunigertyp nvidia-b200 und der A4-Maschinenserie entsprechend)
    • NVIDIA H200-GPUs mit 141 GB (dem Beschleunigertyp nvidia-h200-141gb und dem Maschinentyp A3 Ultra entsprechend) oder NVIDIA H100-GPUs mit 80 GB (dem Beschleunigertyp nvidia-h100-80gb und dem Maschinentyp A3 High entsprechend) oder NVIDIA H100-Mega-GPUs mit 80 GB (dem Beschleunigertyp nvidia-h100-mega-80gb und dem Maschinentyp A3 Mega entsprechend). Weitere Informationen finden Sie in der Compute Engine-Dokumentation unter A3-Maschinenserie.
    • NVIDIA A100-GPUs mit 40 GB (dem Beschleunigertyp nvidia-tesla-a100 und dem Maschinentyp A2 Standard entsprechend) oder NVIDIA A100-GPUs mit 80 GB (dem Beschleunigertyp nvidia-a100-80gb und dem Maschinentyp A2 Ultra entsprechend). Weitere Informationen finden Sie in der Compute Engine-Dokumentation unter A2-Maschinenserie.
    • NVIDIA L4-GPUs (dem Beschleunigertyp nvidia-l4 und der G2-Maschinenserie entsprechend).

    Für alle anderen GPUs ist dieses Flag optional.

  • CLUSTER_NAME: Der Name des Clusters, in dem der Knotenpool erstellt werden soll.

  • CONTROL_PLANE_LOCATION: Der Compute Engine-Standort der Steuerungsebene des Clusters. Geben Sie für regionale Cluster eine Region und für zonale Cluster eine Zone an.

  • COMPUTE_ZONE1,COMPUTE_ZONE2,[...]: Die spezifischen Zonen, in denen GKE die GPU-Knoten erstellt. Die Zonen müssen sich in derselben Region befinden wie der Cluster, angegeben durch das Flag --location. Die definierten GPU-Typen müssen in jeder ausgewählten Zone verfügbar sein. Wenn Sie eine Reservierung verwenden, müssen Sie die Zonen angeben, in denen die Reservierung Kapazität hat. Wir empfehlen, beim Erstellen des Knotenpools immer das Flag --node-locations zu verwenden, um die Zone oder die Zonen anzugeben, in denen die angeforderten GPUs enthalten sind.

  • Optional können Sie Knotenpools erstellen, um Sandbox-Arbeitslasten mit gVisor auszuführen. Weitere Informationen finden Sie unter GKE Sandbox.

  • MIN_NODES: Die Mindestanzahl von Knoten für jede Zone im Knotenpool zu jederzeit. Dieser Wert ist nur relevant, wenn das Flag --enable-autoscaling verwendet wird.

  • MAX_NODES: Die maximale Anzahl von Knoten für jede Zone im Knotenpool zu jeder Zeit. Dieser Wert ist nur relevant, wenn das Flag --enable-autoscaling verwendet wird.

  • Optional können Sie den GPU-Knotenpool mit einem benutzerdefinierten Dienstkonto erstellen, indem Sie die folgenden Flags anhängen. Wenn kein Wert angegeben ist, verwendet der Knotenpool das Compute Engine-Standarddienstkonto:

    • SERVICE_ACCOUNT: Der Name des IAM-Dienstkontos, das von Ihren Knoten verwendet wird.
    • SCOPES: Eine durch Kommas getrennte Liste der zu gewährenden Zugriffsbereiche. Achten Sie darauf, dass einer der Bereiche storage-ro oder https://www.googleapis.com/auth/devstorage.read_only ist. Weitere Informationen zu Bereichen finden Sie unter Zugriffsbereiche festlegen. Wenn Sie das Flag scope weglassen, schlägt die Erstellung des GPU-Knotenpools mit dem Fehler AccessDenied failed to download gpu_driver_versions.bin from GCS bucket fehl.

  • RESERVATION_NAME: Der Name der GPU-Reservierung, die verwendet werden soll. Geben Sie das Flag --reservation mit --reservation-affinity=specific an, um GPU-Kapazität aus einer bestimmten Reservierung zu verwenden. Weitere Informationen finden Sie unter Eine bestimmte Reservierung für ein einzelnes Projekt verwenden.

Mit dem folgenden Befehl wird beispielsweise ein hochverfügbarer Autoscaling-Knotenpool (p100) mit zwei P100-GPUs für jeden Knoten im regionalen Cluster p100-cluster erstellt. GKE installiert automatisch die Standardtreiber auf diesen Knoten.

gcloud container node-pools create p100 \
  --accelerator type=nvidia-tesla-p100,count=2,gpu-driver-version=default \
  --cluster p100-cluster \
  --location us-central1 \
  --node-locations us-central1-c \
  --min-nodes 0 --max-nodes 5 --enable-autoscaling

Console

So erstellen Sie einen Knotenpool mit GPUs:

  1. Öffnen Sie in der Google Cloud Console die Seite Google Kubernetes Engine.

    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 Maschinenkonfiguration 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. Wählen Sie im Abschnitt GPU-Treiberinstallation eine der folgenden Methoden aus:

    • Von Google verwaltet: GKE installiert automatisch einen Treiber. Wenn Sie diese Option auswählen, wählen Sie im Drop-down-Menü Version eine der folgenden Optionen aus:
      • Standard: Installiert die Standard-Treiberversion.
      • Aktuell: Installieren Sie die neueste verfügbare Treiberversion.
    • Vom Kunden verwaltet: GKE installiert keinen Treiber. Sie müssen einen kompatiblen Treiber manuell installieren. Folgen Sie dazu der Anleitung unter NVIDIA-GPU-Gerätetreiber installieren.

  11. Klicken Sie auf Erstellen.

Terraform

Mit einem Terraform-Modul können Sie einen regionalen Cluster mit GPUs mit Terraform erstellen.

  1. Legen Sie die Terraform-Variablen fest, indem Sie den folgenden Block in die Datei variables.tf einfügen:

    variable "project_id" {
  default     = PROJECT_ID
  description = "the gcp_name_short project where GKE creates the cluster"
}

variable "region" {
  default     = CLUSTER_REGION
  description = "the gcp_name_short region where GKE creates the cluster"
}

variable "zone" {
  default     = "COMPUTE_ZONE"
  description = "the GPU nodes zone"
}

variable "cluster_name" {
  default     = "CLUSTER_NAME"
  description = "the name of the cluster"
}

variable "gpu_type" {
  default     = "GPU_TYPE"
  description = "the GPU accelerator type"
}

variable "gpu_driver_version" {
  default = "DRIVER_VERSION"
  description = "the NVIDIA driver version to install"
}

variable "machine_type" {
  default = "MACHINE_TYPE"
  description = "The Compute Engine machine type for the VM"
}

    Dabei gilt:

    • PROJECT_ID: Ihre Projekt-ID.
    • CLUSTER_NAME ist der Name des GKE-Clusters.
    • CLUSTER_REGION. die Compute-Region für den Cluster.
    • COMPUTE_ZONE: Die spezifische Zone, in der GKE die GPU-Knoten erstellt. Die Zone muss sich in derselben Region befinden, die durch die Variable region angegeben wird. In diesen Zonen müssen die von Ihnen definierten GPU-Typen verfügbar sein. Weitere Informationen finden Sie unter Verfügbarkeit von GPUs nach Regionen und Zonen.
    • GPU_TYPE: Der Typ des von Ihnen verwendeten GPU-Beschleunigers. Beispiel: nvidia-tesla-t4

    • DRIVER_VERSION: die GPU-Treiberversion, die von GKE automatisch installiert werden soll. Dieses Feld ist optional. Folgende Werte werden unterstützt:

      • INSTALLATION_DISABLED: Automatische Installation von GPU-Treibern deaktivieren. Sie müssen die Treiber manuell installieren, damit Ihre GPUs funktionieren. In GKE-Versionen vor 1.30.1-gke.1156000 ist dies die Standardoption, wenn Sie dieses Feld weglassen.
      • DEFAULT: Die Standardtreiberversion für die Betriebssystemversion Ihres Knotens wird automatisch installiert. In der GKE-Version 1.30.1-gke.1156000 und höher ist dies die Standardoption, wenn Sie dieses Feld weglassen. In früheren Versionen installiert GKE keinen Treiber, wenn Sie dieses Feld weglassen.
      • LATEST: Die neueste verfügbare Treiberversion für die Betriebssystemversion Ihres Knotens wird automatisch installiert. Nur für Knoten verfügbar, die Container-Optimized OS verwenden.

      Wenn Sie dieses Feld weglassen, installiert GKE Treiber nicht automatisch. Dieses Feld wird in Knotenpools, die die automatische Knotenbereitstellung verwenden, nicht unterstützt. Informationen zur manuellen Installation eines Treibers finden Sie in diesem Dokument unter NVIDIA-GPU-Treiber manuell installieren.

    • MACHINE_TYPE: Der Compute Engine-Maschinentyp für die Knoten. Erforderlich für die folgenden GPU-Typen:

      • NVIDIA B200-GPUs (dem Beschleunigertyp nvidia-b200 und der A4-Maschinenserie entsprechend)
      • NVIDIA H200-GPUs mit 141 GB (dem Beschleunigertyp nvidia-h200-141gb und dem Maschinentyp A3 Ultra entsprechend) oder NVIDIA H100-GPUs mit 80 GB (dem Beschleunigertyp nvidia-h100-80gb und dem Maschinentyp A3 High entsprechend) oder NVIDIA H100-Mega-GPUs mit 80 GB (dem Beschleunigertyp nvidia-h100-mega-80gb und dem Maschinentyp A3 Mega entsprechend). Weitere Informationen finden Sie in der Compute Engine-Dokumentation unter A3-Maschinenserie.
      • NVIDIA A100-GPUs mit 40 GB (dem Beschleunigertyp nvidia-tesla-a100 und dem Maschinentyp A2 Standard entsprechend) oder NVIDIA A100-GPUs mit 80 GB (dem Beschleunigertyp nvidia-a100-80gb und dem Maschinentyp A2 Ultra entsprechend). Weitere Informationen finden Sie in der Compute Engine-Dokumentation unter A2-Maschinenserie.
      • NVIDIA L4-GPUs (dem Beschleunigertyp nvidia-l4 und der G2-Maschinenserie entsprechend).

      Für alle anderen GPUs ist dieses Flag optional.

  2. Fügen Sie Ihrer Terraform-Konfiguration den folgenden Block hinzu:

    provider "google" {
  project = var.project_id
  region  = var.region
}

resource "google_container_cluster" "ml_cluster" {
  name               = var.cluster_name
  location           = var.region
  initial_node_count = 1
}

resource "google_container_node_pool" "gpu_pool" {
  name           = google_container_cluster.ml_cluster.name
  location       = var.region
  node_locations = [var.zones]
  cluster        = google_container_cluster.ml_cluster.name
  node_count     = 3

  autoscaling {
    total_min_node_count = "1"
    total_max_node_count = "5"
  }

  management {
    auto_repair  = "true"
    auto_upgrade = "true"
  }

  node_config {
    oauth_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/trace.append",
      "https://www.googleapis.com/auth/service.management.readonly",
      "https://www.googleapis.com/auth/servicecontrol",
    ]

    labels = {
      env = var.project_id
    }

    guest_accelerator {
      type  = var.gpu_type
      count = 1
      gpu_driver_installation_config {
        gpu_driver_version = var.gpu_driver_version
      }
    }

    image_type   = "cos_containerd"
    machine_type = var.machine_type
    tags         = ["gke-node", "${var.project_id}-gke"]

    disk_size_gb = "30"
    disk_type    = "pd-standard"

    metadata = {
      disable-legacy-endpoints = "true"
    }
  }
}

Terraform ruft Google Cloud APIs auf, um einen neuen Cluster mit einem Knotenpool zu erstellen, der GPUs verwendet. Der Knotenpool hat anfangs drei Knoten und das Autoscaling ist aktiviert. Weitere Informationen zu Terraform finden Sie in der google_container_node_pool-Ressourcenspezifikation auf terraform.io.

Best Practice:

Entfernen Sie alle in der Konfigurationsdatei definierten Ressourcen mit dem Befehl terraform destroy, um weitere Kosten zu vermeiden.

Best Practice: Sie können auch einen neuen Cluster mit GPUs erstellen und Zonen mit dem Flag --node-locations angeben. Wir empfehlen jedoch, einen separaten GPU-Knotenpool in einem vorhandenen Cluster zu erstellen, wie in diesem Abschnitt gezeigt.

NVIDIA-GPU-Treiber manuell installieren

Sie können NVIDIA-GPU-Treiber manuell auf Ihren Knoten installieren, indem Sie ein Installations-DaemonSet auf diesen Knoten bereitstellen. Verwenden Sie die manuelle Installation in den folgenden Situationen:

  • Sie haben bei der Erstellung eines GPU-Knotenpools die automatische Installation von Gerätetreibern deaktiviert.
  • Sie verwenden eine GKE-Version, die älter ist als die unterstützte Mindestversion für die automatische Installation.
  • Für Ihre Arbeitslast ist eine bestimmte NVIDIA-Treiberversion erforderlich, die bei der automatischen Installation nicht als Standard- oder neuester Treiber verfügbar ist. Beispiel: GPUs mit Confidential GKE Nodes verwenden.
Best Practice:

Verwenden Sie nach Möglichkeit die automatische Treiberinstallation. Geben Sie dazu beim Erstellen Ihres Standardclusters die Option gpu-driver-version im Flag --accelerator an. Wenn Sie das DaemonSet für die Installation verwendet haben, um GPU-Treiber am oder vor dem 25. Januar 2023 manuell zu installieren, müssen Sie das DaemonSet möglicherweise noch einmal anwenden, um eine Version zu erhalten, die Knoten mit einer automatischen Treiberinstallation ignoriert.

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 Cloud Storage 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.

Die folgende Anleitung zeigt, wie Sie die Treiber auf Container-Optimized OS (COS) und Ubuntu-Knoten und mit Terraform installieren.

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

  • Wenn Sie eine neuere GPU-Treiberversion aus der Tabelle mit den Treiberversionen in diesem Abschnitt installieren möchten, führen Sie den folgenden Befehl aus:

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

  • Führen Sie den folgenden Befehl aus, um eine GPU-Treiberversion zu installieren, die GPU-Arbeitslasten auf Confidential GKE Nodes unterstützt:

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

Die Installation kann mehrere Minuten dauern. Nach Abschluss der Installation stellt das NVIDIA-GPU-Geräte-Plug-in die NVIDIA-GPU-Kapazität über die Kubernetes API zur Verfügung.

Jede Version von Container-Optimized OS hat mindestens eine unterstützte NVIDIA GPU-Treiberversion. Weitere Informationen zum Zuordnen der GPU-Treiberversion zur GKE-Version finden Sie in den folgenden Abschnitten:

GKE-NVIDIA-Treiberversionen
1.33 R535 (Standard), R570, R575 oder R580
1,32 R535 (Standard), R570, R575 oder R580
1,31 R535 (Standard), R570, R575 oder R580
1,30 R535 (Standard) oder R550
1.29 R535 (Standard) oder R550
1.28 R535 (Standard) oder R550
1.27 R470 (Standard), R525, R535 oder R550
1.26 R470 (Standard), R525, R535 oder R550

Ubuntu

Das Installations-DaemonSet, das Sie bereitstellen, hängt vom GPU-Typ und von der GKE-Knotenversion ab:

  • Führen Sie für alle GPUs außer NVIDIA H200-GPUs den folgenden Befehl aus:

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

  • Installieren Sie für NVIDIA H200-GPUs den R550-Treiber:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/refs/heads/master/nvidia-driver-installer/ubuntu/daemonset-preloaded-R550.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-API verfügbar gemacht.

In der folgenden Tabelle sind die verfügbaren Treiberversionen in jeder GKE-Version aufgeführt:

Ubuntu-GPU-Treiber und GKE-Versionen
1.33 R535 (Standard)
1,32 R535 (Standard)
1,31 R535 (Standard)
1,30 R470 oder R535
1.29 R470 oder R535
1.28 R470 oder R535
1.27 R470 oder R535
1.26 R470 oder R535

Terraform

Sie können Terraform verwenden, um die Standard-GPU-Treiberversion basierend auf dem Knotentyp zu installieren. In beiden Fällen müssen Sie den Terraform-Ressourcentyp kubectl_manifest konfigurieren.

  • Fügen Sie der Terraform-Konfiguration den folgenden Block hinzu, um das DaemonSet unter COS zu installieren:

      data "http" "nvidia_driver_installer_manifest" {
    url = "https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml"
  }

  resource "kubectl_manifest" "nvidia_driver_installer" {
    yaml_body = data.http.nvidia_driver_installer_manifest.body
  }

  • Fügen Sie der Terraform-Konfiguration den folgenden Block hinzu, um DaemonSet unter Ubuntu zu installieren:

      data "http" "nvidia_driver_installer_manifest" {
    url = "https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/ubuntu/daemonset-preloaded.yaml"
  }

  resource "kubectl_manifest" "nvidia_driver_installer" {
    yaml_body = data.http.nvidia_driver_installer_manifest.body
  }

GKE-Version und Container-Optimized OS-Knoten-Image-Version der GPU-Treiberversion zuordnen

So finden Sie die GPU-Treiberversionen, die den GKE-Versionen und Container-Optimized OS-Knoten-Image-Versionen zugeordnet sind:
  1. Container-Optimized OS-Knoten-Image-Versionen GKE-Patchversionen zuordnen für die spezifische GKE-Version, in der Sie die GPU-Treiberversion suchen. Beispiel: 1.33.0-gke.1552000 verwendet cos-121-18867-90-4.
  2. Wählen Sie den Meilenstein der Container-Optimized OS-Knoten-Image-Version in den Versionshinweisen zu Container-Optimized OS aus. Wählen Sie beispielsweise Meilenstein 121 für cos-121-18867-90-4 aus.
  3. Suchen Sie auf der Seite mit den Versionshinweisen für den jeweiligen Meilenstein nach der Versionshinweis, die der jeweiligen Container-Optimized OS-Knotenbildversion entspricht. Ein Beispiel finden Sie in den Versionshinweisen zu Container-Optimized OS: Meilenstein 121 unter cos-121-18867-90-4. Klicken Sie in der Tabelle in der Spalte GPU-Treiber auf Liste ansehen, um die Informationen zur GPU-Treiberversion aufzurufen.

Treiber mithilfe der automatischen Knotenbereitstellung mit GPUs installieren

Wenn Sie die automatische Knotenbereitstellung mit GPUs verwenden, haben die automatisch bereitgestellten Knotenpools standardmäßig nicht genügend Bereiche, um die Treiber zu installieren. Ändern Sie zum Zuweisen der erforderlichen Bereiche die Standardbereiche für die automatische Knotenbereitstellung, um wie im folgenden Beispiel logging.write, monitoring, devstorage.read_only und compute hinzuzufügen.

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

Bei Clustern mit GKE-Version 1.32.2-gke.1297000 und höher installiert GKE automatisch die standardmäßige NVIDIA-Treiberversion für alle GPU-Knoten, einschließlich der Knoten, die mit der automatischen Knotenbereitstellung erstellt wurden. Sie können die folgende Anleitung für Cluster überspringen, auf denen GKE-Version 1.32.2-gke.1297000 und höher ausgeführt wird.

In GKE-Version 1.29.2-gke.1108000 und höher können Sie eine GPU-Treiberversion für GKE auswählen, die automatisch in automatisch bereitgestellten GPU-Knoten installiert wird. Fügen Sie Ihrem Manifest das folgende Feld hinzu:

spec:
  nodeSelector:
    cloud.google.com/gke-gpu-driver-version: "DRIVER_VERSION"

Ersetzen Sie DRIVER_VERSION durch einen der folgenden Werte:

  • default: Der standardmäßige, stabile Treiber für die GKE-Version Ihres Knotens.
  • latest: Die neueste verfügbare Treiberversion für die GKE-Version Ihres Knotens.
  • disabled: Automatische GPU-Treiberinstallation deaktivieren. Wenn dieser Wert ausgewählt ist, müssen Sie die Treiber manuell installieren, um Ihre GPUs auszuführen. In GKE-Versionen vor 1.32.2-gke.1297000 ist dies die Standardoption, wenn Sie den Knotenselektor weglassen.

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

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

Das folgende Manifest ist ein Beispiel für eine Pod-Spezifikation, die GPUs nutzt:

apiVersion: v1
kind: Pod
metadata:
  name: my-gpu-pod
spec:
  # Optional: Use GKE Sandbox
  # runtimeClassName: gvisor
  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: Der Typ des von Ihnen verwendeten GPU-Beschleunigers. Beispiel: nvidia-tesla-t4

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-t4

Knotenpools mit Beschleunigern (GPUs und TPUs) aktualisieren

GKE aktualisiert automatisch Standardcluster, einschließlich Knotenpools. Sie können Knotenpools auch manuell aktualisieren, wenn Sie die Knoten früher auf eine neuere Version aktualisieren möchten. Um die Funktionsweise von Upgrades für Ihren Cluster zu steuern, verwenden Sie Release-Versionen, Wartungsfenster und -ausschlüsse und Roll-out-Sequenzierung.

Sie können auch eine Strategie für Knotenupgrades für Ihren Knotenpool konfigurieren, z. B. Surge-Upgrades, Blau/Grün-Upgrades oder Upgrades mit kurzer Lebensdauer. Durch die Konfiguration dieser Strategien können Sie dafür sorgen, dass die Knotenpools so aktualisiert werden, dass das optimale Gleichgewicht zwischen Geschwindigkeit und Unterbrechung für Ihre Umgebung erreicht wird. Bei TPU-Slice-Knotenpools mit mehreren Hosts erstellt GKE den gesamten Knotenpool atomar in einem einzigen Schritt neu anstelle die konfigurierten Strategie für Knotenupgrades zu verwenden. Weitere Informationen finden Sie in der Definition der Atomarität unter Terminologie in Bezug auf TPU in GKE.

Wenn Sie eine Knotenupgrade-Strategie verwenden, muss GKE je nach Konfiguration vorübergehend zusätzliche Ressourcen bereitstellen. Wenn Google Clouddie Kapazität für die Ressourcen Ihres Knotenpools begrenzt hat, z. B. wenn beim Versuch, mehr Knoten mit GPUs oder TPUs zu erstellen, Fehler zur Ressourcenverfügbarkeit angezeigt werden, finden Sie weitere Informationen unter Upgrade in einer ressourcenbeschränkten Umgebung durchführen.

Informationen zu NVIDIA CUDA-X-Bibliotheken

CUDA® ist die NVIDIA-Plattform für paralleles Computing und das Programmiermodell für GPUs. Wenn Sie CUDA-Anwendungen verwenden möchten, müssen die Bibliotheken im verwendeten Image vorhanden sein. Wenn Sie die NVIDIA CUDA-X-Bibliotheken hinzufügen möchten, können Sie Ihr eigenes Image erstellen und verwenden. Fügen Sie dazu die folgenden Werte in die Umgebungsvariable LD_LIBRARY_PATH in Ihrer Containerspezifikation ein:

  • /usr/local/nvidia/lib64: der Speicherort der NVIDIA-Gerätetreiber.
  • /usr/local/cuda-CUDA_VERSION/lib64: der Speicherort der NVIDIA CUDA-X-Bibliotheken auf dem Knoten.

    Ersetzen Sie CUDA_VERSION durch die von Ihnen verwendete CUDA-X-Image-Version. Einige Versionen enthalten auch Debugging-Dienstprogramme in /usr/local/nvidia/bin. Weitere Informationen finden Sie im NVIDIA CUDA-Image auf DockerHub.

    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. Weitere Informationen zum Zuordnen der GPU-Treiberversion zur GKE-Version finden Sie unter GKE-Version und Container-Optimized OS-Knoten-Image-Version der GPU-Treiberversion zuordnen.

Leistung von GPU-Knoten-Arbeitslasten ü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.

Diese Messwerte gelten auf Containerebene (container/accelerator) und werden nicht für Container erfasst, die auf einer GPU geplant sind, die GPU-Zeitfreigabe oder NVIDIA MPS verwendet.

Sie können vordefinierte Dashboards verwenden, um Ihre Cluster mit GPU-Knoten zu überwachen. Weitere Informationen finden Sie unter Beobachtbarkeitsmesswerte aufrufen. Allgemeine Informationen zum Überwachen Ihrer Cluster und der zugehörigen Ressourcen finden Sie unter Beobachtbarkeit für GKE.

Nutzungsmesswerte für Arbeitslasten ansehen

Sie können Ihre GPU-Nutzungsmesswerte für Arbeitslasten im Dashboard Arbeitslasten der Google Cloud -Konsole 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.

NVIDIA Data Center GPU Manager-Messwerte (DCGM) ansehen

Sie können NVIDIA DCGM-Messwerte mit Google Cloud Managed Service for Prometheus erfassen und visualisieren. Bei Autopilot-Clustern installiert GKE die Treiber. Bei Standardclustern müssen Sie die NVIDIA-Treiber installieren.

Eine Anleitung zum Bereitstellen des von GKE verwalteten DCGM-Pakets finden Sie unter NVIDIA Data Center GPU Manager-Messwerte (DCGM) erfassen und ansehen.

Ordnungsgemäße Beendigung von GPU-Knoten konfigurieren

In GKE-Clustern mit der Steuerungsebene, auf der 1.29.1-gke.1425000 oder höher ausgeführt wird, unterstützen GPU-Knoten SIGTERM-Signale, die den Knoten über ein bevorstehendes Herunterfahren informieren. Die Benachrichtigung zum bevorstehenden Herunterfahren kann in GPU-Knoten bis zu 60 Minuten konfiguriert werden.

Wenn Sie GKE so konfigurieren möchten, dass Ihre Arbeitslasten innerhalb dieses Benachrichtigungszeitraums ordnungsgemäß beendet werden, folgen Sie der Anleitung unter GKE-Knotenunterbrechungen für GPUs und TPUs verwalten.

Nächste Schritte