GPUs mit mehreren Instanzen ausführen

Auf dieser Seite erfahren Sie, wie Sie die Auslastung erhöhen und die Kosten senken, indem Sie GPUs mit mehreren Instanzen ausführen. Bei dieser Konfiguration partitionieren Sie einen NVIDIA A100- oder H100-Grafikprozessor (GPU) zur gemeinsamen Nutzung einer einzelnen GPU in mehreren Containern in Google Kubernetes Engine (GKE).

Machen Sie sich vor dem Lesen dieser Seite mit Kubernetes-Konzepten vertraut, beispielsweise Pods, Knoten, Deployments und Namespaces. Außerdem sollten Sie GKE-Konzepte wie Knotenpools, Autoscaling und Auto-Provisioning kennen.

Einführung

Kubernetes weist pro Container eine vollständige GPU zu, auch wenn der Container nur einen Bruchteil der GPU für seine Arbeitslast benötigt. Dadurch kann es zur Verschwendung von Ressourcen und zu höheren Kosten kommen, insbesondere wenn Sie die neueste Generation leistungsstarker GPUs verwenden. Zur Verbesserung der GPU-Auslastung bieten GPUs mit mehreren Instanzen die Möglichkeit, eine einzelne unterstützte GPU in bis zu sieben Slices zu partitionieren. Jedes Slice kann unabhängig einem Container auf dem Knoten zugewiesen werden, für maximal sieben Container pro GPU. GPUs mit mehreren Instanzen bieten Hardwareisolation zwischen den Arbeitslasten sowie konsistente und vorhersehbare Dienstqualität für alle Container, die auf der GPU ausgeführt werden.

Bei CUDA®-Anwendungen sind GPUs mit mehreren Instanzen weitgehend transparent. Jede GPU-Partition wird als reguläre GPU-Ressource angezeigt und das Programmiermodell bleibt unverändert.

Weitere Informationen zu GPUs mit mehreren Instanzen finden Sie im NVIDIA-Nutzerhandbuch für GPUs mit mehreren Instanzen.

Unterstützte GPUs

Die folgenden GPU-Typen unterstützen GPUs mit mehreren Instanzen:

  • NVIDIA A100 (40 GB)
  • NVIDIA A100 (80 GB)

  • NVIDIA H100 (80 GB)

GPU-Partitionen mit mehreren Instanzen

Die A100- und H100-GPU bestehen aus sieben Recheneinheiten und acht Speichereinheiten, die in GPU-Instanzen unterschiedlicher Größe partitioniert werden können. Die GPU-Partitionsgrößen verwenden die folgende Syntax: [compute]g.[memory]gb. Zum Beispiel bezieht sich eine GPU-Partitionsgröße von 1g.5gb auf eine GPU-Instanz mit einer Recheneinheit (ein Siebtel der Streaming-Multiprozessoren auf der GPU) und einer Speichereinheit (5 GB). Die Partitionsgröße für die GPUs kann beim Bereitstellen einer Autopilot-Arbeitslast oder beim Erstellen eines Standardclusters angegeben werden.

In der Partitionierungstabelle im NVIDIA-Nutzerhandbuch für GPUs mit mehreren Instanzen werden alle verschiedenen GPU-Partitionsgrößen sowie die Anzahl der auf jeder GPU-Partition verfügbaren Rechen- und Speicherressourcen aufgelistet. Die Tabelle zeigt auch die Anzahl der GPU-Instanzen für jede Partitionsgröße, die auf der GPU erstellt werden kann.

In der folgenden Tabelle sind die von GKE unterstützten Partitionsgrößen aufgeführt:

Partitionsgröße GPU-Instanzen
GPU: NVIDIA A100 (40GB) (nvidia-tesla-a100)
1g.5gb 7
2g.10gb 3
3g.20gb 2
7g.40gb 1
GPU: NVIDIA A100 (80GB) (nvidia-a100-80gb)
1g.10gb 7
2g.20gb 3
3g.40gb 2
7g.80gb 1
GPU: NVIDIA H100 (80 GB) (nvidia-h100-80gb und nvidia-h100-mega-80gb)
1g.10gb 7
1g.20gb 4
2g.20gb 3
3g.40gb 2
7g.80gb 1

Jede GPU auf jedem Knoten innerhalb eines Knotenpools wird auf dieselbe Weise partitioniert. Betrachten Sie beispielsweise einen Knotenpool mit zwei Knoten, vier GPUs auf jedem Knoten und einer Partitionsgröße von 1g.5gb. GKE erstellt sieben Partitionen der Größe 1g.5gb auf jeder GPU. Da pro Knoten vier GPUs vorhanden sind, sind auf jedem Knoten 28 1g.5gb-GPU-Partitionen verfügbar. Da der Knotenpool zwei Knoten enthält, sind im gesamten Knotenpool insgesamt 56 1g.5gb-GPU-Partitionen verfügbar.

Sie müssen mehrere Knotenpools erstellen, um einen GKE Standard-Cluster mit unterschiedlichen GPU-Partitionen zu erstellen. Wenn Sie z. B. Knoten mit den GPU-Partitionen 1g.5gb und 3g.20gb in einem Cluster verwenden möchten, müssen Sie zwei Knotenpools erstellen, einen mit der GPU-Partitionsgröße 1g.5gb und einen mit 3g.20gb.

Ein GKE Autopilot-Cluster erstellt automatisch Knoten mit der richtigen Partitionskonfiguration, wenn Sie Arbeitslasten erstellen, die unterschiedliche Partitionsgrößen erfordern.

Jeder Knoten wird mit der Größe der auf dem Knoten verfügbaren GPU-Partitionen gekennzeichnet. Dank dieser Kennzeichnung können Arbeitslasten auf Knoten mit der erforderlichen GPU-Partitionsgröße ausgerichtet werden. Auf einem Knoten mit 1g.5gb-GPU-Instanzen wird der Knoten beispielsweise so gekennzeichnet:

cloud.google.com/gke-gpu-partition-size=1g.5gb

So gehts:

Führen Sie die folgenden Aufgaben aus, um GPUs mit mehreren Instanzen zu verwenden:

  1. Cluster mit aktivierten GPUs mit mehreren Instanzen erstellen
  2. Treiber manuell installieren
  3. Anzahl der GPU-Ressourcen auf dem Knoten prüfen.
  4. Container mit GPUs mit mehreren Instanzen bereitstellen

Preise

GPUs mit mehreren Instanzen sind ausschließlich für A100-GPUs und H100-GPUs verfügbar und unterliegen zusätzlich zu den anderen Produkten, die zum Ausführen Ihrer Arbeitslasten verwendet werden, den entsprechenden GPU-Preisen. Sie können nur ganze GPUs zur Partitionierung an Knoten in Ihrem Cluster anhängen. Informationen zu GPU-Preisen finden Sie auf der Seite GPU-Preise.

Beschränkungen

  • Die Verwendung von GPU-Partitionen mit mehreren Instanzen mit GKE wird für nicht vertrauenswürdige Arbeitslasten nicht empfohlen.
  • Die automatische Skalierung und die automatische Bereitstellung von GPU-Partitionen wird bei GKE-Version 1.20.7-gke.400 oder höher vollständig unterstützt. In früheren Versionen können nur Knotenpools mit mindestens einem Knoten automatisch bedarfsabhängig für bestimmte GPU-Partitionsgrößen von Arbeitslasten skaliert werden.
  • GPU-Auslastungsmesswerte (z. B. duty_cycle) sind für GPUs mit mehreren Instanzen nicht verfügbar.
  • Bei mehreren Instanzen wird eine physische GPU in eigenständige Instanzen aufgeteilt, die jeweils auf Hardwareebene von den anderen isoliert sind. Ein Container, der eine GPU-Instanz mit mehreren Instanzen verwendet, kann nur auf die CPU- und Speicherressourcen zugreifen, die für diese Instanz verfügbar sind.
  • Ein Pod kann nur bis zu einer GPU-Instanz mit mehreren Instanzen nutzen.

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.
  • In Autopilot werden GPUs mit mehreren Instanzen in GKE-Version 1.29.3-gke.1093000 und höher unterstützt.
  • Sie müssen ein ausreichendes NVIDIA A100-GPU-Kontingent haben. Weitere Informationen finden Sie unter Höheres Kontingent anfordern.
  • Wenn Sie GPUs mit mehreren Instanzen mit Autopilot verwenden möchten, finden Sie weitere Informationen zur Verwendung von GPUs mit Autopilot unter GPU-Arbeitslasten in Autopilot bereitstellen.
  • GKE weist allen GPU-Arbeitslasten mit mehreren Instanzen in Autopilot-Clustern die Compute-Klasse Accelerator zu.

Cluster mit aktivierten GPUs mit mehreren Instanzen erstellen

Wenn Sie GKE Standard verwenden, müssen Sie GPUs mit mehreren Instanzen im Cluster aktivieren. Autopilot-Cluster, auf denen Version 1.29.3-gke.1093000 oder höher ausgeführt wird, aktivieren standardmäßig GPUs für mehrere Instanzen. Informationen zur Verwendung von GPUs mit mehreren Instanzen in Autopilot finden Sie auf dieser Seite im Abschnitt Container mit GPU für mehrere Instanzen bereitstellen.

Wenn Sie einen Standard-Cluster mit GPUs für mehrere Instanzen erstellen, müssen Sie gpuPartitionSize zusammen mit acceleratorType und acceleratorCount angeben. acceleratorType muss nvidia-tesla-a100, nvidia-a100-80gb oder nvidia-h100-80gb sein.

Das folgende Beispiel zeigt, wie Sie einen GKE-Cluster mit einem Knoten und sieben GPU-Partitionen der Größe 1g.5gb auf dem Knoten erstellen. In den anderen Schritten dieser Seite wird eine GPU-Partitionsgröße von 1g.5gb verwendet, die sieben Partitionen pro GPU erstellt. Sie können auch die zuvor erwähnten unterstützten Größen von GPU-Partitionen verwenden.

Sie können dazu die Google Cloud CLI oder Terraform verwenden.

gcloud

Cluster mit aktivierten GPUs mit mehreren Instanzen erstellen:

gcloud container clusters create CLUSTER_NAME  \
    --project=PROJECT_ID  \
    --zone ZONE  \
    --cluster-version=CLUSTER_VERSION  \
    --accelerator type=nvidia-tesla-a100,count=1,gpu-partition-size=1g.5gb,gpu-driver-version=DRIVER_VERSION  \
    --machine-type=a2-highgpu-1g  \
    --num-nodes=1

Ersetzen Sie Folgendes:

  • CLUSTER_NAME: Der Name des neuen Clusters.
  • PROJECT_ID ist die ID Ihres Google Cloud-Projekts.
  • ZONE: Die Computing-Zone für die Clustersteuerungsebene.
  • CLUSTER_VERSION: Die Version muss 1.19.7-gke.2503 oder höher sein.
  • DRIVER_VERSION: die zu installierende NVIDIA-Treiberversion. Kann eines der Folgenden sein:
    • 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 Cluster erstellt haben. Wenn Sie gpu-driver-version weglassen, ist dies die Standardoption.

Terraform

Informationen zum Erstellen eines Clusters mit GPUs mit mehreren Instanzen, die mit Terraform aktiviert wurden, finden Sie im folgenden Beispiel:

resource "google_container_cluster" "default" {
  name               = "gke-standard-zonal-gpu"
  location           = "us-central1-a"
  initial_node_count = 1

  node_config {
    guest_accelerator {
      type  = "nvidia-tesla-t4"
      count = 1
      gpu_driver_installation_config {
        gpu_driver_version = "LATEST"
      }
    }
    machine_type = "n1-standard-2"
  }

  # Set `deletion_protection` to `true` will ensure that one cannot
  # accidentally delete this instance by use of Terraform.
  deletion_protection = false
}

Weitere Informationen zur Verwendung von Terraform finden Sie unter Terraform-Unterstützung für GKE.

Mit dem Cluster verbinden

Konfigurieren Sie kubectl, um eine Verbindung zum neu erstellten Cluster herzustellen:

gcloud container clusters get-credentials CLUSTER_NAME

Treiber installieren

Wenn Sie die automatische Treiberinstallation beim Erstellen des Clusters deaktiviert haben oder eine GKE-Version vor 1.27.2-gke.1200 ausführen, müssen Sie nach der Erstellung einen kompatiblen NVIDIA-Treiber manuell installieren. Für mehrere Instanzen ist die NVIDIA-Treiberversion 450.80.02 oder höher erforderlich.

Nach der Installation des Treibers wird der GPU-Modus für mehrere Instanzen aktiviert. Wenn Sie Treiber automatisch installieren, werden Ihre Knoten neu gestartet, wenn das GPU-Geräte-Plug-in mit der Erstellung von GPU-Partitionen beginnt. Wenn Sie Treiber manuell installiert haben, werden die Knoten nach Abschluss der Treiberinstallation neu gestartet. Der Neustart kann einige Minuten dauern

Anzahl der GPU-Ressourcen auf dem Knoten prüfen

Führen Sie den folgenden Befehl aus, um zu prüfen, ob die Kapazität und die zuweisbare Anzahl von nvidia.com/gpu-Ressourcen den Wert 7 haben:

kubectl describe nodes

Hier sehen Sie die Ausgabe des Befehls:

...
Capacity:
  ...
  nvidia.com/gpu:             7
Allocatable:
  ...
  nvidia.com/gpu:             7

Container mit GPU für mehrere Instanzen bereitstellen

Sie können bis zu einen Container pro GPU-Gerät mit mehreren Instanzen auf dem Knoten bereitstellen. In diesem Beispiel mit der Partitionsgröße 1g.5gb sind auf dem Knoten sieben GPU-Partitionen mit mehreren Instanzen verfügbar. Daher können Sie bis zu sieben Container bereitstellen, die GPUs auf diesem Knoten anfordern.

  1. Im folgenden Beispiel wird der Container cuda:11.0.3-base-ubi7 gestartet und nvidia-smi ausgeführt, um die UUID der GPU im Container auszugeben. In diesem Beispiel gibt es sieben Container, die jeweils eine GPU-Partition erhalten. In diesem Beispiel wird der Knotenselektor cloud.google.com/gke-gpu-partition-size auch auf Knoten mit 1g.5gb-GPU-Partitionen ausgerichtet.

    Autopilot

          cat &lt&ltEOF | kubectl apply -f -
      apiVersion: apps/v1
      kind: Deployment
      metadata:
        name: cuda-simple
      spec:
        replicas: 7
        selector:
          matchLabels:
            app: cuda-simple
        template:
          metadata:
            labels:
              app: cuda-simple
          spec:
            nodeSelector:
              cloud.google.com/gke-gpu-partition-size: 1g.5gb
              cloud.google.com/gke-accelerator: nvidia-tesla-a100
              cloud.google.com/gke-accelerator-count: "1"
            containers:
            - name: cuda-simple
              image: nvidia/cuda:11.0.3-base-ubi7
              command:
              - bash
              - -c
              - |
                /usr/local/nvidia/bin/nvidia-smi -L; sleep 300
              resources:
                limits:
                  nvidia.com/gpu: 1
      EOF

    Das Manifest tut Folgendes:

    • Fordert den GPU-Typ nvidia-tesla-a100 an, indem der Knotenselektor cloud.google.com/gke-accelerator festgelegt wird.
    • Teilt die GPU in die Partitionsgröße 1g.5gb auf.
    • Fügt dem Knoten eine einzelne GPU hinzu. Dazu wird der Knotenselektor cloud.google.com/gke-accelerator-count festgelegt.

    Standard

          cat &lt&ltEOF | kubectl apply -f -
      apiVersion: apps/v1
      kind: Deployment
      metadata:
        name: cuda-simple
      spec:
        replicas: 7
        selector:
          matchLabels:
            app: cuda-simple
        template:
          metadata:
            labels:
              app: cuda-simple
          spec:
            nodeSelector:
              cloud.google.com/gke-gpu-partition-size: 1g.5gb
            containers:
            - name: cuda-simple
              image: nvidia/cuda:11.0.3-base-ubi7
              command:
              - bash
              - -c
              - |
                /usr/local/nvidia/bin/nvidia-smi -L; sleep 300
              resources:
                limits:
                  nvidia.com/gpu: 1
      EOF

    Das Manifest tut Folgendes:

    • Fordert eine einzelne GPU mit der Partitionsgröße 1g.5gb an.

  2. Prüfen Sie, ob alle sieben Pods ausgeführt werden:

    kubectl get pods

    Hier sehen Sie die Ausgabe des Befehls:

    NAME                           READY   STATUS    RESTARTS   AGE
cuda-simple-849c47f6f6-4twr2   1/1     Running   0          7s
cuda-simple-849c47f6f6-8cjrb   1/1     Running   0          7s
cuda-simple-849c47f6f6-cfp2s   1/1     Running   0          7s
cuda-simple-849c47f6f6-dts6g   1/1     Running   0          7s
cuda-simple-849c47f6f6-fk2bs   1/1     Running   0          7s
cuda-simple-849c47f6f6-kcv52   1/1     Running   0          7s
cuda-simple-849c47f6f6-pjljc   1/1     Running   0          7s

  3. Rufen Sie die Logs mit der GPU-UUID anhand des Namens eines beliebigen Pods aus dem vorherigen Befehl auf:

    kubectl logs cuda-simple-849c47f6f6-4twr2

    Hier sehen Sie die Ausgabe des Befehls:

    GPU 0: A100-SXM4-40GB (UUID: GPU-45eafa61-be49-c331-f8a2-282736687ab1)
  MIG 1g.5gb Device 0: (UUID: MIG-GPU-45eafa61-be49-c331-f8a2-282736687ab1/11/0)

Nächste Schritte