**Unterstützung für die Verbesserung dieser Seite beitragen** 

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Um zu diesem Benutzerhandbuch beizutragen, wählen Sie den GitHub ** Link Diese Seite ** bearbeiten unter, der sich im rechten Bereich jeder Seite befindet.

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Verwenden Sie Timeslicing mit NVIDIA-GPUs auf Amazon EKS
<a name="device-management-nvidia-time-slicing"></a>

Time-slicing ermöglicht es mehreren Pods, sich eine einzige physische NVIDIA-GPU zu teilen. Der Kubernetes-Scheduler platziert mehrere Pods auf derselben GPU, und der CUDA-Scheduler der GPU multiplext die Arbeit. Time-slicing GPU-sharing ist die einfachste Strategie. Es verwendet nur Software, erfordert keine spezielle Hardware und funktioniert auf jedem NVIDIA-GPU-Instance-Typ AWS. Time-slicing bietet keine Speicher- oder Rechenisolierung zwischen Pods, die sich eine GPU teilen. Es eignet sich am besten für Workloads mit niedriger GPU-Auslastung, z. B. für Inferenzdienste, die zwischen Anfragen inaktiv sind, oder für Entwicklungsumgebungen, in denen sich mehrere Benutzer eine GPU teilen. Verwenden Sie stattdessen Multi-Instance GPU (MIG) für Workloads, die Speicher auf Hardwareebene und Rechenisolierung erfordern.

In Amazon EKS können Sie Timeslicing entweder mit dem [ NVIDIA DRA-Treiber ](device-management-nvidia-dra-device-plugin.md#eks-nvidia-dra-driver) oder dem NVIDIA-Geräte-Plugin verwalten. [Installieren Sie das NVIDIA Kubernetes-Geräte-Plugin](device-management-nvidia-dra-device-plugin.md#eks-nvidia-device-plugin)

Time-slicing kann nur mit Karpenter verwendet werden, wenn Sie statische Kapazitätsbereitstellung verwenden[. ](https://karpenter.sh/docs/concepts/nodepools/#static-nodepool) Time-slicing ist derzeit nicht im EKS-Automatikmodus verfügbar.

Time-slicing passt gut, wenn:
+ Die GPU-Auslastung ist durchweg gering, z. B. bei latenzempfindlichen Inferenzdiensten, die zwischen Anfragen inaktiv sind.
+ Mehrere Entwickler teilen sich einen einzigen GPU-Knoten für Notebook- oder Entwicklungsarbeiten.
+ Ihre Knoten verwenden einen GPU-Instance-Typ, der MIG nicht unterstützt, wie z. B. die `g6e` Familien `g5``g6`,, oder.
+ Sie können akzeptieren, dass ein Pod gelegentlich langsamer ist, weil ein anderer Pod auf derselben GPU ausgelastet ist.

Erwägen Sie einen anderen Ansatz, wenn:
+ Sie benötigen eine Speicherisolierung. Pods auf einer GPU mit Zeitaufteilung teilen sich denselben GPU-Speicher, und ein Pod kann den Speicher erschöpfen, auf den andere Pods angewiesen sind. Verwenden Sie MIG für die Speicherisolierung.
+ Sie benötigen eine vorhersehbare Latenz oder Servicequalität pro Pod. Der GPU-Scheduler verteilt die Rechenleistung nach bestem Bemühen ohne Garantien auf mehrere Steckplätze.
+ Sie führen Trainings-Workloads aus. Time-slicing fügt Kontextwechsel hinzu, der die Trainingseffizienz reduziert. Ein Checkpoint-Job, den ein anderer Pod verlangsamt, muss von seinem letzten Checkpoint aus erneut versucht werden.

## Überlegungen
<a name="eks-time-slicing-considerations"></a>

Lesen Sie die folgenden Überlegungen, bevor Sie Time-Slicing in der Produktion einsetzen.

### Allgemeine Überlegungen
<a name="_general_considerations"></a>
+  **Keine Speicherisolierung: ** Pods, die sich eine Time-Slice-GPU teilen, teilen sich ihren Speicher. Ein Pod kann Speicher zuweisen, den andere Pods benötigen, was zu Fehlern bei unzureichendem Arbeitsspeicher führen kann. Passen Sie die Anzahl der Pods, die sich jede GPU teilen, an den Speicherbedarf Ihrer Workloads an. Wenn Ihre Pods regelmäßig große Modelle laden, teilen Sie sich weniger Pods pro GPU oder verwenden Sie MIG.
+  **Best-effort gemeinsame Nutzung der Rechenleistung: ** Der GPU-Scheduler teilt die Rechenleistung nach bestem Bemühen auf die Pods auf und garantiert nicht, dass die Rechenleistung für jeden Pod proportional ist.
+  **Time-slicing und MPS kann nicht dieselbe GPU gemeinsam nutzen: ** Time-slicing Stellt den GPU-Rechenmodus auf ein`DEFAULT`, während der Multi-Process NVIDIA-Service (MPS) dies erfordert. `EXCLUSIVE_PROCESS` Sie können beide Strategien im selben Cluster verwenden, jedoch nicht gleichzeitig auf derselben physischen GPU. Time-slicing hat auch keine Auswirkungen auf eine MIG-Instanz. Verwenden Sie stattdessen MPS, um eine einzelne MIG-Instanz containerübergreifend gemeinsam zu nutzen.
+  **Per-container Metriken: ** NVIDIA Data Center GPU Manager (DCGM) kann einzelnen Containern keine Metriken zuordnen, wenn Time-Slicing aktiv ist. GPU-level Metriken sind weiterhin verfügbar, aber Sie können nicht identifizieren, welcher Pod eine bestimmte Menge an GPU-Ressourcen verbraucht hat.

### Überlegungen zum NVIDIA DRA-Treiber
<a name="_nvidia_dra_driver_considerations"></a>
+  **Alpha-Funktion: ** Time-slicing Durch den DRA-Treiber ist das `TimeSlicingSettings` Feature Gate erforderlich. Dabei handelt es sich um eine Alpha-Funktion, die standardmäßig deaktiviert ist. Weitere Informationen finden Sie unter [Verwenden Sie GPU-Timeslicing mit dem NVIDIA DRA-Treiber](#eks-time-slicing-dra).
+  **User-mediated Nur gemeinsame Nutzung: ** Pods teilen sich nur eine GPU, indem sie auf dieselbe `ResourceClaim` oder verweisen, wobei der Namespace-Bereich gilt`ResourceClaimTemplate`, sodass die gemeinsame Nutzung nicht über Namespaces hinweg möglich ist. System-mediated Teilen ist eine vorgeschlagene zukünftige Funktion.
+  **Deaktivieren Sie das integrierte Geräte-Plugin auf Bottlerocket: ** Der DRA-Treiber kann nicht zusammen mit dem NVIDIA-Geräte-Plugin auf demselben Knoten ausgeführt werden. Deaktivieren Sie auf Bottlerocket das integrierte Geräte-Plug-In, für das Bottlerocket Version 1.63.0 oder höher erforderlich ist. Weitere Informationen finden Sie unter [Installieren Sie den NVIDIA DRA-Treiber](device-management-nvidia-dra-device-plugin.md#eks-nvidia-dra-driver).
+  **Rechenunterstützung: ** Der NVIDIA DRA-Treiber wird bei der statischen Kapazitätsbereitstellung in Karpenter, EKS-verwalteten Knotengruppen oder selbstverwalteten Knoten unterstützt und wird im EKS-Automodus nicht unterstützt. Weitere Informationen finden Sie in der statischen NodePool Dokumentation zu Karpenter auf der [ Website von Karpenter. ](https://karpenter.sh/docs/concepts/nodepools/#static-nodepool)

### Überlegungen zum NVIDIA-Geräte-Plugin
<a name="_nvidia_device_plugin_considerations"></a>
+  **Best-effort gemeinsame Nutzung von Rechenleistung mit Steckplätzen: ** Das Geräte-Plug-in kündigt eine feste Anzahl von Steckplätzen pro GPU an. Wenn ein einzelner Pod mehr als einen Slot anfordert, erhält er keine zusätzliche Rechenleistung. Aktivieren Sie die `fail-requests-greater-than-one` Option, um Pods abzulehnen, die mehr als einen Slot anfordern.
+  **Bereitstellung mit Karpenter: ** Karpenter zählt jede `nvidia.com/gpu` Anfrage als physische GPU, auch wenn Time-Slicing auf der GPU aktiviert ist. Weitere Informationen finden Sie in Karpenter Ausgabe \#2140 unter. [https://github.com/kubernetes-sigs/karpenter/issues/2140](https://github.com/kubernetes-sigs/karpenter/issues/2140) GitHub
+  **Keine Unterstützung für den EKS-Automatikmodus: Der ** EKS-Automodus verwaltet das NVIDIA-Geräte-Plug-In und stellt dessen Konfiguration nicht zur Verfügung. Da für Time-Slicing eine Geräte-Plug-in-Konfiguration erforderlich ist, können Sie keine Time-Slicing-Konfiguration auf EKS-Auto-Mode-Knoten anwenden.
+  **Time-slicing Konfigurationsänderungen: ** Das NVIDIA-Geräte-Plugin überwacht das Time-Slicing nicht auf Änderungen. `ConfigMap` Starten Sie das Geräte-Plug-In neu, nachdem Sie die Konfiguration aktualisiert haben.

## Konfigurationsoptionen
<a name="eks-time-slicing-configuration-options"></a>

Sie können Timeslicing für NVIDIA-GPUs mit den NVIDIA-AMIs EKS-optimized AL2023 und Bottlerocket verwenden. Die Time-Slicing-Einstellungen variieren je nachdem, ob Sie den NVIDIA DRA-Treiber oder das NVIDIA-Geräte-Plug-In verwenden.

------
#### [ NVIDIA DRA driver ]

Die EKS-optimized beschleunigten AMIs enthalten den NVIDIA DRA-Treiber nicht. Wenn Sie Bottlerocket verwenden, müssen Sie das integrierte `settings.kubelet-device-plugins.nvidia.enabled = false` NVIDIA-Geräte-Plug-In deaktivieren, bevor Sie den NVIDIA-DRA-Treiber verwenden, indem Sie die Benutzerdaten des Knotens eingeben. Dafür ist Bottlerocket-Version 1.63.0 oder höher erforderlich. Weitere Informationen finden Sie unter [Installieren Sie den NVIDIA DRA-Treiber](device-management-nvidia-dra-device-plugin.md#eks-nvidia-dra-driver).

Mit dem NVIDIA DRA-Treiber wird Time-Slicing über konfiguriert. ResourceClaimTemplates Das `interval` Feld steuert die CUDA-Timeslice-Dauer.


| Intervall | Description | 
| --- | --- | 
| Standard | Verwendet das integrierte Standardintervall des NVIDIA-GPU-Treibers | 
| Short | Kürzeres Intervall; Kontexte wechseln häufiger | 
| Mittel | Zwischenintervall | 
| Long | Jeder Kontext läuft länger pro Spielzug, bevor er unterbrochen wird | 

------
#### [ NVIDIA device plugin ]
+  **Bottlerocket ** — Das AMI enthält ein vorinstalliertes NVIDIA-Geräte-Plugin. Sie konfigurieren Time-Slicing über die Bottlerocket-Einstellungen, ohne dass ein separates Geräte-Plug-In, Helm-Chart oder installiert werden muss. `ConfigMap`
+  **AL2023 ** — Sie installieren das NVIDIA-Geräte-Plugin wie unter beschrieben und stellen die [Installieren Sie das NVIDIA Kubernetes-Geräte-Plugin](device-management-nvidia-dra-device-plugin.md#eks-nvidia-device-plugin) Time-Slicing-Konfiguration über eine bereit. `ConfigMap`

  Die folgenden Optionen steuern, wie das NVIDIA-Geräte-Plugin Time-Slice-GPUs bewirbt und verwaltet. Die Feldnamen unterscheiden sich zwischen den Bottlerocket-Einstellungen und dem AL2023`ConfigMap`, wie in den nachfolgenden Verfahren dargestellt.    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/de_de/eks/latest/userguide/device-management-nvidia-time-slicing.html)

  Eine vollständige Liste der Optionen für die gemeinsame Nutzung von GPUs und deren Standardwerte finden Sie in der Dokumentation zum [ NVIDIA Kubernetes-Geräte-Plug-In unter. ](https://github.com/NVIDIA/k8s-device-plugin/blob/main/README.md#shared-access-to-gpus) GitHub

------

## Verwenden Sie GPU-Timeslicing mit dem NVIDIA DRA-Treiber
<a name="eks-time-slicing-dra"></a>

Mit dem NVIDIA DRA-Treiber teilen sich Pods eine GPU, indem sie `gpu.nvidia.com` `DeviceClass` mit einem Time-Slicing auf einen Common verweisen`ResourceClaim`, der den anfordert. `GpuConfig`

Der NVIDIA DRA-Treiber implementiert derzeit ein * vom Benutzer vermitteltes * Time-Slicing: Eine GPU wird nur von den Pods und Containern gemeinsam genutzt, auf die Sie ausdrücklich auf dieselbe Behauptung hinweisen. Da a `ResourceClaim` und a einen Namespace-Bereich haben, müssen `ResourceClaimTemplate` sich die Pods, die auf diese Weise eine GPU teilen, im selben Namespace befinden. Um eine GPU für mehrere Container in einem einzelnen Pod gemeinsam zu nutzen, müssen Sie dafür sorgen, dass jeder Container im Claim auf denselben Anforderungsnamen verweist. Container, die auf unterschiedliche Anforderungsnamen verweisen, erhalten jeweils eine separate GPU. Erstellen Sie ein separates Intervall `ResourceClaimTemplate` für jedes Zeitintervall, das Sie benötigen, und eines für jeden Namespace, in dem Sie GPUs gemeinsam nutzen möchten.

 *System-mediated*Beim Timeslicing teilt sich der Treiber eine GPU für unabhängige Claims (einschließlich Namespaces), und zwar auf der Grundlage von Kriterien, die das System definiert, und nicht anhand eines von Ihnen konfigurierten Claims. Weitere Informationen zum systemgestützten Time-Slicing finden Sie unter Time-Slicing von GPUs (Ausgabe \#659) und unter [ System-mediated Pull Request \#1257 unter. ](https://github.com/kubernetes-sigs/dra-driver-nvidia-gpu/issues/659) [https://github.com/kubernetes-sigs/dra-driver-nvidia-gpu/pull/1257](https://github.com/kubernetes-sigs/dra-driver-nvidia-gpu/pull/1257) GitHub

**Wichtig**  
Time-slicing Durch den DRA-Treiber wird das `TimeSlicingSettings` Feature Gate benötigt, bei dem es sich um eine Alpha-Funktion handelt, die standardmäßig deaktiviert ist. Wenn Sie die `TimeSlicing` Sharing-Strategie anfordern, ohne dieses Feature Gate zu aktivieren, kann der Treiber das Gerät nicht vorbereiten und der Pod bleibt `ContainerCreating` mit einem `FailedPrepareDynamicResources` Ereignis verbunden, das gemeldet wird`error validating GPU config: unknown GPU sharing strategy: TimeSlicing`. Aktiviere das Feature Gate nur, wenn du die Risiken akzeptierst, die mit der Verwendung einer Alpha-Funktion verbunden sind.

### Voraussetzungen
<a name="_prerequisites"></a>
+ Ein Amazon EKS-Cluster, auf dem Kubernetes Version 1.34 oder höher ausgeführt wird. Der NVIDIA DRA-Treiber wird bei der statischen Kapazitätsbereitstellung in Karpenter, EKS-verwalteten Knotengruppen oder selbstverwalteten Knoten unterstützt.
+ Knoten mit NVIDIA-GPU-Instance-Typen, die EKS-optimized das AL2023 NVIDIA AMI verwenden.
+ Der NVIDIA DRA-Treiber wurde wie unter beschrieben installiert[Installieren Sie den NVIDIA DRA-Treiber](device-management-nvidia-dra-device-plugin.md#eks-nvidia-dra-driver), wobei das `TimeSlicingSettings` Feature Gate aktiviert war.

### Verfahren
<a name="_procedure"></a>

1. Erstellen Sie eine`ResourceClaim`, die eine GPU mit der `TimeSlicing` Sharing-Strategie anfordert. Mehrere Pods, die auf diese Behauptung verweisen, verwenden dieselbe physische GPU.

   ```
   cat <<EOF | kubectl apply -f -
   apiVersion: resource.k8s.io/v1
   kind: ResourceClaim
   metadata:
     name: shared-timeslice-gpu
   spec:
     devices:
       requests:
       - name: gpu
         exactly:
           deviceClassName: gpu.nvidia.com
           count: 1
       config:
       - requests: ["gpu"]
         opaque:
           driver: gpu.nvidia.com
           parameters:
             apiVersion: resource.nvidia.com/v1beta1
             kind: GpuConfig
             sharing:
               strategy: TimeSlicing
               timeSlicingConfig:
                 interval: Long
   EOF
   ```

1. Stellen Sie zwei oder mehr Pods bereit, die den gemeinsam genutzten Pods `ResourceClaim` namentlich referenzieren. Jeder Pod verweist über `resourceClaims` und auf den Anspruch`resources.claims`.

   ```
   cat <<EOF | kubectl apply -f -
   apiVersion: v1
   kind: Pod
   metadata:
     name: share-a
   spec:
     tolerations:
       - key: nvidia.com/gpu
         operator: Exists
         effect: NoSchedule
     containers:
       - name: cuda
         image: nvidia/cuda:12.6.0-base-ubuntu22.04
         command: ["nvidia-smi", "-L"]
         resources:
           claims:
           - name: gpu
     resourceClaims:
       - name: gpu
         resourceClaimName: shared-timeslice-gpu
     restartPolicy: OnFailure
   EOF
   ```

1. Stellen Sie sicher, dass die Pods dieselbe physische GPU verwenden. Führen Sie `nvidia-smi -L` jeden Pod aus und vergewissern Sie sich, dass sie dieselbe GPU-UUID melden.

   ```
   kubectl logs share-a
   ```

   Eine Beispielausgabe sieht wie folgt aus. Ein zweiter Pod, der auf dieselbe Behauptung verweist, meldet eine identische `GPU` UUID, was bestätigt, dass sich beide Pods eine physische GPU teilen.

   ```
   GPU 0: NVIDIA L4 (UUID: GPU-b41973ee-5d0a-cde8-6287-12b53f861f02)
   ```

## Verwenden Sie GPU-Time-Slicing auf Bottlerocket-Knoten mit dem NVIDIA-Geräte-Plugin
<a name="eks-time-slicing-device-plugin-bottlerocket"></a>

Auf Bottlerocket enthält das beschleunigte AMI das EKS-optimized NVIDIA-Geräte-Plugin. Sie aktivieren Time-Slicing über die `settings.kubelet-device-plugins.nvidia` Einstellungen, die Bottlerocket beim Booten des Nodes in die Geräte-Plug-in-Konfiguration rendert.

### Voraussetzungen
<a name="_prerequisites_2"></a>
+ Ein Amazon EKS-Cluster. Das folgende Verfahren versorgt NVIDIA-GPU-Knoten mit dem EKS-optimized Bottlerocket NVIDIA AMI.
+ Karpenter wurde in Ihrem Cluster installiert und konfiguriert, da das folgende Verfahren einen Karpenter verwendet, `EC2NodeClass` um die Time-Slicing-Einstellungen in den Benutzerdaten des Bottlerocket-Knotens bereitzustellen. Weitere Informationen finden Sie unter Erste Schritte mit Karpenter auf der [ Karpenter-Website. ](https://karpenter.sh/docs/getting-started/getting-started-with-karpenter/)
+  `kubectl`konfiguriert für die Kommunikation mit Ihrem Cluster, weitere Informationen finden Sie unter[Installieren oder aktualisieren `Sie kubectl`](install-kubectl.md#kubectl-install-update).

### Verfahren
<a name="_procedure_2"></a>

Fügen Sie die Time-Slicing-Einstellungen zu den Bottlerocket-Benutzerdaten für Ihre GPU-Knoten hinzu. Im folgenden Beispiel werden vier Steckplätze pro GPU konfiguriert. Die Art und Weise, wie Sie Benutzerdaten angeben, hängt davon ab, wie Sie Knoten bereitstellen. Das folgende Beispiel zeigt einen Karpenter`EC2NodeClass`.

```
cat <<EOF | kubectl apply -f -
apiVersion: karpenter.k8s.aws/v1
kind: EC2NodeClass
metadata:
  name: gpu-bottlerocket-timeslicing
spec:
  amiFamily: Bottlerocket
  amiSelectorTerms:
    - alias: bottlerocket@latest
  role: eksctl-KarpenterNodeRole-<cluster-name>
  subnetSelectorTerms:
    - tags:
        karpenter.sh/discovery: <cluster-name>
  securityGroupSelectorTerms:
    - tags:
        karpenter.sh/discovery: <cluster-name>
  userData: |
    [settings.kubelet-device-plugins.nvidia]
    device-sharing-strategy = "time-slicing"

    [settings.kubelet-device-plugins.nvidia.time-slicing]
    replicas = 4
    rename-by-default = false
    fail-requests-greater-than-one = true
EOF
```

Wenn Knoten, die mit diesen Einstellungen ausgestattet sind, dem Cluster beitreten, kündigt das Geräte-Plug-In vier `nvidia.com/gpu` Steckplätze für jede physische GPU an. Sie fordern sie in Ihrer Workload-Spezifikation mit Container-Ressourcenanforderungen oder Grenzwerten für die `nvidia.com/gpu` erweiterte Ressource an.

## Verwenden Sie das GPU-Time-Slicing auf AL2023-Knoten mit dem NVIDIA-Geräte-Plugin
<a name="eks-time-slicing-device-plugin-al2023"></a>

Auf AL2023 installieren Sie das NVIDIA-Geräte-Plug-In wie unter beschrieben[Installieren Sie das NVIDIA Kubernetes-Geräte-Plugin](device-management-nvidia-dra-device-plugin.md#eks-nvidia-device-plugin), und stellen die Time-Slicing-Konfiguration in einem bereit. `ConfigMap`

### Voraussetzungen
<a name="_prerequisites_3"></a>
+ Ein Amazon EKS-Cluster mit Knoten, die NVIDIA-GPU-Instance-Typen und das EKS-optimized AL2023 NVIDIA AMI verwenden.
+ Weitere Informationen finden Sie in den [Anweisungen zur Einrichtung von Helm](helm.md).
+  `kubectl`konfiguriert für die Kommunikation mit Ihrem Cluster, weitere Informationen [Installieren oder aktualisieren `Sie kubectl`](install-kubectl.md#kubectl-install-update) finden Sie unter.

### Verfahren
<a name="_procedure_3"></a>

1. Erstellen Sie das Time-Slicing `ConfigMap` in dem `nvidia` Namespace, in dem Sie das Geräte-Plug-In installiert haben. [Installieren Sie das NVIDIA Kubernetes-Geräte-Plugin](device-management-nvidia-dra-device-plugin.md#eks-nvidia-device-plugin) In diesem Beispiel werden vier Steckplätze pro GPU konfiguriert.

   ```
   cat <<EOF | kubectl apply -f -
   apiVersion: v1
   kind: ConfigMap
   metadata:
     name: nvidia-device-plugin-config
     namespace: nvidia
   data:
     config.yaml: |
       version: v1
       sharing:
         timeSlicing:
           renameByDefault: false
           failRequestsGreaterThanOne: true
           resources:
             - name: nvidia.com/gpu
               replicas: 4
   EOF
   ```

1. Aktualisieren Sie die bestehende Version des NVIDIA-Geräte-Plug-ins, um auf `ConfigMap` den `config.name` Wert zu verweisen. Das `--reuse-values` Flag behält die Werte bei, die Sie bei der Installation des Geräte-Plug-ins [Installieren Sie das NVIDIA Kubernetes-Geräte-Plugin](device-management-nvidia-dra-device-plugin.md#eks-nvidia-device-plugin) festgelegt haben.

   ```
   helm upgrade nvdp nvdp/nvidia-device-plugin \
       --namespace nvidia \
       --reuse-values \
       --set config.name=nvidia-device-plugin-config
   ```

**Anmerkung**  
Das Geräte-Plugin wird nicht automatisch neu geladen, wenn Sie das ändern. `ConfigMap` Nachdem Sie die Time-Slicing-Konfiguration aktualisiert haben, starten Sie die Geräte-Plugin-Pods neu, um die Änderung zu übernehmen.

## Stellen Sie sicher, dass das GPU-Time-Slicing aktiv ist
<a name="verify-eks-time-slicing"></a>

Vergewissern Sie sich, dass das Geräte-Plug-in die erwartete Anzahl von Steckplätzen angibt`Ready`, nachdem Ihre Knoten in Zeitaufteilung eingerichtet sind, und dass sich die Pods eine physische GPU teilen.

**Anmerkung**  
Die Überprüfung der gemeinsamen UUID in diesem Verfahren zeigt das Time-Slicing am deutlichsten, wenn die Pods auf derselben physischen GPU landen. Auf einem Knoten mit einer einzigen GPU kündigt das Geräte-Plugin vier Steckplätze an, und alle vier Pods teilen sich diese GPU, sodass sie dieselbe UUID melden. Auf einem Knoten mit mehreren physischen GPUs kann der Scheduler Pods auf verschiedenen GPUs platzieren. Diese Pods melden unterschiedliche UUIDs, obwohl Time-Slicing aktiv ist. Um die gemeinsame Nutzung auf einer GPU zu demonstrieren, planen Sie die Arbeitslast auf einen Instanztyp mit einer einzelnen GPU ein. Fügen Sie beispielsweise einen Knotenselektor hinzu, z. B. `node.kubernetes.io/instance-type: g6.2xlarge` zur Pod-Spezifikation.

1. Vergewissern Sie sich, dass der Knoten die konfigurierte Anzahl von GPU-Steckplätzen bekannt gibt. Bei vier Steckplätzen pro GPU meldet `4` sich ein Knoten mit einer physischen GPU.

   ```
   kubectl get nodes "-o=custom-columns=NAME:.metadata.name,GPU:.status.allocatable.nvidia\.com/gpu"
   ```

   Eine Beispielausgabe sieht wie folgt aus.

   ```
   NAME                                           GPU
   ip-192-168-11-225.us-west-2.compute.internal   4
   ```

1. Erstellen Sie eine Bereitstellung, in der vier Replikate ausgeführt werden, von denen jedes einen GPU-Steckplatz anfordert.

   ```
   cat <<EOF | kubectl apply -f -
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: timeslicing-demo
   spec:
     replicas: 4
     selector:
       matchLabels:
         app: timeslicing-demo
     template:
       metadata:
         labels:
           app: timeslicing-demo
       spec:
         tolerations:
           - key: nvidia.com/gpu
             operator: Exists
             effect: NoSchedule
         containers:
           - name: cuda
             image: nvidia/cuda:12.6.0-base-ubuntu22.04
             command: ["bash", "-c", "nvidia-smi --query-gpu=uuid --format=csv,noheader; sleep infinity"]
             resources:
               limits:
                 nvidia.com/gpu: 1
   EOF
   ```

1. Vergewissern Sie sich, dass alle vier Pods auf demselben Knoten geplant sind.

   ```
   kubectl get pods -l app=timeslicing-demo -o wide
   ```

1. Vergewissern Sie sich, dass alle vier Pods dieselbe GPU-UUID melden. Eine einzige gemeinsame UUID für alle vier Pods bestätigt, dass eine physische GPU im Zeitmultiplex ausgeführt wird.

   ```
   kubectl logs -l app=timeslicing-demo --prefix
   ```

   Eine Beispielausgabe sieht wie folgt aus.

   ```
   [pod/timeslicing-demo-xxxxxxxxxx-aaaaa/cuda] GPU-c0583cce-87c5-c736-db7f-6d3128c84d03
   [pod/timeslicing-demo-xxxxxxxxxx-bbbbb/cuda] GPU-c0583cce-87c5-c736-db7f-6d3128c84d03
   [pod/timeslicing-demo-xxxxxxxxxx-ccccc/cuda] GPU-c0583cce-87c5-c736-db7f-6d3128c84d03
   [pod/timeslicing-demo-xxxxxxxxxx-ddddd/cuda] GPU-c0583cce-87c5-c736-db7f-6d3128c84d03
   ```