GKE-Infrastruktur für DRA-Arbeitslasten vorbereiten

Auf dieser Seite wird erläutert, wie Sie Ihre Google Kubernetes Engine-Infrastruktur (GKE) für die Unterstützung der dynamischen Ressourcenzuweisung (Dynamic Resource Allocation, DRA) einrichten. Auf dieser Seite erstellen Sie Cluster, in denen GPU- oder TPU-Arbeitslasten bereitgestellt werden können, und installieren manuell die Treiber, die Sie zum Aktivieren von DRA benötigen.

Diese Seite richtet sich an Plattformadministratoren, die die Komplexität und den Aufwand für die Einrichtung von Infrastruktur mit speziellen Hardwaregeräten reduzieren möchten.

Informationen zu DRA

DRA ist eine integrierte Kubernetes-Funktion, mit der Sie Hardware in Ihrem Cluster flexibel für Pods und Container anfordern, zuweisen und freigeben können. Weitere Informationen finden Sie unter Dynamische Ressourcenzuweisung.

Beschränkungen

  • Die automatische Knotenbereitstellung wird nicht unterstützt.
  • Autopilot-Cluster unterstützen keine Geräteressourcen-Zuweisung.
  • Die folgenden GPU-Freigabefunktionen können nicht verwendet werden:
    • GPUs mit Zeitfreigabe
    • GPUs mit mehreren Instanzen
    • Multi-Process Service (MPS)

Voraussetzungen

Wenn Sie DRA verwenden möchten, muss Ihre GKE-Version mindestens Version 1.32.1-gke.1489001 sein.

Außerdem sollten Sie sich mit den folgenden Anforderungen und Einschränkungen vertraut machen, je nachdem, welche Hardware Sie verwenden möchten:

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.

  • Wenn Sie Cloud Shell nicht verwenden, installieren Sie die Helm-Befehlszeile:

    curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3
chmod 700 get_helm.sh
./get_helm.sh

GKE-Standardcluster erstellen

Erstellen Sie einen Cluster im Standardmodus, in dem die Kubernetes-Beta-APIs für DRA aktiviert sind:

gcloud container clusters create CLUSTER_NAME \
    --quiet \
    --enable-kubernetes-unstable-apis="resource.k8s.io/v1beta1/deviceclasses,resource.k8s.io/v1beta1/resourceclaims,resource.k8s.io/v1beta1/resourceclaimtemplates,resource.k8s.io/v1beta1/resourceslices" \
    --release-channel=rapid \
    --enable-autoupgrade \
    --location CONTROL_PLANE_LOCATION \
    --num-nodes "1" \
    --cluster-version GKE_VERSION \
    --workload-pool="PROJECT_ID.svc.id.goog"

Ersetzen Sie Folgendes:

  • CLUSTER_NAME: ein Name für Ihren Cluster.
  • 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.
  • GKE_VERSION: Die GKE-Version, die für den Cluster und die Knoten verwendet werden soll. Muss 1.32.1-gke.1489001 oder höher sein.
  • PROJECT_ID: Ihre Projekt-ID.

GKE-Umgebung für die Unterstützung von DRA vorbereiten

In GKE können Sie DRA sowohl mit GPUs als auch mit TPUs verwenden. Wenn Sie Ihre Knotenpools erstellen, müssen Sie die folgenden Einstellungen verwenden, die während der Vorabversion mit DRA funktionieren:

  • Deaktivieren Sie für GPUs die automatische Installation von GPU-Treibern.
  • Fügen Sie die erforderlichen Zugriffsbereiche für die Knoten hinzu.
  • Fügen Sie Knotenlabels hinzu, damit nur DRA-Arbeitslasten auf den Knoten ausgeführt werden.
  • Aktivieren Sie das Cluster-Autoscaling.

Alle anderen Konfigurationseinstellungen für Knotenpools, z. B. Maschinentyp, Beschleunigertyp, Anzahl, Knotenbetriebssystem und Knotenstandorte, hängen von Ihren Anforderungen ab.

Umgebung für GPUs vorbereiten

  1. Erstellen Sie einen Knotenpool mit der erforderlichen Hardware:

    gcloud beta container node-pools create "gpu-pool" \
    --quiet \
    --project PROJECT_ID \
    --cluster CLUSTER_NAME \
    --location CONTROL_PLANE_LOCATION \
    --node-version KUBERNETES_VERSION \
    --machine-type "n1-standard-8" \
    --accelerator "type=nvidia-tesla-t4,count=2,gpu-driver-version=disabled" \
    --image-type "UBUNTU_CONTAINERD" \
    --disk-type "pd-standard" \
    --disk-size "100" \
    --scopes "https://www.googleapis.com/auth/devstorage.read_only","https://www.googleapis.com/auth/logging.write","https://www.googleapis.com/auth/monitoring","https://www.googleapis.com/auth/servicecontrol","https://www.googleapis.com/auth/service.management.readonly","https://www.googleapis.com/auth/trace.append" \
    --num-nodes "1" \
    --enable-autoscaling \
    --min-nodes "1" \
    --max-nodes "6" \
    --location-policy "ANY" \
    --max-surge-upgrade 1 \
    --max-unavailable-upgrade 0 \
    --node-locations ZONE \
    --node-labels=gke-no-default-nvidia-gpu-device-plugin=true,nvidia.com/gpu.present=true

    Ersetzen Sie Folgendes:

    • CLUSTER_NAME: Der Name Ihres Clusters.
    • 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. Achten Sie darauf, dass der ausgewählte Standort zur selben Region gehört, in der die von Ihnen angegebenen GPUs verfügbar sind.
    • ZONE: eine Zone, in der die von Ihnen angegebenen GPUs verfügbar sind.

  2. Installieren Sie die Treiber manuell auf Ihren Container-Optimized OS- oder Ubuntu-Knoten. Eine ausführliche Anleitung finden Sie unter NVIDIA-GPU-Treiber manuell installieren.

    • Wenn Sie COS verwenden, führen Sie die folgenden Befehle 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 Ubuntu verwenden, hängt das Installations-DaemonSet, das Sie bereitstellen, vom GPU-Typ und von der GKE-Knotenversion ab, wie im Ubuntu-Abschnitt der Anleitung beschrieben.

  3. Rufen Sie das Helm-Diagramm ab, das den GPU-Operator enthält, und aktualisieren Sie es:

    helm repo add nvidia https://helm.ngc.nvidia.com/nvidia \
    && helm repo update

  4. Erstellen Sie einen Namespace für den GPU-Operator:

    kubectl create namespace gpu-operator

  5. Erstellen Sie ein ResourceQuota im Namespace gpu-operator. Mit dem ResourceQuota kann der GPU-Operator Pods mit derselben Priorität wie Kubernetes-System-Pods bereitstellen.

    kubectl apply -n gpu-operator -f - << EOF
apiVersion: v1
kind: ResourceQuota
metadata:
  name: gpu-operator-quota
spec:
  hard:
    pods: 100
  scopeSelector:
    matchExpressions:
    - operator: In
      scopeName: PriorityClass
      values:
        - system-node-critical
        - system-cluster-critical
EOF

  6. Installieren Sie den GPU-Operator mit dem Helm-Skript:

    helm install --wait --generate-name -n gpu-operator nvidia/gpu-operator \
    --set driver.enabled=false \
    --set operator.repository=ghcr.io/nvidia \
    --set operator.version=6171a52d \
    --set validator.repository=ghcr.io/nvidia/gpu-operator \
    --set validator.version=6171a52d \
    --set toolkit.repository=ghcr.io/nvidia \
    --set toolkit.version=5d9b27f1-ubuntu20.04 \
    --set gfd.repository=ghcr.io/nvidia \
    --set gfd.version=f171c926-ubi9 \
    --set cdi.enabled=true \
    --set hostPaths.driverInstallDir=/home/kubernetes/bin/nvidia \
    --set toolkit.installDir=/home/kubernetes/bin/nvidia

Umgebung für TPUs vorbereiten

Erstellen Sie einen Knotenpool, der TPUs verwendet. Im folgenden Beispiel wird ein TPU-Trillium-Knotenpool erstellt:

gcloud container node-pools create NODEPOOL_NAME \
    --cluster CLUSTER_NAME --num-nodes 1 \
    --location CONTROL_PLANE_LOCATION \
    --node-labels "gke-no-default-tpu-device-plugin=true,gke-no-default-tpu-dra-plugin=true" \
    --machine-type=ct6e-standard-8t \
    --enable-autoupgrade

Ersetzen Sie Folgendes: * NODEPOOL_NAME: den Namen für Ihren Knotenpool. * CLUSTER_NAME: Der Name Ihres Clusters. * CONTROL_PLANE_LOCATION: Der Compute Engine-Standort der Steuerungsebene Ihres Clusters. Geben Sie für regionale Cluster eine Region und für zonale Cluster eine Zone an.

DRA-Treiber aufrufen und installieren

In den folgenden Abschnitten erfahren Sie, wie Sie DRA-Treiber für GPUs und TPUs installieren. Mit den DRA-Treibern kann Kubernetes die angehängten Geräte dynamisch Arbeitslasten zuweisen. Sie können DRA-Treiber für GPUs und TPUs mit dem bereitgestellten Helm-Diagramm installieren. So erhalten Sie Zugriff auf die Helm-Charts:

  1. Klonen Sie das Repository ai-on-gke, um auf die Helm-Diagramme zuzugreifen, die die DRA-Treiber für GPUs und TPUs enthalten:

    git clone https://github.com/GoogleCloudPlatform/ai-on-gke/common-infra.git

  2. Wechseln Sie in das Verzeichnis, das die Diagramme enthält:

    cd common-infra/common/charts

DRA-Treiber auf GPUs installieren

Nachdem Sie Zugriff auf das Helm-Chart mit DRA-Treibern haben, installieren Sie den DRA-Treiber für GPUs, indem Sie den folgenden Schritt ausführen:

COS 

helm upgrade -i --create-namespace --namespace nvidia nvidia-dra-driver-gpu nvidia-dra-driver-gpu/ \
    --set image.repository=ghcr.io/nvidia/k8s-dra-driver-gpu \
    --set image.tag=d1fad7ed-ubi9 \
    --set image.pullPolicy=Always \
    --set controller.priorityClassName="" \
    --set kubeletPlugin.priorityClassName="" \
    --set nvidiaDriverRoot="/home/kubernetes/bin/nvidia/" \
    --set nvidiaCtkPath=/home/kubernetes/bin/nvidia/toolkit/nvidia-ctk \
    --set deviceClasses="{gpu}" \
    --set gpuResourcesEnabledOverride=true \
    --set resources.computeDomains.enabled=false \
    --set kubeletPlugin.tolerations[0].key=nvidia.com/gpu \
    --set kubeletPlugin.tolerations[0].operator=Exists \
    --set kubeletPlugin.tolerations[0].effect=NoSchedule \
    --set kubeletPlugin.tolerations[1].key=cloud.google.com/compute-class \
    --set kubeletPlugin.tolerations[1].operator=Exists \
    --set kubeletPlugin.tolerations[1].effect=NoSchedule

Ubuntu 

helm upgrade -i --create-namespace --namespace nvidia nvidia-dra-driver-gpu nvidia-dra-driver-gpu/ \
    --set image.repository=ghcr.io/nvidia/k8s-dra-driver-gpu \
    --set image.tag=d1fad7ed-ubi9 \
    --set image.pullPolicy=Always \
    --set controller.priorityClassName="" \
    --set kubeletPlugin.priorityClassName="" \
    --set nvidiaDriverRoot="/opt/nvidia" \
    --set nvidiaCtkPath=/home/kubernetes/bin/nvidia/toolkit/nvidia-ctk \
    --set deviceClasses="{gpu}" \
    --set gpuResourcesEnabledOverride=true \
    --set resources.computeDomains.enabled=false \
    --set kubeletPlugin.tolerations[0].key=nvidia.com/gpu \
    --set kubeletPlugin.tolerations[0].operator=Exists \
    --set kubeletPlugin.tolerations[0].effect=NoSchedule \
    --set kubeletPlugin.tolerations[1].key=cloud.google.com/compute-class \
    --set kubeletPlugin.tolerations[1].operator=Exists \
    --set kubeletPlugin.tolerations[1].effect=NoSchedule

DRA-Treiber auf TPUs installieren

Nachdem Sie Zugriff auf das Helm-Diagramm mit den Treibern haben, installieren Sie den TPU-Treiber, indem Sie den folgenden Schritt ausführen:

./tpu-dra-driver/install-tpu-dra-driver.sh

Prüfen, ob Ihre Infrastruktur für DRA bereit ist

Prüfen Sie, ob in ResourceSlice die Hardwaregeräte aufgeführt sind, die Sie hinzugefügt haben:

kubectl get resourceslices -o yaml

Wenn Sie das Beispiel aus dem vorherigen Abschnitt verwendet haben, sieht ResourceSlice je nach verwendeter Hardware etwa so aus:

GPU 

apiVersion: v1
items:
- apiVersion: resource.k8s.io/v1beta1
  kind: ResourceSlice
  metadata:
    # lines omitted for clarity
  spec:
    devices:
    - basic:
        attributes:
          architecture:
            string: Turing
          brand:
            string: Nvidia
          cudaComputeCapability:
            version: 7.5.0
          cudaDriverVersion:
            version: 12.2.0
          driverVersion:
            version: 535.230.2
          index:
            int: 0
          minor:
            int: 0
          productName:
            string: Tesla T4
          type:
            string: gpu
          uuid:
            string: GPU-2087ac7a-f781-8cd7-eb6b-b00943cc13ef
        capacity:
          memory:
            value: 15Gi
      name: gpu-0

TPU 

apiVersion: v1
items:
- apiVersion: resource.k8s.io/v1beta1
  kind: ResourceSlice
  metadata:
    # lines omitted for clarity
  spec:
    devices:
    - basic:
        attributes:
          index:
            int: 0
          tpuGen:
            string: v6e
          uuid:
            string: tpu-54de4859-dd8d-f67e-6f91-cf904d965454
      name: "0"
    - basic:
        attributes:
          index:
            int: 1
          tpuGen:
            string: v6e
          uuid:
            string: tpu-54de4859-dd8d-f67e-6f91-cf904d965454
      name: "1"
    - basic:
        attributes:
          index:
            int: 2
          tpuGen:
            string: v6e
          uuid:
            string: tpu-54de4859-dd8d-f67e-6f91-cf904d965454
      name: "2"
    - basic:
        attributes:
          index:
            int: 3
          tpuGen:
            string: v6e
          uuid:
            string: tpu-54de4859-dd8d-f67e-6f91-cf904d965454
      name: "3"
    driver: tpu.google.com
    nodeName: gke-tpu-b4d4b61b-fwbg
    pool:
      generation: 1
      name: gke-tpu-b4d4b61b-fwbg
      resourceSliceCount: 1
kind: List
metadata:
  resourceVersion: ""

Nächste Schritte