

 **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** 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à.

# Esegui container accelerati da GPU (Windows su EC2 G-Series)
<a name="ml-eks-windows-optimized-ami"></a>

**Importante**  
Il [plug-in per dispositivi Kubernetes per DirectX](https://github.com/TensorWorks/DirectX-Device-Plugins) di TensorWorks è uno strumento di terze parti che non è approvato, supportato o gestito da AWS. AWS non si assume alcuna responsabilità per la sicurezza, l’affidabilità o le prestazioni di questo plug-in.

Scopri come eseguire carichi di lavoro di container Windows accelerati da GPU su Amazon EKS (Elastic Kubernetes Service) utilizzando GPU NVIDIA con il plug-in per dispositivi Kubernetes per DirectX di TensorWorks. Per ulteriori informazioni, consulta [Kubernetes Device Plugin for DirectX](https://github.com/TensorWorks/DirectX-Device-Plugins).

Esistono due approcci principali per configurare l’accelerazione GPU per i container Windows:
+  **Opzione 1**: [crea un’AMI EKS ottimizzata per Windows personalizzata](eks-custom-ami-windows.md) con i driver GPU richiesti preinstallati.
  + Utilizza questo approccio quando hai bisogno di un ambiente coerente, pre-configurato e pronto per eseguire container Windows accelerati da GPU e quando sei in grado di investire le energie aggiuntive necessarie per creare e mantenere l’AMI personalizzata.
+  **Opzione 2**: installa i driver GPU necessari sui nodi worker EKS dopo aver avviato l’istanza.
  + Utilizza questo approccio quando desideri un processo di configurazione più semplice e puoi installare i driver GPU su ogni nuovo nodo worker. Più adatto a un ambiente di sviluppo per la valutazione o la prototipazione di carichi di lavoro accelerati da GPU.

Entrambi gli approcci possono essere sfruttati utilizzando i passaggi descritti in questa guida.

## Considerazioni
<a name="_considerations"></a>

Questa guida fornisce i passaggi per installare e configurare l’accelerazione GPU per i container Windows utilizzando GPU NVIDIA, driver NVIDIA GRID e il [Kubernetes Device Plugin for DirectX](https://github.com/TensorWorks/DirectX-Device-Plugins) di TensorWorks. I passaggi sono stati testati e verificati per fornire l’accelerazione GPU per i carichi di lavoro dei container Windows su Amazon EKS. Per ulteriori informazioni sui driver e plug-in dei dispositivi compatibili, consulta [Limiti noti](#ml-eks-windows-ami-known-limitations). Prima di procedere, tieni presente i seguenti punti:
+ Solo i tipi di istanze della famiglia G con [NVIDIA GRID drivers](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/install-nvidia-driver#nvidia-GRID-driver) sono stati testati e verificati per funzionare con questa guida. Esistono sicuramente altri tipi di istanze e combinazioni di driver in grado di eseguire container Windows con accelerazione GPU, ma potrebbero richiedere passaggi di configurazione aggiuntivi non descritti in questa guida.
+ Solo i carichi di lavoro basati su DirectX sono stati testati e verificati per il funzionamento con questa guida. Esistono anche altre API GPU come OpenGL, Vulkan e OpenCL che sono potenzialmente compatibili per l’esecuzione di container Windows con accelerazione GPU, ma potrebbero richiedere passaggi di configurazione aggiuntivi non trattati in questa guida.
+ Esistono alcune limitazioni note di cui tenere conto prima di eseguire container Windows con accelerazione GPU. Consulta la sezione [Limiti noti](#ml-eks-windows-ami-known-limitations) per ulteriori informazioni.

## Prerequisiti
<a name="ml-eks-windows-ami-prerequisites"></a>

Per abilitare l’accelerazione GPU per i container Windows su Amazon EKS, devi preparare i seguenti requisiti prima di procedere:
+ Avvia un cluster Amazon EKS con Kubernetes v1.27 o successive.
+ Esegui il provisioning dei nodi Windows con Windows Server 2022 o versioni successive.
+ Esegui il provisioning dei nodi Windows nei tipi di istanze della famiglia G, come [G4](https://aws.amazon.com/ec2/instance-types/g4/) o [G5](https://aws.amazon.com/ec2/instance-types/g5/).
+ Esegui il provisioning dei nodi Windows con un runtime dei container con containerd `1.7.x` o `2.x.x`. (Vedi [Recupero delle informazioni sulla versione delle AMI Windows](eks-ami-versions-windows.md) per verificare la versione del containerd nella tua AMI ottimizzata di Amazon EKS).

## Installa il driver GPU su ogni nodo Windows
<a name="ml-eks-windows-ami-install-gpu-driver"></a>

Per installare i driver NVIDIA GRID sui nodi worker EKS, segui i passaggi descritti in [NVIDIA drivers for your Amazon EC2 instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/install-nvidia-driver.html). Vai a [Installation options - Option 3: GRID drivers](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/install-nvidia-driver#nvidia-GRID-driver) e segui i passaggi per l’installazione.

 **Installa per Windows Server Core** 

Per Windows Server Core, che non offre un’esperienza desktop, installa i driver NVIDIA GRID in modo invisibile utilizzando i seguenti comandi:

```
$nvidiaInstallerFilePath = nvidia-driver-installer.exe # Replace with path to installer
$installerArguments = "-s -clean -noreboot -noeula"
Start-Process -FilePath $nvidiaInstallerFilePath -ArgumentList $installerArguments -Wait -NoNewWindow -PassThru
```

 **Verifica dell’installazione** 

Esegui il seguente comando PowerShell per mostrare le informazioni di diagnostica sulle GPU sull’istanza:

```
nvidia-smi
```

Questo comando mostra la versione del driver NVIDIA e le informazioni sull’hardware della GPU. Assicurati che l’output di questo comando corrisponda alla versione del driver NVIDIA GRID che prevedi di installare.

## Implementa il plug-in del dispositivo GPU su ogni nodo
<a name="ml-eks-windows-ami-deploy-gpu-driver"></a>

Per consentire il rilevamento e l’esposizione delle risorse della GPU ai container sui nodi Windows, è necessario un plug-in per il dispositivo. Distribuisci il [DirectX Device Plugin](https://github.com/TensorWorks/DirectX-Device-Plugins) di Tensorworks su ogni nodo worker eseguendolo come DaemonSet nel tuo cluster EKS. Segui la guida per l’installazione specificata in [README.md](https://github.com/TensorWorks/DirectX-Device-Plugins/blob/main/README.md), che comporterà i seguenti passaggi. Si consiglia di:
+ Implementare il plug-in del dispositivo nel namespace `kube-system`.
+ Impostare limiti di risorse appropriati per DaemonSet per assicurarsi che non consumi risorse eccessive sui nodi.

**Nota**  
Il plug-in del dispositivo DaemonSet verrà eseguito su ogni nodo come container di processi host con privilegi elevati. Si consiglia di implementare i controlli RBAC per limitare l’accesso a questo DaemonSet in modo che solo gli utenti autorizzati possano eseguire comandi privilegiati.

Durante l’esecuzione di container accelerati da GPU, il plug-in del dispositivo supporta due modalità:
+  **Modalità a tenancy singola**: questa modalità dedica tutte le risorse GPU a un singolo container sull’istanza. Installa i plug-in del dispositivo con supporto della tenancy singola utilizzando il comando seguente: Per ulteriori informazioni, consulta il file README.md.

  ```
  kubectl apply -f "https://raw.githubusercontent.com/TensorWorks/directx-device-plugins/main/deployments/default-daemonsets.yml"
  ```
+  **Modalità multi-tenancy**: questa modalità consente di condividere le risorse GPU tra più container sull’istanza. Installa i plug-in del dispositivo con supporto della multi-tenancy utilizzando il comando seguente: Per ulteriori informazioni, consulta il file README.md.

  ```
  kubectl apply -f "https://raw.githubusercontent.com/TensorWorks/directx-device-plugins/main/deployments/multitenancy-inline.yml"
  ```

  In alternativa, usa una ConfigMap per specificare la multi-tenancy.

  ```
  kubectl apply -f "https://raw.githubusercontent.com/TensorWorks/directx-device-plugins/main/deployments/multitenancy-configmap.yml"
  ```

### Verifica dell’implementazione del plug-in del dispositivo
<a name="ml-eks-windows-ami-verify-device-plugin"></a>

Dopo aver distribuito il plug-in del dispositivo, sostituisci `<namespace>` ed esegui il comando seguente per verificare che il plug-in DirectX funzioni correttamente su tutti i nodi Windows.

```
kubectl get ds device-plugin-wddm -n <namespace>
```

### Verifica che i container siano pronti per l’implementazione
<a name="ml-eks-windows-ami-verify-container-deployment"></a>

Quando il plug-in del dispositivo DaemonSet è in esecuzione sui nodi worker Windows alimentati da GPU, utilizza il comando seguente per verificare che ogni nodo disponga di GPU allocabili. Il numero corrispondente deve corrispondere al numero di dispositivi DirectX su ciascun nodo.

```
kubectl get nodes "-o=custom-columns=NAME:.metadata.name,DirectX:.status.allocatable.directx\.microsoft\.com/display"
```

## Esecuzione di container Windows con accelerazione GPU
<a name="ml-eks-windows-ami-run-with-gpu-acceleration"></a>

Prima di avviare i pod, specifica il nome della risorsa `directx.microsoft.com/display` in `.spec.containers[].resources`. Questo indicherà che i container richiedono funzionalità basate su GPU e `kube-scheduler` cercherà di posizionare i pod sul nodo Windows preconfigurato con le risorse GPU disponibili.

Vedi il comando di esempio riportato di seguito che avvia `Job` per eseguire una simulazione Monte Carlo e stimare il valore di pi. Questo esempio proviene dal repository GitHub [Kubernetes Device Plugins for DirectX](https://github.com/TensorWorks/DirectX-Device-Plugins), che offre [diversi esempi](https://github.com/TensorWorks/DirectX-Device-Plugins/tree/main/examples) da eseguire per testare le funzionalità della GPU dei nodi Windows.

```
cat <<EOF | kubectl apply -f -
apiVersion: batch/v1
kind: Job
metadata:
  name: example-cuda-montecarlo-wddm
spec:
  template:
    spec:
      containers:
      - name: example-cuda-montecarlo-wddm
        image: "index.docker.io/tensorworks/example-cuda-montecarlo:0.0.1"
        resources:
          limits:
            directx.microsoft.com/display: 1
      nodeSelector:
        "kubernetes.io/os": windows
      restartPolicy: Never
  backoffLimit: 0
EOF
```

## Limiti noti
<a name="ml-eks-windows-ami-known-limitations"></a>

### Tutte le GPU sono utilizzabili
<a name="ml-eks-windows-ami-gpus-usable"></a>

Tutte le GPU dell’istanza saranno utilizzabili da ogni container in esecuzione sull’host, anche quando si richiede un numero specifico di GPU per un determinato container. Inoltre, il comportamento predefinito prevede che tutti i container in esecuzione sull’host utilizzino la GPU con indice 0, anche se sul nodo sono disponibili più GPU. Pertanto, affinché le attività con più GPU funzionino correttamente, è necessario designare esplicitamente il dispositivo GPU specifico da utilizzare all’interno del codice dell’applicazione.

L’implementazione esatta per allocare un dispositivo da utilizzare per l’applicazione dipenderà dal linguaggio di programmazione o dal framework in uso. Ad esempio, se utilizzi la programmazione CUDA, per selezionare una GPU specifica, puoi specificare esplicitamente il dispositivo da utilizzare nel codice dell’applicazione utilizzando la funzione [cudaSetDevice()](https://docs.nvidia.com/cuda/cuda-runtime-api/group_%5FCUDART%5F_DEVICE.html).

La necessità di specificare in modo esplicito il dispositivo è dovuta a un problema noto che interessa i container Windows. È possibile tenere traccia dei progressi nella risoluzione di questo problema nel [microsoft/Windows-Containers issue \$1333](https://github.com/microsoft/Windows-Containers/issues/333). La tabella seguente è una rappresentazione visiva e un esempio pratico di questo comportamento di allocazione delle GPU.

Consideriamo uno scenario in cui esiste un singolo nodo Windows del tipo di istanza EC2 `g4dn.12xlarge`, dotato di quattro GPU. Consideriamo uno scenario in cui vengono lanciati tre pod su questa istanza. La tabella mostra che, indipendentemente dal numero di GPU richieste da ciascun container, tutti e tre i pod hanno accesso a tutte e quattro le GPU dell’istanza e, per impostazione predefinita, utilizzeranno la GPU con indice di dispositivo 0.


| Pod | GPU richieste | Accesso effettivo alla GPU | Utilizzo predefinito della GPU | Indici disponibili della GPU | Istanze totali della GPU | 
| --- | --- | --- | --- | --- | --- | 
|  Pod 1  |  1 GPU  |  Tutte e 4 le GPU  |  GPU con indice 0  |  0, 1, 2, 3  |  4  | 
|  Pod 2  |  2 GPU  |  Tutte e 4 le GPU  |  GPU con indice 0  |  0, 1, 2, 3  |  4  | 
|  Pod 3  |  1 GPU  |  Tutte e 4 le GPU  |  GPU con indice 0  |  0, 1, 2, 3  |  4  | 

### Supporto per il plug-in dei dispositivi Kubernetes
<a name="ml-eks-windows-ami-device-plugin-support"></a>

L’implementazione ufficiale di NVIDIA del [Kubernetes device plugin](https://github.com/NVIDIA/k8s-device-plugin) non supporta Windows. Puoi tenere traccia dei progressi nell’aggiunta del supporto ufficiale per Windows in [NVIDIA/k8s-device-plugin issue \$1419](https://github.com/NVIDIA/k8s-device-plugin/issues/419).

### Limitazioni delle istanze di calcolo GPU
<a name="ml-eks-windows-ami-compute-instance-limitations"></a>

A seconda della configurazione del tuo account AWS, potresti avere dei limiti di servizio sul numero e sui tipi di istanze di calcolo GPU Amazon EC2 che puoi avviare. Se hai bisogno di capacità aggiuntiva, consulta [Request a quota increase](https://docs.aws.amazon.com/servicequotas/latest/userguide/request-quota-increase.html).

### È necessario creare un’AMI ottimizzata per GPU Windows
<a name="ml-eks-windows-ami-build-gpu-ami"></a>

Amazon EKS non fornisce alcuna AMI EKS ottimizzata per GPU Windows né un componente gestito da EC2 Image Builder. È necessario seguire i passaggi di questa guida per creare un’AMI EKS ottimizzata per Windows e personalizzata con i driver GPU richiesti preinstallati o installare i driver GPU necessari sui nodi worker EKS dopo l’avvio delle istanze.

### Inferentia e Trainium non sono supportati
<a name="ml-eks-windows-ami-inferentia-tranium-support"></a>

 I carichi di lavoro basati su AWS [Inferentia](https://aws.amazon.com/ai/machine-learning/inferentia/) e AWS [Trainium](https://aws.amazon.com/ai/machine-learning/trainium/) non sono supportati su Windows.