**Contribuisci a migliorare questa pagina** 

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Per contribuire a questa guida per l'utente, scegli il GitHub ** link ** Modifica questa pagina su che si trova nel riquadro destro di ogni pagina.

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Usa il time-slicing con le GPU NVIDIA su Amazon EKS
<a name="device-management-nvidia-time-slicing"></a>

Time-slicing consente a più Pod di condividere un'unica GPU fisica NVIDIA. Lo scheduler Kubernetes colloca più Pod sulla stessa GPU e lo scheduler CUDA della GPU multiplica il lavoro nel tempo. Time-slicing è la strategia più semplice. GPU-sharing Utilizza solo software, non richiede hardware speciale e funziona su tutti i tipi di istanze GPU NVIDIA. AWS Time-slicing non offre l'isolamento della memoria o del calcolo tra Pod che condividono una GPU. Si adatta meglio ai carichi di lavoro con un basso utilizzo della GPU, come i servizi di inferenza che rimangono inattivi tra le richieste o gli ambienti di sviluppo in cui più utenti condividono una GPU. Per i carichi di lavoro che richiedono memoria a livello hardware e isolamento di elaborazione, utilizza invece la GPU (MIG). Multi-Instance 

Su Amazon EKS, puoi gestire il time-slicing con il driver NVIDIA DRA o il plug-in del [ dispositivo NVIDIA. ](device-management-nvidia-dra-device-plugin.md#eks-nvidia-dra-driver) [Installa il plug-in del dispositivo NVIDIA Kubernetes](device-management-nvidia-dra-device-plugin.md#eks-nvidia-device-plugin)

Time-slicing può essere utilizzato con Karpenter solo se si utilizza il provisioning statico della capacità. [https://karpenter.sh/docs/concepts/nodepools/#static-nodepool](https://karpenter.sh/docs/concepts/nodepools/#static-nodepool) Time-slicing non è attualmente disponibile in modalità EKS Auto.

Time-slicing è adatto quando:
+ L'utilizzo della GPU è costantemente basso, ad esempio i servizi di inferenza sensibili alla latenza che rimangono inattivi tra una richiesta e l'altra.
+ Diversi sviluppatori condividono un singolo nodo GPU per il notebook o il lavoro di sviluppo.
+ I nodi utilizzano un tipo di istanza GPU che non supporta MIG, ad esempio le famiglie `g5``g6`, o. `g6e`
+ Puoi accettare che un Pod sia occasionalmente più lento perché un altro Pod sulla stessa GPU è occupato.

Prendi in considerazione un approccio diverso quando:
+ È necessario l'isolamento della memoria. I pod su una GPU frazionata condividono la stessa memoria della GPU e un Pod può esaurire la memoria su cui fanno affidamento gli altri Pod. Usa MIG per l'isolamento della memoria.
+ È necessaria una latenza per POD o una qualità del servizio prevedibili. Lo scheduler GPU condivide l'elaborazione tra gli slot nel migliore dei modi e senza garanzie.
+ Esegui carichi di lavoro di formazione. Time-slicing aggiunge il cambio di contesto che riduce l'efficienza della formazione. Un processo sottoposto a checkpoint rallentato da un altro Pod deve riprovare dall'ultimo checkpoint.

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

Esamina le seguenti considerazioni prima di utilizzare il time-slicing in produzione.

### Considerazioni generali
<a name="_general_considerations"></a>
+  **Nessun isolamento della memoria: ** i pod che condividono una GPU suddivisa in base al tempo condividono la stessa memoria. Un Pod può allocare la memoria necessaria ad altri Pod, il che può causare errori di esaurimento della memoria. Abbina il numero di Pod che condividono ciascuna GPU all'ingombro di memoria dei tuoi carichi di lavoro. Se i tuoi Pod caricano regolarmente modelli di grandi dimensioni, condividi meno Pod per GPU o usa MIG.
+  **Best-effort condivisione dell'elaborazione: lo scheduler GPU condivide ** l'elaborazione tra i Pod nel migliore dei modi e non garantisce un calcolo proporzionale per ciascun Pod.
+  **Time-slicing e MPS non può condividere la stessa GPU: ** Time-slicing imposta la modalità di elaborazione della GPU su, mentre NVIDIA Service (MPS) lo richiede. `DEFAULT` Multi-Process `EXCLUSIVE_PROCESS` È possibile utilizzare entrambe le strategie nello stesso cluster, ma non sulla stessa GPU fisica contemporaneamente. Time-slicing inoltre non ha effetto su un'istanza MIG. Per condividere una singola istanza MIG tra contenitori, utilizzate invece MPS.
+  **Per-container metriche: ** NVIDIA Data Center GPU Manager (DCGM) non può attribuire metriche ai singoli contenitori quando il time-slicing è attivo. GPU-level le metriche rimangono disponibili, ma non è possibile identificare quale Pod abbia consumato una determinata quantità di risorse GPU.

### considerazioni sui driver NVIDIA DRA
<a name="_nvidia_dra_driver_considerations"></a>
+  **Funzione alfa: ** Time-slicing tramite il driver DRA è necessaria la `TimeSlicingSettings` feature gate, che è una funzionalità alfa disattivata per impostazione predefinita. Per ulteriori informazioni, consulta [Usa il time-slicing della GPU con il driver NVIDIA DRA](#eks-time-slicing-dra).
+  **User-mediated solo condivisione: ** i pod condividono una GPU solo facendo riferimento alla stessa `ResourceClaim` o`ResourceClaimTemplate`, con ambito di namespace, quindi la condivisione non può attraversare namespace. System-mediated la condivisione è una capacità futura proposta.
+  **Disabilita il plug-in del dispositivo integrato su Bottlerocket: ** il driver DRA non può essere eseguito insieme al plug-in del dispositivo NVIDIA sullo stesso nodo. Su Bottlerocket, disabilita il plug-in del dispositivo integrato, che richiede la versione Bottlerocket 1.63.0 o successiva. Per ulteriori informazioni, consulta [Installa il driver NVIDIA DRA](device-management-nvidia-dra-device-plugin.md#eks-nvidia-dra-driver).
+  **Supporto di elaborazione: ** il driver NVIDIA DRA è supportato con il provisioning della capacità statica in Karpenter, gruppi di nodi gestiti da EKS o nodi autogestiti e non è supportato con EKS Auto Mode. Per ulteriori informazioni, consulta la documentazione statica di Karpenter sul sito Web di [ Karpenter. NodePool ](https://karpenter.sh/docs/concepts/nodepools/#static-nodepool)

### Considerazioni sui plug-in dei dispositivi NVIDIA
<a name="_nvidia_device_plugin_considerations"></a>
+  **Best-effort condivisione del computer con slot: ** il plug-in del dispositivo pubblicizza un numero fisso di slot per GPU. Se un singolo Pod richiede più di uno slot, non riceve elaborazione aggiuntiva. Abilita l'`fail-requests-greater-than-one`opzione per rifiutare i Pod che richiedono più di uno slot.
+  **Provisioning con Karpenter: ** Karpenter conta ogni `nvidia.com/gpu` richiesta come GPU fisica anche quando il time-slicing è abilitato sulla GPU. Per ulteriori informazioni, consulta il numero \#2140 di Karpenter su. [https://github.com/kubernetes-sigs/karpenter/issues/2140](https://github.com/kubernetes-sigs/karpenter/issues/2140) GitHub
+  **Nessun supporto per la modalità EKS Auto: ** EKS Auto Mode gestisce il plug-in del dispositivo NVIDIA e non ne espone la configurazione. Poiché il time-slicing richiede la configurazione del plug-in del dispositivo, non è possibile applicare una configurazione time-slicing sui nodi EKS Auto Mode.
+  **Time-slicing modifiche alla configurazione: ** il plug-in del dispositivo NVIDIA non monitora il time-slicing per eventuali modifiche. `ConfigMap` Riavvia il plug-in del dispositivo dopo aver aggiornato la configurazione.

## Opzioni di configurazione
<a name="eks-time-slicing-configuration-options"></a>

È possibile utilizzare il time-slicing per le GPU NVIDIA con le AMI NVIDIA EKS-optimized AL2023 e Bottlerocket. Le impostazioni del time-slicing variano a seconda che si stia utilizzando il driver NVIDIA DRA o il plug-in del dispositivo NVIDIA.

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

Le AMI EKS-optimized accelerate non includono il driver NVIDIA DRA. Se si utilizza Bottlerocket, è necessario disabilitare il plug-in del dispositivo NVIDIA integrato prima di utilizzare il driver NVIDIA DRA impostando i dati utente del nodo, che richiede Bottlerocket versione `settings.kubelet-device-plugins.nvidia.enabled = false` 1.63.0 o successiva. Per ulteriori informazioni, consulta [Installa il driver NVIDIA DRA](device-management-nvidia-dra-device-plugin.md#eks-nvidia-dra-driver).

Con il driver NVIDIA DRA, il time-slicing è configurato tramite. ResourceClaimTemplates Il `interval` campo controlla la durata del time-slice CUDA.


| Interval | Description | 
| --- | --- | 
| Predefinita | Utilizza l'intervallo predefinito integrato nel driver GPU NVIDIA | 
| Breve | Intervallo più breve; i contesti cambiano più frequentemente | 
| Media | Intervallo intermedio | 
| Long | ogni contesto dura più a lungo per turno prima di essere annullato | 

------
#### [ NVIDIA device plugin ]
+  **Bottlerocket**: l'AMI include un plug-in per dispositivi NVIDIA preinstallato. Puoi configurare il time-slicing tramite le impostazioni di Bottlerocket, senza l'installazione separata del plug-in del dispositivo, del diagramma Helm o. `ConfigMap`
+  **AL2023 ** — Si installa il plug-in del dispositivo NVIDIA come descritto in [Installa il plug-in del dispositivo NVIDIA Kubernetes](device-management-nvidia-dra-device-plugin.md#eks-nvidia-device-plugin) e si fornisce la configurazione del time-slicing tramite un. `ConfigMap`

  Le seguenti opzioni controllano il modo in cui il plug-in del dispositivo NVIDIA pubblicizza e gestisce le GPU time-sliced. I nomi dei campi differiscono tra le impostazioni Bottlerocket e AL2023`ConfigMap`, come mostrato nelle procedure che seguono.    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/it_it/eks/latest/userguide/device-management-nvidia-time-slicing.html)

  Per l'elenco completo delle opzioni di condivisione della GPU e dei relativi valori predefiniti, consulta la documentazione del plug-in per dispositivi [ NVIDIA Kubernetes su. ](https://github.com/NVIDIA/k8s-device-plugin/blob/main/README.md#shared-access-to-gpus) GitHub

------

## Usa il time-slicing della GPU con il driver NVIDIA DRA
<a name="eks-time-slicing-dra"></a>

Con il driver NVIDIA DRA, i Pod condividono una GPU facendo riferimento a una comune che la richiede con un time-slicing. `ResourceClaim` `gpu.nvidia.com` `DeviceClass` `GpuConfig`

Il driver NVIDIA DRA attualmente implementa il * time-slicing * mediato dall'utente: una GPU è condivisa solo tra i Pod e i contenitori a cui si fa esplicitamente riferimento alla stessa dichiarazione. Poiché a `ResourceClaim` e a hanno un ambito di namespace, `ResourceClaimTemplate` i Pod che condividono una GPU in questo modo devono trovarsi nello stesso namespace. Per condividere una GPU tra contenitori in un singolo pod, fai in modo che ogni contenitore faccia riferimento allo stesso nome di richiesta nel claim. I contenitori che fanno riferimento a nomi di richiesta diversi ricevono ciascuno una GPU separata. Creane uno separato `ResourceClaimTemplate` per ogni intervallo di tempo necessario e uno in ogni namespace in cui desideri condividere le GPU.

 *System-mediated*il time-slicing si verifica quando il driver condivide una GPU tra claim indipendenti (inclusi namespace) in base a criteri definiti dal sistema anziché a un claim configurato dall'utente. Per ulteriori informazioni sul time-slicing mediato dal sistema, vedi [ System-mediated time-slicing of GPU (issue \#659) e pull request \#1257 on. ](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

**Importante**  
Time-slicing tramite il driver DRA richiede il `TimeSlicingSettings` feature gate, che è una funzionalità alfa disattivata per impostazione predefinita. Se richiedi la strategia di `TimeSlicing` condivisione senza abilitare questa funzionalità, il driver non riesce a preparare il dispositivo e il Pod rimane aggiornato `ContainerCreating` con un `FailedPrepareDynamicResources` evento che segnala`error validating GPU config: unknown GPU sharing strategy: TimeSlicing`. Abilita il feature gate solo se accetti i rischi derivanti dall'utilizzo di una funzionalità alfa.

### Prerequisiti
<a name="_prerequisites"></a>
+ Un cluster Amazon EKS che esegue Kubernetes versione 1.34 o successiva. Il driver NVIDIA DRA è supportato con il provisioning statico della capacità in Karpenter, gruppi di nodi gestiti EKS o nodi autogestiti.
+ Nodi con tipi di istanze GPU NVIDIA che utilizzano l'AMI NVIDIA AL2023. EKS-optimized 
+ Il driver NVIDIA DRA è stato installato come descritto in[Installa il driver NVIDIA DRA](device-management-nvidia-dra-device-plugin.md#eks-nvidia-dra-driver), con il feature gate abilitato. `TimeSlicingSettings`

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

1. Crea un file `ResourceClaim` che richieda una GPU con la `TimeSlicing` strategia di condivisione. Più pod che fanno riferimento a questa affermazione condividono la stessa GPU fisica.

   ```
   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. Distribuisci due o più Pod che fanno riferimento al nome condiviso. `ResourceClaim` Ogni Pod fa riferimento al reclamo tramite `resourceClaims` e. `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. Verifica che i Pod condividano la stessa GPU fisica. Esegui `nvidia-smi -L` in ogni Pod e conferma che riportino lo stesso UUID della GPU.

   ```
   kubectl logs share-a
   ```

   Di seguito viene riportato un output di esempio. Un secondo Pod che fa riferimento alla stessa affermazione riporta un `GPU` UUID identico, il che conferma che entrambi i Pod condividono una GPU fisica.

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

## Usa il time-slicing della GPU sui nodi Bottlerocket con il plug-in per dispositivi NVIDIA
<a name="eks-time-slicing-device-plugin-bottlerocket"></a>

Su Bottlerocket, l'AMI accelerata include il plug-in del dispositivo NVIDIA. EKS-optimized Si abilita la suddivisione temporale `settings.kubelet-device-plugins.nvidia` delle impostazioni, che Bottlerocket trasforma nella configurazione del plug-in del dispositivo all'avvio del nodo.

### Prerequisiti
<a name="_prerequisites_2"></a>
+ Un cluster Amazon EKS. La seguente procedura fornisce ai nodi GPU NVIDIA l'AMI NVIDIA EKS-optimized Bottlerocket.
+ Karpenter è stato installato e configurato nel cluster, poiché la procedura seguente utilizza un Karpenter per fornire le impostazioni di time-slicing nei dati utente del nodo `EC2NodeClass` Bottlerocket. Per ulteriori informazioni, consulta la Guida introduttiva a Karpenter sul sito Web di Karpenter[. ](https://karpenter.sh/docs/getting-started/getting-started-with-karpenter/)
+  `kubectl`configurato per comunicare con il tuo cluster, vedi [`Installa o aggiorna kubectl`](install-kubectl.md#kubectl-install-update) per ulteriori informazioni.

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

Aggiungi le impostazioni di time-slicing ai dati utente di Bottlerocket per i tuoi nodi GPU. L'esempio seguente configura quattro slot per GPU. Il modo in cui fornisci i dati utente dipende dal modo in cui esegui il provisioning dei nodi. L'esempio seguente mostra un 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
```

Quando i nodi dotati di queste impostazioni si uniscono al cluster, il plug-in del dispositivo annuncia quattro `nvidia.com/gpu` slot per ogni GPU fisica. Li richiedi nelle specifiche del carico di lavoro con le richieste di risorse del contenitore o i limiti per la risorsa estesa. `nvidia.com/gpu`

## Usa il time-slicing della GPU sui nodi AL2023 con il plug-in per dispositivi NVIDIA
<a name="eks-time-slicing-device-plugin-al2023"></a>

Su AL2023, installi il plug-in del dispositivo NVIDIA come descritto in e fornisci la configurazione del time-slicing in [Installa il plug-in del dispositivo NVIDIA Kubernetes](device-management-nvidia-dra-device-plugin.md#eks-nvidia-device-plugin) un. `ConfigMap`

### Prerequisiti
<a name="_prerequisites_3"></a>
+ Un cluster Amazon EKS con nodi che utilizzano i tipi di istanza GPU NVIDIA e l'AMI NVIDIA AL2023. EKS-optimized 
+ Helm è installato nell’ambiente a riga di comando, consulta le [istruzioni di configurazione di Helm](helm.md) per ulteriori informazioni.
+  `kubectl`configurato per comunicare con il tuo cluster, consulta [`Installa o aggiorna kubectl`](install-kubectl.md#kubectl-install-update) per ulteriori informazioni.

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

1. Crea il time-slicing `ConfigMap` nel `nvidia` namespace in cui hai installato il plug-in del dispositivo. [Installa il plug-in del dispositivo NVIDIA Kubernetes](device-management-nvidia-dra-device-plugin.md#eks-nvidia-device-plugin) Questo esempio configura quattro slot per GPU.

   ```
   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. Aggiorna la versione esistente del plug-in del dispositivo NVIDIA per fare riferimento `ConfigMap` al valore. `config.name` Il `--reuse-values` flag conserva i valori impostati quando hai installato il plug-in del dispositivo in. [Installa il plug-in del dispositivo NVIDIA Kubernetes](device-management-nvidia-dra-device-plugin.md#eks-nvidia-device-plugin)

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

**Nota**  
Il plug-in del dispositivo non si ricarica automaticamente quando si modifica il. `ConfigMap` Dopo aver aggiornato la configurazione del time-slicing, riavvia il plug-in del dispositivo Pods per applicare la modifica.

## Verifica che il time-slicing della GPU sia attivo
<a name="verify-eks-time-slicing"></a>

Una volta terminata la suddivisione temporale dei nodi`Ready`, verificate che il plug-in del dispositivo indichi il numero previsto di slot e che i Pod condividano una GPU fisica.

**Nota**  
Il controllo degli UUID condivisi in questa procedura dimostra più chiaramente il time-slicing quando i Pod atterrano sulla stessa GPU fisica. Su un nodo con una sola GPU, il plug-in del dispositivo pubblicizza quattro slot e tutti e quattro i Pod condividono la stessa GPU, quindi riportano lo stesso UUID. Su un nodo con più GPU fisiche, lo scheduler può posizionare i Pod su GPU diverse. Questi Pod riportano UUID diversi anche se il time-slicing è attivo. Per dimostrare la condivisione su una GPU, pianifica il carico di lavoro su un tipo di istanza a GPU singola. Ad esempio, aggiungi un selettore di nodi come `node.kubernetes.io/instance-type: g6.2xlarge` nella specifica Pod.

1. Verifica che il nodo indichi il numero configurato di slot GPU. Con quattro slot per GPU, viene segnalato un nodo con una GPU fisica. `4`

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

   Di seguito viene riportato un output di esempio.

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

1. Crea una distribuzione che esegua quattro repliche, ognuna delle quali richiede uno slot GPU.

   ```
   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. Verifica che tutti e quattro i Pod siano pianificati sullo stesso nodo.

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

1. Conferma che tutti e quattro i Pod riportino lo stesso UUID della GPU. Un singolo UUID condiviso tra tutti e quattro i Pod conferma che una GPU fisica viene multiplexata nel tempo.

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

   Di seguito viene riportato un output di esempio.

   ```
   [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
   ```