GPUs in GKE-Standardknotenpools ausführen

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.

Überblick

Mit GKE können Sie Knotenpools erstellen, die mit GPUs vom Typ NVIDIA Tesla® K80, P100, P4, V100, T4, L4 (Vorschau) 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.

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 Aufgaben aus, bevor Sie beginnen:

  • Aktivieren Sie die Google Kubernetes Engine API.
    • Google Kubernetes Engine API aktivieren
  • Wenn Sie die Google Cloud CLI für diese Aufgabe verwenden möchten, 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.

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ä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, müsste Ihr Projekt nach dem Einreichen Ihrer Kontingentanfrage automatisch ein Kontingent erhalten.

  • NVIDIA-GPU-Treiber: Wenn Sie einen Cluster oder einen Knotenpool erstellen, können Sie GKE anweisen, je nach GKE-Version automatisch eine Treiberversion 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. Dafür ist die GKE-Version 1.18.6-gke.3504 oder höher erforderlich. Achten Sie darauf, dass Ihr Kontingent für den zugrunde liegenden A2-Maschinentyp ausreicht, um die A100-GPU zu verwenden.

  • L4-GPUs:

    • Sie müssen mindestens die GKE-Version 1.22.17-gke.5400 verwenden.
    • Die ausgewählte GKE-Version muss NVIDIA-Treiberversion 525 oder höher in Container-Optimized OS enthalten. Wenn Treiberversion 525 oder höher nicht die Standardversion oder die neueste Version in Ihrer GKE-Version ist, müssen Sie einen unterstützten Treiber auf Ihren Knoten manuell installieren.

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:

    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.

  • In den GKE-Versionen 1.22 bis 1.25 unterstützt Cluster Autoscaler nur das vertikale Skalieren von Knoten mit L4-GPUs. Diese Einschränkung gilt nicht für GKE-Version 1.26 und höher.

  • Bei H100-GPUs müssen Sie zur Verwendung lokaler SSDs für Pod-Speicher explizit die genaue Anzahl lokaler SSDs angeben, die mit zugrunde liegenden A3-VM angehängt werden sollen. Dazu wird das Flag --ephemeral-storage-local-ssd=count=SSD_COUNT für sitzungsspezifischen Speicher oder das Flag --local-nvme-ssd-block=count=SSD_COUNT für Blockzugriff verwendet. Wenn Sie dieses Flag weglassen, können Sie die lokalen SSDs nicht in Ihren Pods verwenden. Diese Flags sind nur erforderlich, wenn Sie lokale SSDs für den Datenzugriff verwenden möchten.

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

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 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 Next (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 ausführen

Erstellen Sie zum Ausführen von GPUs in GKE-Standardclustern einen Knotenpool mit angehängten GPUs. 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

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.

Für eine bessere Kosteneffizienz, Zuverlässigkeit und Verfügbarkeit von GPUs in GKE empfehlen wir die folgenden Aktionen:

  • 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.
  • Weisen Sie GKE an, automatisch die standardmäßigen oder neuesten GPU-Treiber auf den Knotenpools zu installieren, sodass Sie Ihre Treiberversionen nicht manuell installieren und verwalten müssen.

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.

Sie können GKE anweisen, die Standardversion oder die neueste NVIDIA-Treiberversion automatisch zu installieren, die Ihrer Container-Optimized OS-Version entspricht.

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 GPU-Typ. Folgende Werte sind möglich:
    • nvidia-tesla-k80
    • nvidia-tesla-p100
    • nvidia-tesla-p4
    • nvidia-tesla-v100
    • nvidia-tesla-t4
    • nvidia-tesla-a100
    • nvidia-a100-80gb
    • nvidia-l4
    • nvidia-h100-80gb

  • DRIVER_VERSION: die zu installierende NVIDIA-Treiberversion. folgende Arten von Werten sind möglich:

    • default: Installieren Sie die Standardtreiberversion für Ihre GKE-Version.
    • 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. Wenn Sie gpu-driver-version weglassen, ist dies die Standardoption.

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

    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: Die Anzahl der lokalen SSDs, die als sitzungsspezifischer Speicher hinzugefügt 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 automatisch die Standardtreiber 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. Wenn Sie diese Option auswählen, wählen Sie eine der folgenden Optionen aus dem Drop-down-Menü Version aus:
      • Standard: Installieren Sie die Standardtreiberversion.
      • Neueste: 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-Treiber installieren.

  11. Klicken Sie auf Erstellen.

Terraform

Mit einem Terraform-Modul können Sie einen regionalen Cluster mit Terraform mit 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: 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. Diese Zonen müssen die von Ihnen definierten GPU-Typen enthalten. 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 GPU-Typ. Folgende Werte sind möglich:

      • nvidia-tesla-k80
      • nvidia-tesla-p100
      • nvidia-tesla-p4
      • nvidia-tesla-v100
      • nvidia-tesla-t4
      • nvidia-tesla-a100
      • nvidia-a100-80gb
      • nvidia-l4
      • nvidia-h100-80gb

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

      • INSTALLATION_DISABLED: Automatische Installation des GPU-Treibers deaktivieren. Sie müssen Treiber manuell installieren, um Ihre GPUs auszuführen.
      • DEFAULT: Installiert automatisch die Standardtreiberversion für Ihre Knotenbetriebssystemversion.
      • LATEST: Installiert automatisch die neueste verfügbare Treiberversion für Ihre Knotenbetriebssystemversion.

    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:

    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 Autoscaling ist aktiviert. Weitere Informationen zu Terraform finden Sie in der google_container_node_pool-Ressourcenspezifikation.

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

Wenn Sie bei der Erstellung eines GPU-Knotenpools die automatische Installation von Gerätetreibern deaktiviert haben oder wenn Sie eine GKE-Version verwenden, die älter ist als die unterstützte Mindestversion für die automatische Installation, müssen Sie manuell einen kompatiblen NVIDIA-GPU-Treiber 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 verwenden, können Sie auch zwischen der Standard-GPU-Treiberversion oder einer neueren Version auswählen.

Wir empfehlen, nach Möglichkeit die automatische Treiberinstallation zu verwenden. 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.

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

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

Ubuntu

Führen Sie den folgenden Befehl aus, um das DaemonSet für alle GPUs außer NVIDIA L4-GPUs 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.

Installieren Sie für NVIDIA L4-GPUs stattdessen den Treiber R525 mit dem folgenden Befehl:

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

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

GKE-Version NVIDIA-Treiber
1,27 R470
1.26 R470
1.25 R470
1.24 R470
1.23 R470
1.22 R450
1.21 R450
1.20 R450

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
  }

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

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

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, nvidia-a100-80gb, nvidia-h100-80gb oder nvidia-l4.

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

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 in 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 Führen Sie ein Upgrade in einer ressourcenbeschränkten Umgebung durch.

Informationen zu NVIDIA CUDA-X-Bibliotheken

CUDA® ist die NVIDIA-Plattform für paralleles Computing und das Programmiermodell für GPUs. Zur Verwendung von CUDA-Anwendungen muss das verwendete Image die Bibliotheken haben. Verwenden Sie eine der folgenden Methoden, um die NVIDIA CUDA-X-Bibliotheken hinzuzufügen:

  • Empfohlen: Verwenden Sie ein Image mit den vorinstallierten NVIDIA CUDA-X-Bibliotheken. Sie können beispielsweise Deep Learning Container verwenden. In diesen Containern werden die wichtigsten Data-Science-Frameworks, die NVIDIA CUDA-X-Bibliotheken und die Tools vorinstalliert. Alternativ enthält das NVIDIA CUDA-Image nur die NVIDIA CUDA-X-Bibliotheken.
  • Erstellen und verwenden Sie ein eigenes Image. Fügen Sie in diesem Fall folgende Werte in die LD_LIBRARY_PATH-Umgebungsvariable in Ihrer Containerspezifikation ein:
    1. /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 Dienstprogramme zur Fehlerbehebung in /usr/local/nvidia/bin. Weitere Informationen finden Sie im NVIDIA CUDA-Image auf DockerHub.
    2. /usr/local/nvidia/lib64: Der Speicherort der NVIDIA-Gerätetreiber.

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.

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

Sie können NVIDIA DCGM-Messwerte mit Standardclustern mithilfe von Google Cloud Managed Service for Prometheus erfassen und visualisieren.

Eine Anleitung zum Bereitstellen von DCGM und dem Prometheus DCGM-Exporter für Ihren Standardcluster finden Sie in der Google Cloud-Dokumentation zur Beobachtbarkeit unter NVIDIA Data Center GPU Manager (DCGM).

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.

Sie können GKE so konfigurieren, dass Ihre Arbeitslasten innerhalb dieses Benachrichtigungszeitraums ordnungsgemäß beendet werden. Legen Sie in Ihrem Pod-Manifest das Feld spec.terminationGracePeriodSeconds auf einen Wert von maximal 60 Minuten (3600 Sekunden) fest. Wenn Sie beispielsweise eine Benachrichtigungszeit von 10 Minuten erhalten möchten, legen Sie in Ihrem Pod-Manifest das Feld spec.terminationGracePeriodSeconds so auf 600 Sekunden fest:

  spec:
    terminationGracePeriodSeconds: 600

GKE unternimmt alles, um diese Pods ordnungsgemäß zu beenden und die von Ihnen definierte Beendigungsaktion auszuführen, z. B. das Speichern eines Trainingsstatus.

Nächste Schritte