**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 driver o il plug-in del dispositivo NVIDIA DRA su Amazon EKS Amazon EKS supporta due meccanismi per la gestione dei dispositivi GPU NVIDIA nei tuoi cluster EKS: il driver NVIDIA DRA per GPU e il plug-in per dispositivi * NVIDIA Kubernetes. * * * Consigliamo di utilizzare il driver NVIDIA DRA per le nuove implementazioni con Kubernetes versioni 1.34 e successive quando si utilizza il provisioning della capacità statica in Karpenter, gruppi di nodi gestiti da EKS o nodi autogestiti. [https://karpenter.sh/docs/concepts/nodepools/#static-nodepool](https://karpenter.sh/docs/concepts/nodepools/#static-nodepool) Il driver NVIDIA DRA non è attualmente supportato con EKS Auto Mode. Usa il plug-in del dispositivo [ NVIDIA ](#eks-nvidia-device-plugin) con EKS Auto Mode o con Karpenter quando usi il provisioning dinamico della capacità. Il plug-in per dispositivi NVIDIA rimane supportato anche per i gruppi di nodi gestiti da EKS e i nodi autogestiti. Se utilizzi funzionalità di condivisione GPU come GPU multiistanza (MIG) o time-slicing, ti consigliamo di utilizzare la configurazione statica con il driver DRA o il plug-in del dispositivo NVIDIA. Il MIG dinamico e il time-slicing sono in stato alfa nel driver NVIDIA DRA. Consulta le versioni dei driver [ NVIDIA DRA per gli ultimi aggiornamenti. ](https://github.com/kubernetes-sigs/dra-driver-nvidia-gpu/releases) GitHub ## Driver NVIDIA DRA e plug-in per dispositivi NVIDIA | Funzionalità | Driver NVIDIA DRA | Plugin per dispositivi NVIDIA | | --- | --- | --- | | Versione minima di Kubernetes | 1.34 | Tutte le versioni di EKS-supported Kubernetes | | EKS Compute | Karpenter (solo capacità statica), gruppi di nodi gestiti, nodi autogestiti | EKS Auto Mode, Karpenter, gruppi di nodi gestiti, nodi autogestiti | | EKS-optimized AMI | AL 2023 (NVIDIA), Bottlerocket | AL 2023 (NVIDIA), Bottlerocket | | Pubblicità sul dispositivo | Attributi avanzati tramite `ResourceSlice` oggetti tra cui modello GPU, memoria, versione del driver e topologia | Numero intero di risorse estese `nvidia.com/gpu` | | Condivisione GPU | (Alpha) MIG dinamico, MPS, time-slicing | (GA) MIG statico, MPS, time-slicing | | ComputeDomains | Gestisce Multi-Node NVLink (MNNVL) tramite risorse per comunicazioni GPU multinodo sicure `ComputeDomain` | Non supportata | | Attribute-based selezione | Filtrare le GPU per modello, memoria o altri attributi utilizzando le espressioni CEL | Non supportata | | Topology-aware Allocazione EFA | DRA-native consapevolezza della topologia | Riconoscimento automatico della topologia (solo AMI AL2023) EKS-optimized | ## Installa il driver NVIDIA DRA Il driver NVIDIA DRA per GPU gestisce due tipi di risorse: GPU e. ComputeDomains Esegue due plugin DRA kubelet: e. `gpu-kubelet-plugin` `compute-domain-kubelet-plugin` Ciascuno può essere abilitato o disabilitato separatamente durante l'installazione. Questa guida si concentra sull'allocazione delle GPU. Per l'utilizzo ComputeDomains, vedere. [Utilizzo P6e-GB200 UltraServers con Amazon EKS](ml-eks-nvidia-ultraserver.md) ### Prerequisiti + Un cluster Amazon EKS che esegue Kubernetes versione 1.34 o successiva con capacità statica fornita da Karpenter, gruppi di nodi gestiti da EKS o gruppi di nodi autogestiti. + Nodi con tipi di istanze GPU NVIDIA (ad esempio istanze or). `P` `G` + Nodi con componenti a livello di host installati per le GPU NVIDIA. Quando si utilizzano le AMI NVIDIA EKS-optimized AL2023 o Bottlerocket, il driver NVIDIA a livello di host, il driver in modalità utente CUDA e il toolkit contenitore sono preinstallati. + 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 cluster, consulta per ulteriori informazioni. [`Installa o aggiorna kubectl`](install-kubectl.md#kubectl-install-update) ### Procedura **Importante** Quando si utilizza il driver NVIDIA DRA per la gestione dei dispositivi GPU, non installarlo insieme al plug-in del dispositivo NVIDIA sullo stesso nodo. Ciò può causare una sottoscrizione silenziosa dei dispositivi sottostanti a più pod sullo stesso nodo. **Disattiva il plug-in del dispositivo NVIDIA integrato su Bottlerocket** Le varianti NVIDIA di EKS-optimized Bottlerocket includono il plug-in del dispositivo NVIDIA e lo abilitano per impostazione predefinita. Il driver DRA non può essere eseguito insieme al plug-in del dispositivo sullo stesso nodo. Prima di utilizzare il driver DRA, disabilitate il plug-in del dispositivo integrato nei nodi GPU Bottlerocket. Impostato su `false` nei `settings.kubelet-device-plugins.nvidia.enabled` dati utente del nodo Bottlerocket. ``` [settings.kubelet-device-plugins.nvidia] enabled = false ``` L'`settings.kubelet-device-plugins.nvidia.enabled`impostazione è disponibile nella versione Bottlerocket 1.63.0 e successive. Nelle versioni precedenti, il plug-in integrato del dispositivo NVIDIA non può essere disabilitato. Per maggiori informazioni, vedi [ bottlerocket- os/bottlerocket pull request \#4856 on. ](https://github.com/bottlerocket-os/bottlerocket/pull/4856) GitHub 1. Installa il driver NVIDIA DRA direttamente dal registro Kubernetes SIG OCI. Per trovare le versioni disponibili, consulta le versioni dei driver NVIDIA DRA su. [https://github.com/kubernetes-sigs/dra-driver-nvidia-gpu/releases](https://github.com/kubernetes-sigs/dra-driver-nvidia-gpu/releases) GitHub ``` helm install dra-driver-nvidia-gpu \ oci://registry.k8s.io/dra-driver-nvidia/charts/dra-driver-nvidia-gpu \ --version {{0.4.1}} \ --create-namespace \ --namespace nvidia \ --set resources.computeDomains.enabled=false \ --set gpuResourcesEnabledOverride=true ``` Per le opzioni di configurazione avanzate, consultate i valori del grafico Helm del driver [ NVIDIA DRA ](https://dra-driver-nvidia-gpu.sigs.k8s.io/docs/reference/helm-values/) sul sito web di Kubernetes SIG. Per visualizzare i valori disponibili per una versione specifica del grafico, esegui. `helm show values oci://registry.k8s.io/dra-driver-nvidia/charts/dra-driver-nvidia-gpu --version 0.4.1` 1. (Facoltativo) Per utilizzare il time-slicing tramite il driver DRA, aggiungete il `TimeSlicingSettings` feature gate al `helm install` comando nel passaggio precedente. Si tratta di una funzionalità alfa disattivata per impostazione predefinita. Per ulteriori informazioni, consulta [Usa il time-slicing della GPU con il driver NVIDIA DRA](device-management-nvidia-time-slicing.md#eks-time-slicing-dra). ``` --set featureGates.TimeSlicingSettings=true ``` 1. (Facoltativo) Per utilizzare il MIG dinamico tramite il driver DRA, aggiungete il `DynamicMIG` feature gate al `helm install` comando nel passaggio precedente. Questa è una funzionalità alfa disattivata per impostazione predefinita. Non è possibile combinare il `DynamicMIG` feature gate con i feature gate `PassthroughSupport``NVMLDeviceHealthCheck`,, o `MPSSupport` feature. Per ulteriori informazioni, consulta [Usa MIG con il driver NVIDIA DRA](device-management-nvidia-mig.md#eks-mig-dra-driver). ``` --set featureGates.DynamicMIG=true ``` 1. Verificare che i driver pod DRA siano in funzione. ``` kubectl get pods -n nvidia ``` 1. Verificate che gli `DeviceClass` oggetti siano stati creati. ``` kubectl get deviceclass ``` ``` NAME AGE gpu.nvidia.com 60s ``` 1. Verifica che `ResourceSlice` gli oggetti siano pubblicati per i tuoi nodi GPU. ``` kubectl get resourceslice ``` Per richiedere le GPU NVIDIA utilizzando il driver DRA, creane un riferimento `gpu.nvidia.com` `DeviceClass` e `ResourceClaimTemplate` inseriscilo nelle specifiche del tuo Pod. L'esempio seguente richiede una singola GPU. Consulta [Topology-aware EFA e GPU/Neuron allocazione dei dispositivi](device-management-efa.md#efa-dra-topology-aware) la procedura per allocare le GPU NVIDIA con interfacce EFA allineate alla topologia. ``` apiVersion: resource.k8s.io/v1 kind: ResourceClaimTemplate metadata: name: single-gpu spec: spec: devices: requests: - name: gpu exactly: deviceClassName: gpu.nvidia.com count: 1 --- apiVersion: v1 kind: Pod metadata: name: gpu-workload spec: containers: - name: gpu-demo image: public.ecr.aws/amazonlinux/amazonlinux:2023-minimal command: ["/bin/sh", "-c"] args: ["nvidia-smi && tail -f /dev/null"] resources: claims: - name: gpu resourceClaims: - name: gpu resourceClaimTemplateName: single-gpu tolerations: - key: "nvidia.com/gpu" operator: "Exists" effect: "NoSchedule" ``` ## Installa il plug-in del dispositivo NVIDIA Kubernetes Il plug-in per dispositivi NVIDIA Kubernetes pubblicizza le GPU NVIDIA come risorse estese. `nvidia.com/gpu` Richiedete le GPU in container, richieste e limiti di risorse. ### Prerequisiti + Un cluster Amazon EKS. + Nodi con tipi di istanze GPU NVIDIA (ad esempio `G` istanze `P` or). + Nodi con tipi di istanze GPU NVIDIA che utilizzano l'AMI NVIDIA AL2023. EKS-optimized Le AMI EKS-optimized Bottlerocket includono il plug-in del dispositivo NVIDIA. Non è necessario installarlo separatamente. + Nodi con componenti a livello di host installati per le GPU NVIDIA. Quando si utilizzano le AMI NVIDIA EKS-optimized AL2023 o Bottlerocket, il driver NVIDIA a livello di host, il driver in modalità utente CUDA e il toolkit contenitore sono preinstallati. + 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 cluster, consulta per ulteriori informazioni. [`Installa o aggiorna kubectl`](install-kubectl.md#kubectl-install-update) ### Procedura 1. Aggiungi il repository grafico Helm del plug-in per dispositivi NVIDIA. ``` helm repo add nvdp https://nvidia.github.io/k8s-device-plugin ``` 1. Aggiorna il tuo repository Helm locale. ``` helm repo update ``` 1. Installa il plug-in del dispositivo NVIDIA Kubernetes. ``` helm install nvdp nvdp/nvidia-device-plugin \ --create-namespace \ --namespace nvidia ``` **Opzionale: abilita GPU Feature Discovery (GFD)** Il plug-in del dispositivo pubblicizza risorse `nvidia.com/gpu` estese e pianifica autonomamente i GPU Pod. Sulla NVIDIA AMI EKS-optimized AL2023, l'etichetta del `nvidia.com/gpu.present=true` nodo è già applicata all'avvio`nodeadm`, quindi GPU Feature Discovery (GFD) non è richiesto per la pianificazione di base della GPU. Abilita GFD con `--set gfd.enabled=true` se desideri che il nodo sia etichettato con attributi GPU dettagliati, come,, etichette del profilo MIG e versioni. `nvidia.com/gpu.product` `nvidia.com/gpu.memory` `nvidia.com/gpu.count` driver/CUDA Con queste etichette, puoi scegliere come target specifici tipi di GPU con affinità di nodo (ad esempio, programmando un carico di lavoro solo sulle GPU A10G `nodeSelector` o su un particolare profilo MIG). Anche le configurazioni di condivisione della GPU come time-slicing e MIG utilizzano queste etichette. Se non hai bisogno della selezione dei nodi basata sugli attributi o della condivisione della GPU, puoi omettere il flag. ``` helm install nvdp nvdp/nvidia-device-plugin \ --create-namespace \ --namespace nvidia \ --set gfd.enabled=true ``` **Abilita GDRCopy se i tuoi carichi di lavoro lo utilizzano** `k8s-device-plugin`La versione da v0.19.0 a v0.19.2 ha abilitato le funzionalità GDRCopy e MOFED per impostazione predefinita. Questa abilitazione predefinita è stata ripristinata nella `k8s-device-plugin` versione 0.19.3. Come risultato del ripristino, GDRCopy (`gdrdrv`) non può più essere abilitato per contenitore con la variabile di `NVIDIA_GDRCOPY=enabled` ambiente in una specifica Pod, tale variabile viene ora ignorata. Se i tuoi carichi di lavoro utilizzano GDRCopy (copia GPUDirect RDMA), devi abilitarlo sul plug-in del dispositivo al momento dell'installazione impostando: `gdrcopyEnabled=true` ``` helm upgrade --install nvdp nvdp/nvidia-device-plugin \ --namespace nvidia \ --create-namespace \ --set gdrcopyEnabled=true ``` (Aggiungetelo `--set gfd.enabled=true` anche se volete aggiungere anche le etichette GPU Feature Discovery, come descritto in precedenza). Se gestisci il plug-in del dispositivo NVIDIA tramite [ NVIDIA GPU Operator attivo GitHub, l'operatore imposta dinamicamente `GDRCOPY_ENABLED=true` quando il modulo del `gdrdrv` kernel viene caricato ](https://github.com/NVIDIA/gpu-operator) sul nodo. Per ulteriori informazioni, consulta il numero \#1692 di [ NVIDIA k8s-device-plugin su. ](https://github.com/NVIDIA/k8s-device-plugin/issues/1692) GitHub **Nota** Puoi anche installare e gestire il plug-in del dispositivo NVIDIA Kubernetes utilizzando NVIDIA GPU Operator [ on GitHub, che automatizza la gestione di tutti i ](https://github.com/NVIDIA/gpu-operator) componenti software NVIDIA necessari per il provisioning delle GPU. 1. Verifica che il plug-in del dispositivo NVIDIA DaemonSet sia in esecuzione. ``` kubectl get ds -n nvidia nvdp-nvidia-device-plugin ``` ``` NAME DESIRED CURRENT READY UP-TO-DATE AVAILABLE NODE SELECTOR AGE nvdp-nvidia-device-plugin 2 2 2 2 2 60s ``` 1. Verifica che i tuoi nodi dispongano di GPU allocabili. ``` 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 1 ip-192-168-24-96.us-west-2.compute.internal 1 ``` ### Richiedi le GPU NVIDIA in un pod Per richiedere le GPU NVIDIA utilizzando il plug-in del dispositivo, specifica la `nvidia.com/gpu` risorsa nel contenitore (richieste e limiti). ``` apiVersion: v1 kind: Pod metadata: name: nvidia-smi spec: restartPolicy: OnFailure containers: - name: gpu-demo image: public.ecr.aws/amazonlinux/amazonlinux:2023-minimal command: ["/bin/sh", "-c"] args: ["nvidia-smi && tail -f /dev/null"] resources: limits: nvidia.com/gpu: 1 requests: nvidia.com/gpu: 1 tolerations: - key: "nvidia.com/gpu" operator: "Equal" value: "true" effect: "NoSchedule" ``` Per eseguire questo test, applica il manifest e visualizza i log: ``` kubectl apply -f nvidia-smi.yaml kubectl logs nvidia-smi ``` Di seguito viene riportato un output di esempio. ``` +-----------------------------------------------------------------------------------------+ | NVIDIA-SMI XXX.XXX.XX Driver Version: XXX.XXX.XX CUDA Version: XX.X | |-----------------------------------------+------------------------+----------------------+ | GPU Name Persistence-M | Bus-Id Disp.A | Volatile Uncorr. ECC | | Fan Temp Perf Pwr:Usage/Cap | Memory-Usage | GPU-Util Compute M. | | | | MIG M. | |=========================================+========================+======================| | 0 NVIDIA L4 On | 00000000:31:00.0 Off | 0 | | N/A 27C P8 11W / 72W | 0MiB / 23034MiB | 0% Default | | | | N/A | +-----------------------------------------+------------------------+----------------------+ +-----------------------------------------------------------------------------------------+ | Processes: | | GPU GI CI PID Type Process name GPU Memory | | ID ID Usage | |=========================================================================================| | No running processes found | +-----------------------------------------------------------------------------------------+ ```