

 **Aidez à améliorer cette page** 

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Pour contribuer à ce guide de l'utilisateur, cliquez sur le GitHub lien **Modifier cette page sur** qui se trouve dans le volet droit de chaque page.

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Gérez les appareils Neuron sur Amazon EKS
<a name="device-management-neuron"></a>

 AWS Trainium et AWS Inferentia sont des puces d'apprentissage automatique spécialement conçues par. AWS Amazon EKS prend en charge deux mécanismes de gestion des appareils Neuron dans les clusters EKS : le *pilote Neuron DRA* et le plug-in d'appareil *Neuron Kubernetes*.

Il est recommandé d'utiliser le pilote Neuron DRA pour les nouveaux déploiements sur des clusters EKS exécutant Kubernetes version 1.34 ou ultérieure. Le pilote Neuron DRA fournit une allocation tenant compte de la topologie, une planification de sous-ensembles de périphériques connectés, une configuration logique NeuronCore (LNC) et une allocation UltraServer multi-nœuds sans nécessiter d'extensions de planificateur personnalisées. Le plug-in de l'appareil Neuron reste compatible.

## Pilote Neuron DRA ou plug-in de périphérique Neuron
<a name="_neuron_dra_driver_vs_neuron_device_plugin"></a>


| Fonctionnalité | pilote Neuron DRA | Plug-in pour appareil Neuron | 
| --- | --- | --- | 
|  Version minimale de Kubernetes  |  1,34  |  Toutes les versions de Kubernetes prises en charge par EKS  | 
|  Mode automatique Karpenter et EKS  |  Non pris en charge  |  Pris en charge  | 
|  Support d'AMI optimisé pour EKS  |  AL2023  |  AL2023, Flacon Rocket  | 
|  Publicité sur les appareils  |  Attributs riches via `ResourceSlice` des objets, notamment l'ID du périphérique, le type d'instance, la topologie, la version du pilote et la localité EFA  |  Nombre entier de ressources `aws.amazon.com/neuron` et ressources `aws.amazon.com/neuroncore` étendues  | 
|  Sous-ensembles d'appareils connectés  |  Allouez des sous-ensembles de 1, 4, 8 ou 16 dispositifs Neuron connectés à l'aide de contraintes topologiques  |  Nécessite l'[extension Neuron Scheduler](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/containers/tutorials/k8s-neuron-scheduler.html) pour l'allocation d'appareils contigus  | 
|  Configuration du LNC  |   NeuronCore Configuration logique par charge de travail (LNC=1 ou LNC=2) via des paramètres `ResourceClaimTemplate`  |  Nécessite une préconfiguration dans les modèles de lancement EC2  | 
|  Sélection basée sur les attributs  |  Filtrez les appareils par type d'instance, version de pilote et autres attributs à l'aide d'expressions CEL  |  Non pris en charge  | 

## Installez le pilote Neuron DRA
<a name="neuron-dra-driver"></a>

Le pilote Neuron DRA présente les appareils Neuron sous la forme d'`ResourceSlice`objets portant ce nom. `DeviceClass` `neuron.aws.com` Le pilote s'exécute en tant que DaemonSet et découvre automatiquement les périphériques Neuron et leurs attributs topologiques.

Des informations détaillées sur le pilote Neuron DRA sont disponibles dans la documentation [Neuron DRA](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/containers/neuron-dra.html#neuron-dra-driver-attributes-reference).

L'utilisation du pilote Neuron DRA avec Bottlerocket n'est actuellement pas prise en charge.

### Conditions préalables
<a name="_prerequisites"></a>
+ Un cluster Amazon EKS exécutant Kubernetes version 1.34 ou ultérieure.
+ Nœuds dotés de AWS types d'instance Trainium ou Inferentia2.
+ Helm installé dans votre environnement de ligne de commande, consultez les instructions de configuration de Helm pour plus d’informations.[Déployez des applications avec Helm sur Amazon EKS](helm.md)
+  `kubectl`configuré pour communiquer avec votre cluster, voir [Installer ou mettre à jour `kubectl`](install-kubectl.md#kubectl-install-update) pour plus d'informations.

### Procédure
<a name="_procedure"></a>

**Important**  
N'installez pas le pilote Neuron DRA sur les nœuds sur lesquels le plug-in du périphérique Neuron est en cours d'exécution. Les deux mécanismes ne peuvent pas coexister sur le même nœud. Consultez Kubernetes [KEP-5004](https://github.com/kubernetes/enhancements/issues/5004) en amont pour les mises à jour.

1. Installez le pilote Neuron DRA à l'aide de 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"
   ```

   Le pilote est déployé DaemonSet en tant que dans l'espace de `neuron-dra-driver` noms par défaut avec le `DeviceClass``neuron.aws.com`.

1. Vérifiez que le pilote DRA DaemonSet est en cours d'exécution.

   ```
   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. Vérifiez que le `DeviceClass` a été créé.

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

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

1. Vérifiez que `ResourceSlice` les objets sont annoncés pour vos nœuds.

   ```
   kubectl get resourceslice
   ```

Consultez la [documentation Neuron DRA](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/containers/neuron-dra.html#neuron-dra-driver-attributes-reference) pour plus d'informations sur les attributs `ResourceSlice` d'objet disponibles.

### Demandez des appareils Neuron dans un Pod
<a name="_request_neuron_devices_in_a_pod"></a>

Pour demander des appareils Neuron à l'aide du pilote DRA, créez-en un `ResourceClaimTemplate` qui y fait référence `neuron.aws.com` `DeviceClass` et le référencez dans les spécifications de votre Pod.

L'exemple suivant demande tous les appareils Neuron d'une `trn2.48xlarge` instance :

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

### Allouer des sous-ensembles d'appareils connectés
<a name="_allocate_connected_device_subsets"></a>

Le pilote Neuron DRA peut allouer des sous-ensembles de périphériques Neuron connectés sans avoir besoin de l'extension [Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/containers/tutorials/k8s-neuron-scheduler.html) Scheduler. Les tailles de sous-ensembles prises en charge sont 1, 4, 8 ou 16 appareils. Utilisez la `matchAttribute` contrainte avec un ID de groupe topologique pour vous assurer que les appareils sont connectés.

L'exemple suivant demande 4 appareils Neuron connectés :

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

Les `matchAttribute` valeurs prises en charge pour les sous-ensembles connectés sont `resource.aws.com/devicegroup1_id``resource.aws.com/devicegroup4_id`,`resource.aws.com/devicegroup8_id`, et`resource.aws.com/devicegroup16_id`.

### Configuration logique NeuronCores (LNC)
<a name="_configure_logical_neuroncores_lnc"></a>

Le pilote Neuron DRA permet une NeuronCore configuration logique par charge de travail via `ResourceClaimTemplate` des paramètres. Il n'est donc plus nécessaire de préconfigurer LNC dans les modèles de lancement EC2.

L'exemple suivant demande tous les appareils Neuron dont le LNC est défini sur 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
```

## Installez le plug-in pour appareil Neuron Kubernetes
<a name="neuron-device-plugin"></a>

Le plug-in pour appareils Neuron Kubernetes annonce les appareils Neuron au fur et à mesure des ressources étendues. `aws.amazon.com/neuron` NeuronCores `aws.amazon.com/neuroncore` Vous demandez des appareils Neuron dans les demandes de ressources et les limites des conteneurs.

### Conditions préalables
<a name="_prerequisites_2"></a>
+ Un cluster Amazon EKS.
+ Nœuds dotés de composants au niveau de l'hôte installés pour les instances AWS Trainium ou Inferentia AWS . Ils sont inclus si vous utilisez l' AL2023 accélérateur EKS AMIs ou l'EKS Bottlerocket AMIs.
+ Helm installé dans votre environnement de ligne de commande, consultez les instructions de configuration de Helm pour plus d’informations.[Déployez des applications avec Helm sur Amazon EKS](helm.md)
+  `kubectl`configuré pour communiquer avec votre cluster, voir [Installer ou mettre à jour `kubectl`](install-kubectl.md#kubectl-install-update) pour plus d'informations.

### Procédure
<a name="_procedure_2"></a>

1. Installez le plug-in de l'appareil Neuron Kubernetes à l'aide de Helm.

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

1. Vérifiez que le plug-in de l'appareil Neuron DaemonSet est en cours d'exécution.

   ```
   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. Vérifiez que vos nœuds disposent de dispositifs Neuron allouables.

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

### Vérifiez les appareils Neuron à l'aide d'un module de test
<a name="_verify_neuron_devices_with_a_test_pod"></a>

Vous pouvez vérifier que les appareils Neuron sont accessibles en exécutant l'`neuron-ls`outil dans un module de test.

1. Créez un fichier nommé `neuron-ls.yaml` avec les contenus suivants. Ce manifeste lance un conteneur [Neuron Monitor sur](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/tools/neuron-sys-tools/neuron-monitor-user-guide.html) lequel l'`neuron-ls`outil est installé.

   ```
   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. Appliquez le manifeste.

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

1. Une fois que le Pod a fini de fonctionner, consultez ses journaux.

   ```
   kubectl logs neuron-ls
   ```

   L'exemple qui suit illustre un résultat.

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

**Note**  
Lorsque vous utilisez le plug-in d'appareil Neuron, l'allocation d'appareils contigus sur des instances comportant plusieurs appareils Neuron (par exemple`trn2.48xlarge`) nécessite l'extension de planificateur [Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/containers/tutorials/k8s-neuron-scheduler.html) Kubernetes. Le pilote Neuron DRA gère cela automatiquement par le biais de contraintes topologiques.

Pour plus d'informations sur l'utilisation des appareils Neuron avec Amazon EKS, consultez la [documentation Neuron relative à l'exécution sur](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/containers/kubernetes-getting-started.html) EKS.