GPUs in GKE-Standardknotenpools ausführen

Auf dieser Seite erfahren Sie, wie Sie verarbeitungsintensive 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 Hilfeartikel GPU-Arbeitslasten in Autopilot bereitstellen.

Übersicht

Mit GKE können Sie Knotenpools mit GPUs erstellen. 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 Google Cloud-Seite GPUs. 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-Konfiguration.

Hinweise

Führen Sie die folgenden Schritte durch, 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, müssen Sie die gcloud CLI installieren und dann initialisieren. Wenn Sie die gcloud CLI bereits installiert haben, rufen Sie die neueste Version mit gcloud components update ab.

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

  • A100-GPUs: A100-GPUs werden nur auf a2-Maschinentypen unterstützt. Achten Sie darauf, dass Ihr Kontingent für den zugrunde liegenden A2-Maschinentyp ausreicht, um die A100-GPU zu verwenden.

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

  • L4-GPUs und H100-GPUs: NVIDIA-Treiberversion 535 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.

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 Einschrä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:

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

  • Wenn Sie H100-GPUs verwenden und lokale SSDs in Ihren Pods verwenden möchten, müssen Sie explizit die genaue Anzahl der lokalen SSDs angeben, die an die zugrunde liegende A3-VM angehängt werden sollen. Geben Sie die Anzahl mit dem Flag --ephemeral-storage-local-ssd=count=SSD_COUNT für sitzungsspezifischen Speicher oder dem Flag --local-nvme-ssd-block=count=SSD_COUNT für Blockzugriff an. Wenn Sie keines dieser Flags hinzufügen, können Sie die lokalen SSDs nicht in Ihren Pods verwenden.

    Die unterstützte Maschinengröße in GKE ist a3-highgpu-8g und die entsprechende Anzahl lokaler SSDs ist 16.

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

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 und 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): Fügen Sie den Namen derRegion oder Zone ein, die Sie verwenden, und drücken Sie Eingabe.

  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:

So verbessern Sie die Kosteneffizienz, Zuverlässigkeit und Verfügbarkeit von GPUs in GKE:

  • 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 das 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 automatisch 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. 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 Kennzeichnung nur hinzu, wenn sich im Cluster ein Knotenpool ohne GPUs befindet. Wenn Sie einen GPU-Knotenpool zu einem Cluster hinzufügen, bei dem alle vorhandenen Knotenpools GPU-Knotenpools sind, oder wenn Sie einen neuen Cluster erstellen, bei dem GPUs an den Standardknotenpool angehängt sind, wird die vorherige Markierung nicht zu den GPU-Knoten hinzugefügt.

Wenn Sie dem Cluster später einen Knotenpool ohne GPUs hinzufügen, wendet GKE diese Kennzeichnung nicht rückwirkend auf vorhandene GPU-Knoten an.

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, damit 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 die Google Cloud Console oder die Google Cloud CLI verwenden. Sie können Terraform auch zur Bereitstellung Ihrer GKE-Cluster und Ihres GPU-Knotenpools verwenden.

In der GKE-Steuerungsebene der Version 1.30.1-gke.1156000 und höher installiert GKE automatisch die Standardversion des NVIDIA-Treibers für Ihre GKE-Knotenversion. Sie können optional die neueste verfügbare Treiberversion auswählen oder die automatische Treiberinstallation ausdrücklich 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 \
  --region COMPUTE_REGION --cluster CLUSTER_NAME \
  --node-locations COMPUTE_ZONE1[,COMPUTE_ZONE2] \
  [--enable-autoscaling \
   --min-nodes MIN_NODES \
   --max-nodes MAX_NODES] \
  [--ephemeral-storage-local-ssd=count=SSD_COUNT]

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

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

  • AMOUNT: Die Anzahl der GPUs, die an Knoten im Knotenpool angehängt werden sollen.

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

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

  • COMPUTE_REGION: Die Compute Engine-Region des Clusters, z. B. us-central1. Wählen Sie eine Region mit mindestens einer Zone aus, in der die angeforderten GPUs verfügbar sind.

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

  • 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 --region. Die definierten GPU-Typen müssen in jeder ausgewählten Zone verfügbar sein. 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.

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

  • SSD_COUNT: Anzahl der lokalen SSDs, die für den sitzungsspezifischen Speicher angehängt werden sollen. Dieses Flag ist erforderlich, um lokale SSDs in A3-Maschinentypen mit H100-GPUs zu 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 die Standardtreiber automatisch auf diesen Knoten.

gcloud container node-pools create p100 \
  --accelerator type=nvidia-tesla-p100,count=2,gpu-driver-version=default \
  --region us-central1 --cluster p100-cluster \
  --node-locations us-central1-c \
  --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 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. Wählen Sie in diesem Fall im Drop-down-Menü Version eine der folgenden Optionen aus:
      • Standard: Die Standard-Treiberversion wird installiert.
      • Aktuell: Hier wird die neueste verfügbare Treiberversion installiert.
    • 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 Terraform und GPUs 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_ZONE1,COMPUTE_ZONE2"
  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_ZONE1,COMPUTE_ZONE2,[...]: Die spezifischen Zonen, in denen GKE die GPU-Knoten erstellt. Die Zonen müssen sich in derselben Region befinden, angegeben durch die Variable region. In diesen Zonen müssen die von Ihnen definierten GPU-Typen verfügbar sein. Unter Verfügbarkeit erfahren Sie, welche Zonen GPUs bieten. Verwenden Sie beim Erstellen des GPU-Knotenpools die Variable node_locations, um die Zone oder die Zonen anzugeben, die die angeforderten GPUs enthalten.
    • 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 GPU-Treiberinstallation deaktivieren. Sie müssen Treiber manuell installieren, um Ihre GPUs ausführen zu können. 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 des 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 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
  node_locations = [var.zone]
}

resource "google_container_node_pool" "gpu_pool" {
  name       = google_container_cluster.ml_cluster.name
  location   = var.region
  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 Fällen:

  • Sie haben beim Erstellen 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 nicht als Standard- oder aktueller Treiber mit automatischer Installation verfügbar ist.
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 erfordert der GPU-Knotenpool den Bereich https://www.googleapis.com/auth/devstorage.read_only für die Kommunikation mit Cloud Storage. 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

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. Nach der Installation verwendet das NVIDIA-GPU-Geräte-Plug-in die Kubernetes API, um die Kapazität der NVIDIA-GPU verfügbar zu machen.

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 verfügbaren Treiberversionen in jeder GKE-Version aufgeführt:

NVIDIA-Treiberversionen für GKE
1.30 R535 (Standard) oder R550
1.29 R535 (Standard) oder R550
1.28 R535 (Standard) oder R550
1.27 R470 (default), R525, R535 oder R550
1.26 R470 (default), R525, R535 oder R550

Ubuntu

Das von Ihnen bereitgestellte DaemonSet für die Installation hängt vom GPU-Typ und von der GKE-Knotenversion ab:

  • Führen Sie für alle GPUs außer NVIDIA L4- und NVIDIA H100-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 L4- oder H100-GPUs mit Knotenversionen ab der 2024-R05-Version den Treiber R535:

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

  • Installieren Sie für NVIDIA L4- oder H100-GPUs, auf denen Knotenversionen aus Releases vor der 2024-R05-Version oder später ausgeführt werden, den Treiber R525:

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

Die Installation kann mehrere Minuten dauern. Nach der Installation verwendet das NVIDIA-GPU-Geräte-Plug-in die Kubernetes API, um die Kapazität der NVIDIA-GPU verfügbar zu machen.

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

Ubuntu-GPU-Treiber und GKE-Versionen
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
  }

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

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. Wenn Sie den nodeSelector in Ihrem Manifest weglassen, ist dies die Standardoption.
  • latest: die neueste verfügbare Treiberversion für die GKE-Version Ihres Knotens.

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:
  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. Beispiele:

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 oder Blau/Grün-Upgrades. 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 von Atomarität unter Terminologie in Bezug auf TPU in GKE.

Wenn Sie eine Strategie für Knotenupgrades verwenden, muss GKE je nach Konfiguration vorübergehend zusätzliche Ressourcen bereitstellen. Wenn Google Cloud die 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 ein eigenes Image erstellen und verwenden. Fügen Sie dazu die folgenden Werte in die Umgebungsvariable LD_LIBRARY_PATH in Ihrer Containerspezifikation ein:

  • /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-Imageversion. Einige Versionen enthalten auch Debug-Dienstprogramme unter /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.

  • /usr/local/nvidia/lib64: der Speicherort der NVIDIA-Gerätetreiber.
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.

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.

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

NVIDIA Data Center GPU Manager-Messwerte (DCGM) ansehen

Mit Google Cloud Managed Service for Prometheus können Sie NVIDIA DCGM-Messwerte erfassen und visualisieren. Bei Autopilot-Clustern werden die Treiber von GKE installiert. Für Standardcluster 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