Diese Seite wurde von der Cloud Translation API übersetzt.

Geräte mit DRA dynamisch Arbeitslasten zuweisen

Standard

Auf dieser Seite wird erläutert, wie Sie Arbeitslasten mit dynamischer Ressourcenzuweisung (Dynamic Resource Allocation, DRA) in Ihren Google Kubernetes Engine-Clustern bereitstellen. Auf dieser Seite erstellen Sie eine ResourceClaimTemplate, um Hardware mit DRA anzufordern, und stellen dann eine einfache Arbeitslast bereit, um zu demonstrieren, wie Kubernetes Hardware flexibel für Ihre Pods zuweist.

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

Dynamische Ressourcenzuweisung

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.

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 in einem 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 innerhalb einer DeviceClass nach bestimmten Parametern filtert.
ResourceClaimTemplate: Eine ResourceClaimTemplate definiert eine Vorlage, die Pods verwenden können, um automatisch neue ResourceClaims pro Pod zu erstellen.

Weitere Informationen zu ResourceClaim- und ResourceClaimTemplate-Objekten finden Sie unter Wann sollten ResourceClaims und ResourceClaimTemplates verwendet werden?.

In den Beispielen auf dieser Seite wird ein einfaches ResourceClaimTemplate verwendet, um die angegebene Gerätekonfiguration anzufordern. Weitere Informationen finden Sie in der ResourceClaimTemplateSpec-Dokumentation zu Kubernetes.

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.32.1-gke.1489001 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 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.
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. Durch das Festlegen eines Standardspeicherorts können Sie in der gcloud CLI Fehler wie One of [--zone, --region] must be supplied: Please specify location vermeiden. 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 Gerätezuweisung pro Pod anfordern möchten, erstellen Sie zuerst ein ResourceClaimTemplate, das ein ResourceClaim erzeugt, um Ihre Anfrage für GPUs oder TPUs zu beschreiben. Kubernetes verwendet dieses als Vorlage, um für jeden Pod in einer Arbeitslast neue ResourceClaim-Objekte zu erstellen. Wenn Sie ResourceClaimTemplate in einer Arbeitslast angeben, weist Kubernetes die angeforderten Ressourcen zu und plant die Pods auf entsprechenden Knoten.

GPU

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

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

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

Speichern Sie zum Erstellen eines Workloads, der auf das 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: ["while [ 1 ]; do date; echo $(nvidia-smi -L || echo Waiting...); sleep 60; done"]
        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/v1beta1
kind: ResourceClaimTemplate
metadata:
  name: tpu-claim-template
spec:
  spec:
    devices:
      requests:
      - name: all-tpus
        deviceClassName: tpu.google.com
        allocationMode: All

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

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

Speichern Sie zum Erstellen eines Workloads, der auf das 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 ResourceClaim aufrufen oder sich die Logs für Ihren Pod ansehen.