Geräte mit DRA dynamisch Arbeitslasten zuweisen

Standard

Mit der dynamischen Ressourcenzuweisung (Dynamic Resource Allocation, DRA) können Sie Geräte flexibel für Ihre Google Kubernetes Engine-Arbeitslasten (GKE) anfordern. In diesem Dokument wird beschrieben, wie Sie ein ResourceClaimTemplate erstellen, um Geräte anzufordern, und dann eine Arbeitslast erstellen, um zu beobachten, wie Kubernetes die Geräte flexibel Ihren Pods zuweist.

Dieses Dokument richtet sich an Anwendungsoperatoren und Data Engineers, die Arbeitslasten wie KI/ML oder Hochleistungs-Computing (HPC) ausführen.

Geräte mit DRA anfordern

Wenn Sie Ihre GKE-Infrastruktur für DRA einrichten, erstellen die DRA-Treiber auf Ihren Knoten DeviceClass-Objekte im Cluster. Eine DeviceClass definiert eine Kategorie von Geräten, z. B. GPUs, die für Arbeitslasten angefordert werden können. Ein Plattformadministrator kann optional zusätzliche DeviceClasses bereitstellen, die einschränken, welche Geräte Sie in bestimmten Arbeitslasten anfordern können.

Wenn Sie Geräte innerhalb einer DeviceClass anfordern möchten, erstellen Sie eines der folgenden Objekte:

ResourceClaim: Mit einem ResourceClaim kann ein Pod oder ein Nutzer Hardware-Ressourcen anfordern, indem er nach bestimmten Parametern innerhalb einer DeviceClass filtert.
ResourceClaimTemplate: Eine ResourceClaimTemplate definiert eine Vorlage, die Pods verwenden können, um automatisch neue ResourceClaims pro Pod zu erstellen.

Weitere Informationen zu ResourceClaims und ResourceClaimTemplates finden Sie unter Wann sollten ResourceClaims und ResourceClaimTemplates verwendet werden?.

In den Beispielen auf dieser Seite wird eine einfache ResourceClaimTemplate verwendet, um die angegebene Gerätekonfiguration anzufordern. Weitere Informationen zu allen Feldern, die Sie angeben können, finden Sie in der API-Referenz für ResourceClaimTemplate.

Beschränkungen

Die automatische Knotenbereitstellung wird nicht unterstützt.
Autopilot-Cluster unterstützen DRA nicht.
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.34 sein.

Außerdem sollten Sie mit den folgenden Anforderungen und Einschränkungen vertraut sein:

Hinweise

Führen Sie die folgenden Aufgaben aus, bevor Sie beginnen:

Aktivieren Sie die Google Kubernetes Engine API.

Google Kubernetes Engine API aktivieren

Wenn Sie die Google Cloud CLI für diesen Task verwenden möchten, müssen Sie die gcloud CLI installieren und dann initialisieren. Wenn Sie die gcloud CLI bereits installiert haben, rufen Sie die neueste Version mit dem Befehl gcloud components update ab. In früheren gcloud CLI-Versionen werden die Befehle in diesem Dokument möglicherweise nicht unterstützt.
Hinweis: Legen Sie für vorhandene Installationen der gcloud CLI das compute/region-Attribut fest. Wenn Sie hauptsächlich zonale Cluster verwenden, legen Sie stattdessen compute/zone fest. Wenn Sie einen standardmäßigen Speicherort festlegen, können Sie in der gcloud CLI Fehler wie diesen vermeiden: One of [--zone, --region] must be supplied: Please specify location. Bei bestimmten Befehlen müssen Sie möglicherweise den Speicherort angeben, wenn er sich von dem von Ihnen festgelegten Standard unterscheidet.

GKE-Cluster für DRA-Arbeitslasten konfigurieren

DRA zum Bereitstellen von Arbeitslasten verwenden

Wenn Sie die Zuweisung von Geräten pro Pod anfordern möchten, erstellen Sie ein ResourceClaimTemplate mit der gewünschten Gerätekonfiguration, z. B. GPUs eines bestimmten Typs. Wenn Sie eine Arbeitslast bereitstellen, die auf das ResourceClaimTemplate verweist, erstellt Kubernetes ResourceClaims für jeden Pod in der Arbeitslast basierend auf dem ResourceClaimTemplate. Kubernetes weist die angeforderten Ressourcen zu und plant die Pods auf entsprechenden Knoten.

Wenn Sie Geräte in einem Arbeitslast mit DRA anfordern möchten, wählen Sie eine der folgenden Optionen aus:

GPU

Speichern Sie das folgende Manifest als claim-template.yaml:

apiVersion: resource.k8s.io/v1
kind: ResourceClaimTemplate
metadata:
  name: gpu-claim-template
spec:
  spec:
    devices:
      requests:
      - name: single-gpu
        exactly:
          deviceClassName: gpu.nvidia.com
          allocationMode: ExactCount
          count: 1

Erstellen Sie das ResourceClaimTemplate:
```
kubectl create -f claim-template.yaml
```

Speichern Sie zum Erstellen einer Arbeitslast, die auf die ResourceClaimTemplate verweist, das folgende Manifest als dra-gpu-example.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: dra-gpu-example
spec:
  replicas: 1
  selector:
    matchLabels:
      app: dra-gpu-example
  template:
    metadata:
      labels:
        app: dra-gpu-example
    spec:
      containers:
      - name: ctr
        image: ubuntu:22.04
        command: ["bash", "-c"]
        args: ["echo $(nvidia-smi -L || echo Waiting...)"]
        resources:
          claims:
          - name: single-gpu
      resourceClaims:
      - name: single-gpu
        resourceClaimTemplateName: gpu-claim-template
      tolerations:
      - key: "nvidia.com/gpu"
        operator: "Exists"
        effect: "NoSchedule"

Arbeitslast bereitstellen:
```
kubectl create -f dra-gpu-example.yaml
```

TPU

Speichern Sie das folgende Manifest als claim-template.yaml:

apiVersion: resource.k8s.io/v1
kind: ResourceClaimTemplate
metadata:
  name: tpu-claim-template
spec:
  spec:
    devices:
      requests:
      - name: all-tpus
        exactly:
          deviceClassName: tpu.google.com
          allocationMode: All

Mit dieser ResourceClaimTemplate wird angefordert, dass GKE jedem ResourceClaim einen gesamten TPU-Knotenpool zuweist.

Erstellen Sie das ResourceClaimTemplate:
```
kubectl create -f claim-template.yaml
```

Speichern Sie zum Erstellen einer Arbeitslast, die auf die ResourceClaimTemplate verweist, das folgende Manifest als dra-tpu-example.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: dra-tpu-example
spec:
  replicas: 1
  selector:
    matchLabels:
      app: dra-tpu-example
  template:
    metadata:
      labels:
        app: dra-tpu-example
    spec:
      containers:
      - name: ctr
        image: ubuntu:22.04
        command:
          - /bin/sh
          - -c
          - |
            echo "Environment Variables:"
            env
            echo "Sleeping indefinitely..."
            sleep infinity
        resources:
          claims:
          - name: all-tpus
      resourceClaims:
      - name: all-tpus
        resourceClaimTemplateName: tpu-claim-template
      tolerations:
      - key: "google.com/tpu"
        operator: "Exists"
        effect: "NoSchedule"

Arbeitslast bereitstellen:
```
kubectl create -f dra-tpu-example.yaml
```

Hardwarezuweisung prüfen

Sie können prüfen, ob Ihren Arbeitslasten Hardware zugewiesen wurde, indem Sie den ResourceClaim oder die Logs für Ihren Pod ansehen. Wählen Sie eine der folgenden Optionen aus, um die Zuweisung für GPUs oder TPUs zu prüfen: