

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

# Gestisci i dispositivi Neuron su Amazon EKS
<a name="device-management-neuron"></a>

 AWS Trainium e AWS Inferentia sono chip di apprendimento automatico progettati appositamente da. AWS Amazon EKS supporta due meccanismi per la gestione dei dispositivi Neuron nei cluster EKS: il *driver Neuron DRA* e il plug-in del dispositivo *Neuron* Kubernetes.

Si consiglia di utilizzare il driver Neuron DRA per nuove implementazioni su cluster EKS che eseguono Kubernetes versione 1.34 o successiva. Il driver Neuron DRA fornisce l'allocazione basata sulla topologia, la pianificazione di sottoinsiemi di dispositivi connessi, la configurazione logica (LNC) e l'allocazione multinodo senza richiedere estensioni di pianificazione personalizzate. NeuronCore UltraServer Il plug-in del dispositivo Neuron rimane supportato.

## Driver Neuron DRA e plug-in per dispositivi Neuron
<a name="_neuron_dra_driver_vs_neuron_device_plugin"></a>


| Funzionalità | Driver Neuron DRA | Plugin per dispositivi Neuron | 
| --- | --- | --- | 
|  Versione minima di Kubernetes  |  1.34  |  Tutte le versioni di Kubernetes supportate da EKS  | 
|  Karpenter ed EKS Auto Mode  |  Non supportata  |  Supportata  | 
|  Supporto AMI ottimizzato per EKS  |  AL2023  |  AL2023, Bottlerocket  | 
|  Pubblicità del dispositivo  |  Attributi completi tramite `ResourceSlice` oggetti tra cui l'ID del dispositivo, il tipo di istanza, la topologia, la versione del driver e la località EFA  |  Numero intero e risorse estese `aws.amazon.com/neuron` `aws.amazon.com/neuroncore`  | 
|  Sottoinsiemi di dispositivi collegati  |  Alloca sottoinsiemi di 1, 4, 8 o 16 dispositivi Neuron collegati utilizzando vincoli di topologia  |  Richiede l'estensione dello scheduler [Neuron per l'allocazione di dispositivi contigui](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/containers/tutorials/k8s-neuron-scheduler.html)  | 
|  Configurazione LNC  |   NeuronCore Configurazione logica per carico di lavoro (LNC=1 o LNC=2) tramite parametri `ResourceClaimTemplate`  |  Richiede la preconfigurazione nei modelli di lancio EC2  | 
|  Selezione basata sugli attributi  |  Filtra i dispositivi per tipo di istanza, versione del driver e altri attributi utilizzando le espressioni CEL  |  Non supportata  | 

## Installa il driver Neuron DRA
<a name="neuron-dra-driver"></a>

Il driver Neuron DRA pubblicizza i dispositivi Neuron come oggetti con lo stesso nome. `ResourceSlice` `DeviceClass` `neuron.aws.com` Il driver funziona come un DaemonSet e rileva automaticamente i dispositivi Neuron e i relativi attributi di topologia.

[Informazioni dettagliate sul driver Neuron DRA sono disponibili nella documentazione Neuron DRA.](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/containers/neuron-dra.html#neuron-dra-driver-attributes-reference)

L'utilizzo del driver Neuron DRA con Bottlerocket non è attualmente supportato.

### Prerequisiti
<a name="_prerequisites"></a>
+ Un cluster Amazon EKS che esegue Kubernetes versione 1.34 o successiva.
+ Nodi con tipi di istanze AWS Trainium o Inferentia2.
+ Helm è installato nell’ambiente a riga di comando, consulta le [istruzioni di configurazione di Helm](helm.md) per ulteriori informazioni.
+  `kubectl`configurati per comunicare con il cluster, vedi [Installazione o aggiornamento di `kubectl`](install-kubectl.md#kubectl-install-update) per ulteriori informazioni.

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

**Importante**  
Non installate il driver Neuron DRA sui nodi in cui è in esecuzione il plug-in del dispositivo Neuron. I due meccanismi non possono coesistere sullo stesso nodo. [Vedi upstream Kubernetes KEP-5004 per gli aggiornamenti.](https://github.com/kubernetes/enhancements/issues/5004)

1. Installa il driver Neuron DRA usando Helm.

   ```
   helm upgrade --install neuron-helm-chart oci://public.ecr.aws/neuron/neuron-helm-chart \
       --namespace neuron-dra-driver \
       --create-namespace \
       --set "devicePlugin.enabled=false" \
       --set "npd.enabled=false" \
       --set "draDriver.enabled=true"
   ```

   Per impostazione predefinita, il driver viene distribuito come DaemonSet nel `neuron-dra-driver` namespace con. `DeviceClass` `neuron.aws.com`

1. Verificare che il driver DRA sia in esecuzione. DaemonSet 

   ```
   kubectl get ds -n neuron-dra-driver neuron-dra-driver-kubelet-plugin
   ```

   ```
   NAME                              DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   NODE SELECTOR   AGE
   neuron-dra-driver-kubelet-plugin  1         1         1       1            1           <none>          60s
   ```

1. Verificare che sia `DeviceClass` stato creato.

   ```
   kubectl get deviceclass neuron.aws.com
   ```

   ```
   NAME            AGE
   neuron.aws.com  60s
   ```

1. Verifica che `ResourceSlice` gli oggetti siano pubblicizzati per i tuoi nodi.

   ```
   kubectl get resourceslice
   ```

Consultate la [documentazione di Neuron DRA](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/containers/neuron-dra.html#neuron-dra-driver-attributes-reference) per informazioni sugli attributi degli oggetti disponibili`ResourceSlice`.

### Richiedi i dispositivi Neuron in un Pod
<a name="_request_neuron_devices_in_a_pod"></a>

Per richiedere dispositivi Neuron utilizzando il driver DRA, creane uno `ResourceClaimTemplate` che faccia riferimento a `neuron.aws.com` `DeviceClass` e fallo riferimento nelle specifiche del tuo Pod.

L'esempio seguente richiede tutti i dispositivi Neuron su un'istanza: `trn2.48xlarge`

```
apiVersion: resource.k8s.io/v1
kind: ResourceClaimTemplate
metadata:
  name: all-neurons
spec:
  spec:
    devices:
      requests:
      - name: neurons
        exactly:
          deviceClassName: neuron.aws.com
          selectors:
          - cel:
              expression: "device.attributes['neuron.aws.com'].instanceType == 'trn2.48xlarge'"
          allocationMode: All
---
apiVersion: v1
kind: Pod
metadata:
  name: neuron-workload
spec:
  containers:
  - name: app
    ...
    resources:
      claims:
      - name: neurons
  resourceClaims:
  - name: neurons
    resourceClaimTemplateName: all-neurons
```

### Alloca sottoinsiemi di dispositivi collegati
<a name="_allocate_connected_device_subsets"></a>

[Il driver Neuron DRA può allocare sottoinsiemi di dispositivi Neuron collegati senza richiedere l'estensione dello scheduler Neuron.](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/containers/tutorials/k8s-neuron-scheduler.html) Le dimensioni dei sottoinsiemi supportate sono 1, 4, 8 o 16 dispositivi. Utilizzate il `matchAttribute` vincolo con un ID del gruppo di topologia per assicurarvi che i dispositivi siano collegati.

L'esempio seguente richiede 4 dispositivi Neuron connessi:

```
apiVersion: resource.k8s.io/v1
kind: ResourceClaimTemplate
metadata:
  name: 1x4-connected-neurons
spec:
  spec:
    devices:
      requests:
      - name: neurons
        exactly:
          deviceClassName: neuron.aws.com
          allocationMode: ExactCount
          count: 4
          selectors:
          - cel:
              expression: "device.attributes['neuron.aws.com'].instanceType == 'trn2.48xlarge'"
      constraints:
      - requests: ["neurons"]
        matchAttribute: "resource.aws.com/devicegroup4_id"
```

I `matchAttribute` valori supportati per i sottoinsiemi connessi sono`resource.aws.com/devicegroup1_id`, `resource.aws.com/devicegroup4_id``resource.aws.com/devicegroup8_id`, e. `resource.aws.com/devicegroup16_id`

### Configura logica NeuronCores (LNC)
<a name="_configure_logical_neuroncores_lnc"></a>

Il driver Neuron DRA consente la configurazione logica per carico di lavoro tramite parametri. NeuronCore `ResourceClaimTemplate` Ciò elimina la necessità di preconfigurare LNC nei modelli di avvio di EC2.

L'esempio seguente richiede tutti i dispositivi Neuron con LNC impostato su 1:

```
apiVersion: resource.k8s.io/v1
kind: ResourceClaimTemplate
metadata:
  name: all-neurons-lnc-1
spec:
  spec:
    devices:
      requests:
      - name: neurons
        exactly:
          deviceClassName: neuron.aws.com
          selectors:
          - cel:
              expression: "device.attributes['neuron.aws.com'].instanceType == 'trn2.48xlarge'"
          allocationMode: All
      config:
      - requests: ["neurons"]
        opaque:
          driver: neuron.aws.com
          parameters:
            apiVersion: neuron.aws.com/v1
            kind: NeuronConfig
            logicalNeuronCore: 1
```

## Installa il plug-in del dispositivo Neuron Kubernetes
<a name="neuron-device-plugin"></a>

Il plug-in per dispositivi Neuron Kubernetes pubblicizza i dispositivi Neuron come e come risorse estese. `aws.amazon.com/neuron` NeuronCores `aws.amazon.com/neuroncore` Richiedete i dispositivi Neuron nelle richieste e nei limiti delle risorse del contenitore.

### Prerequisiti
<a name="_prerequisites_2"></a>
+ Un cluster Amazon EKS.
+ Nodi con componenti a livello di host installati per istanze AWS Trainium o AWS Inferentia. Questi sono inclusi se si utilizza EKS accelerated o EKS Bottlerocket AL2023 . AMIs AMIs
+ 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, vedi [Installazione o aggiornamento di `kubectl`](install-kubectl.md#kubectl-install-update) per ulteriori informazioni.

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

1. Installa il plug-in del dispositivo Neuron Kubernetes utilizzando Helm.

   ```
   helm upgrade --install neuron-helm-chart oci://public.ecr.aws/neuron/neuron-helm-chart \
       --set "npd.enabled=false"
   ```

1. Verifica che il plug-in del dispositivo Neuron sia in esecuzione. DaemonSet 

   ```
   kubectl get ds -n kube-system neuron-device-plugin
   ```

   ```
   NAME                   DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   NODE SELECTOR   AGE
   neuron-device-plugin   1         1         1       1            1           <none>          60s
   ```

1. Verifica che i tuoi nodi abbiano dispositivi Neuron allocabili.

   ```
   kubectl get nodes "-o=custom-columns=NAME:.metadata.name,NeuronDevice:.status.allocatable.aws\.amazon\.com/neuron,NeuronCore:.status.allocatable.aws\.amazon\.com/neuroncore"
   ```

   ```
   NAME                                           NeuronDevice   NeuronCore
   ip-192-168-47-173.us-west-2.compute.internal   1              2
   ```

### Verifica i dispositivi Neuron con un test Pod
<a name="_verify_neuron_devices_with_a_test_pod"></a>

Puoi verificare che i dispositivi Neuron siano accessibili eseguendo lo `neuron-ls` strumento in un test Pod.

1. Crea un file denominato `neuron-ls.yaml` con i seguenti contenuti. Questo manifest avvia un contenitore [Neuron Monitor su](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/tools/neuron-sys-tools/neuron-monitor-user-guide.html) cui è installato lo `neuron-ls` strumento.

   ```
   apiVersion: v1
   kind: Pod
   metadata:
     name: neuron-ls
   spec:
     restartPolicy: Never
     containers:
     - name: neuron-container
       image: public.ecr.aws/g4h4h0b5/neuron-monitor:1.0.0
       command: ["/bin/sh"]
       args: ["-c", "neuron-ls"]
       resources:
         limits:
           aws.amazon.com/neuron: 1
     tolerations:
     - key: "aws.amazon.com/neuron"
       operator: "Exists"
       effect: "NoSchedule"
   ```

1. Applicare il file manifesto.

   ```
   kubectl apply -f neuron-ls.yaml
   ```

1. Dopo che il Pod ha finito di funzionare, visualizza i suoi registri.

   ```
   kubectl logs neuron-ls
   ```

   Di seguito viene riportato un output di esempio.

   ```
   instance-type: inf2.xlarge
   instance-id: ...
   +--------+--------+--------+---------+
   | NEURON | NEURON | NEURON |   PCI   |
   | DEVICE | CORES  | MEMORY |   BDF   |
   +--------+--------+--------+---------+
   | 0      | 2      | 32 GB  | 00:1f.0 |
   +--------+--------+--------+---------+
   ```

**Nota**  
[Quando si utilizza il plug-in del dispositivo Neuron, l'allocazione di dispositivi contigui su istanze con più dispositivi Neuron (ad esempio`trn2.48xlarge`) richiede l'estensione di pianificazione Neuron Kubernetes.](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/containers/tutorials/k8s-neuron-scheduler.html) Il driver Neuron DRA lo gestisce automaticamente tramite vincoli di topologia.

Per ulteriori informazioni sull'uso dei dispositivi Neuron con Amazon EKS, consulta la [documentazione di Neuron per l'esecuzione su](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/containers/kubernetes-getting-started.html) EKS.