

 **Ayude a mejorar esta página** 

Para contribuir a esta guía del usuario, elija el enlace **Edit this page on GitHub** que se encuentra en el panel derecho de cada página.

# Administración de los dispositivos Neuron en Amazon EKS
<a name="device-management-neuron"></a>

 AWS Trainium y AWS Inferentia son chips de machine learning especialmente diseñados por AWS. Amazon EKS admite dos mecanismos para administrar los dispositivos Neuron en los clústeres de EKS: el *controlador de DRA de Neuron* y el *complemento para dispositivos de Kubernetes de Neuron*.

Se recomienda utilizar el controlador de DRA de Neuron para las nuevas implementaciones en los clústeres de EKS que ejecuten la versión 1.34 o posterior de Kubernetes. El controlador de DRA de Neuron proporciona una asignación compatible con la topología, programación de subconjuntos de dispositivos conectados, configuración lógica de NeuronCore (LNC) y asignación de varios nodos UltraServer sin necesidad de extensiones de programador personalizadas. El complemento para dispositivos Neuron sigue siendo compatible.

## El controlador de DRA de Neuron frente al complemento para dispositivos Neuron
<a name="_neuron_dra_driver_vs_neuron_device_plugin"></a>


| Característica | Controlador de DRA de Neuron | Complemento para dispositivos Neuron | 
| --- | --- | --- | 
| Versión mínima de Kubernetes | 1.34 | Todas las versiones de Kubernetes compatible con EKS | 
| Karpenter y modo automático de EKS | No admitido | Compatible | 
| Compatibilidad con AMI optimizadas para EKS | AL2023 | AL2023, Bottlerocket | 
| Anuncio de dispositivo | Atributos enriquecidos a través de objetos `ResourceSlice`, como el ID del dispositivo, el tipo de instancia, la topología, la versión del controlador y la localidad de EFA | Recuento de enteros de `aws.amazon.com/neuron` y recursos ampliados de `aws.amazon.com/neuroncore` | 
| Subconjuntos de dispositivos conectados | Asigne subconjuntos de 1, 4, 8 o 16 dispositivos de Neuron conectados mediante restricciones de topología | Requiere la [extensión del programador Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/containers/tutorials/k8s-neuron-scheduler.html) para la asignación de dispositivos contiguos | 
| Configuración de LNC | Configuración lógica de NeuronCore por carga de trabajo (LNC=1 o LNC=2) mediante parámetros `ResourceClaimTemplate` | Requiere una configuración previa en las plantillas de inicio de EC2 | 
| Selección basada en atributos | Filtre los dispositivos por tipo de instancia, versión del controlador y otros atributos mediante expresiones CEL | No admitido | 

## Instalación del controlador de DRA de Neuron
<a name="neuron-dra-driver"></a>

El controlador de DRA de Neuron anuncia los dispositivos Neuron como objetos `ResourceSlice` con el nombre de `DeviceClass` `neuron.aws.com`. El controlador funciona como un DaemOnset y detecta automáticamente los dispositivos Neuron y sus atributos topológicos.

Encontrará información detallada sobre el controlador de DRA de Neuron en la [documentación de DRA de Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/containers/neuron-dra.html#neuron-dra-driver-attributes-reference).

Actualmente, no se admite el uso del controlador de DRA de Neuron con Bottlerocket.

### Requisitos previos
<a name="_prerequisites"></a>
+ Un clúster de Amazon EKS que ejecuta la versión 1.34 de Kubernetes o una posterior.
+ Nodos con los tipos de instancia AWS Trainium o Inferentia2.
+ Si tiene Helm instalado en su entorno de línea de comandos, consulte las [instrucciones de configuración de Helm](helm.md) para obtener más información.
+  `kubectl` configurado para comunicarse con su clúster. Consulte [Instalación o actualización de `kubectl`](install-kubectl.md#kubectl-install-update) para obtener más información.

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

**importante**  
No instale el controlador de DRA de Neuron en los nodos en los que se esté ejecutando el complemento para dispositivos Neuron. Los dos mecanismos no pueden coexistir en el mismo nodo. Consulte [KEP-5004](https://github.com/kubernetes/enhancements/issues/5004) de Kubernetes ascendente para ver las actualizaciones.

1. Instale el controlador de DRA de Neuron mediante 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"
   ```

   El controlador se implementa como un DaemOnset en el espacio de nombres `neuron-dra-driver` de forma predeterminada con `DeviceClass` `neuron.aws.com`.

1. Compruebe que el DaemOnset del controlador de DRA esté funcionando.

   ```
   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. Compruebe que `DeviceClass` se haya creado.

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

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

1. Compruebe que los objetos `ResourceSlice` estén anunciados para sus nodos.

   ```
   kubectl get resourceslice
   ```

Consulte la [documentación de DRA de Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/containers/neuron-dra.html#neuron-dra-driver-attributes-reference) para obtener información sobre los atributos de los objetos `ResourceSlice` disponibles.

### Solicitud de dispositivos Neuron en un pod
<a name="_request_neuron_devices_in_a_pod"></a>

Para solicitar dispositivos Neuron mediante el controlador de DRA, cree un `ResourceClaimTemplate` que haga referencia al `neuron.aws.com` `DeviceClass` y haga referencia a él en la especificación del pod.

En el siguiente ejemplo, se solicitan todos los dispositivos Neuron de una instancia `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
```

### Asignación de subconjuntos de dispositivos conectados
<a name="_allocate_connected_device_subsets"></a>

El controlador de DRA de Neuron puede asignar subconjuntos de dispositivos Neuron conectados sin necesidad de la [extensión del programador de Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/containers/tutorials/k8s-neuron-scheduler.html). Los tamaños de subconjunto admitidos son de 1, 4, 8 o 16 dispositivos. Use la restricción `matchAttribute` con un ID de grupo de topología para asegurarse de que los dispositivos estén conectados.

En el siguiente ejemplo, se solicitan 4 dispositivos Neuron conectados:

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

Los valores de `matchAttribute` admitidos para los subconjuntos conectados son `resource.aws.com/devicegroup1_id`, `resource.aws.com/devicegroup4_id`, `resource.aws.com/devicegroup8_id` y `resource.aws.com/devicegroup16_id`.

### Configuración de NeuronCores lógicos (LNC)
<a name="_configure_logical_neuroncores_lnc"></a>

El controlador de DRA de Neuron permite configurar el NeuronCore lógico por carga de trabajo mediante parámetros `ResourceClaimTemplate`. Esto elimina la necesidad de preconfigurar el LNC en las plantillas de lanzamiento de EC2.

El siguiente ejemplo solicita todos los dispositivos Neuron con el LNC establecido en 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
```

## Instalación del complemento para dispositivos de Kubernetes de Neuron
<a name="neuron-device-plugin"></a>

El complemento para dispositivos de Kubernetes de Neuron anuncia los dispositivos Neuron como `aws.amazon.com/neuron` y los NeuronCores como recursos ampliados de `aws.amazon.com/neuroncore`. Los dispositivos Neuron se solicitan en límites y solicitudes de recursos de contenedores.

### Requisitos previos
<a name="_prerequisites_2"></a>
+ Un clúster de Amazon EKS.
+ Nodos con componentes a nivel de host instalados para las instancias de AWS Trainium o AWS Inferentia. Se incluyen si se utilizan las AMI aceleradas de EKS AL2023 o las AMI de Bottlerocket de EKS.
+ Si tiene Helm instalado en su entorno de línea de comandos, consulte las [instrucciones de configuración de Helm](helm.md) para obtener más información.
+  `kubectl` configurado para comunicarse con su clúster. Consulte [Instalación o actualización de `kubectl`](install-kubectl.md#kubectl-install-update) para obtener más información.

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

1. Instale el complemento para dispositivos de Kubernetes de Neuron mediante Helm.

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

1. Compruebe que el DaemonSet del complemento para dispositivos Neuron esté en ejecución.

   ```
   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. Compruebe que los nodos tengan dispositivos Neuron asignables.

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

### Comprobación de los dispositivos Neuron con un pod de prueba
<a name="_verify_neuron_devices_with_a_test_pod"></a>

Para comprobar que se puede acceder a los dispositivos Neuron, ejecute la herramienta `neuron-ls` en un pod de prueba.

1. Cree un archivo denominado `neuron-ls.yaml` con el siguiente contenido. Este manifiesto lanza un contenedor de [Neuron Monitor](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/tools/neuron-sys-tools/neuron-monitor-user-guide.html) que tiene la herramienta `neuron-ls` instalada.

   ```
   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. Aplique el manifiesto.

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

1. Una vez que el pod termine de ejecutarse, consulte sus registros.

   ```
   kubectl logs neuron-ls
   ```

   Un ejemplo de salida sería el siguiente.

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

**nota**  
Cuando se utiliza el complemento para dispositivos Neuron, la asignación de dispositivos contiguos en instancias con varios dispositivos Neuron (por ejemplo, `trn2.48xlarge`) requiere la [extensión del programador de Kubernetes de Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/containers/tutorials/k8s-neuron-scheduler.html). El controlador de DRA de Neuron lo gestiona automáticamente mediante restricciones topológicas.

Para obtener más información sobre el uso de dispositivos Neuron con Amazon EKS, consulte la [documentación de Neuron para ejecuciones en EKS](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/containers/kubernetes-getting-started.html).