

 **Ajudar a melhorar esta página** 

Para contribuir com este guia de usuário, escolha o link **Editar esta página no GitHub**, disponível no painel direito de cada página.

# Gerenciar dispositivos Neuron no Amazon EKS
<a name="device-management-neuron"></a>

 O AWS Trainium e o AWS Inferentia são chips de machine learning com propósito específico desenvolvidos pela AWS. O Amazon EKS oferece suporte a dois mecanismos para gerenciar dispositivos Neuron em clusters do EKS: o *driver Neuron DRA* e o *plug-in de dispositivo Neuron para o Kubernetes*.

É recomendado usar o driver de DRA do Neuron para novas implantações em clusters do EKS que executam a versão 1.34 ou versões posteriores do Kubernetes com grupos de nós gerenciados pelo EKS ou grupos de nós autogerenciados. O driver Neuron DRA oferece alocação com reconhecimento de topologia, agendamento de subconjuntos de dispositivos conectados, configuração do Logical NeuronCore (LNC) e alocação em vários nós do UltraServer sem a necessidade de extensões personalizadas do agendador.

Não há suporte para o driver de DRA do Neuron com o Karpenter ou para o Modo Automático do EKS. Use o [plug-in de dispositivo do Neuron](#neuron-device-plugin) com o Karpenter e o Modo Automático do EKS. Além disso, o plug-in de dispositivo do Neuron permanece compatível com grupos de nós gerenciados pelo EKS e com nós autogerenciados.

## Driver DRA do Neuron x plug-in do dispositivo Neuron
<a name="_neuron_dra_driver_vs_neuron_device_plugin"></a>


| Recurso | Driver Neuron DRA | Plug-in do dispositivo Neuron | 
| --- | --- | --- | 
| Versão mínima do Kubernetes | 1.34 | Todas as versões do Kubernetes compatíveis com o EKS | 
| Computação do EKS | Grupos de nós gerenciados e nós autogerenciados | Modo Automático do EKS, Karpenter, grupos de nós gerenciados e nós autogerenciados | 
| Suporte a AMI otimizado para EKS | AL2023 (Neuron) e Bottlerocket | AL2023 (Neuron) e Bottlerocket | 
| Anúncio de dispositivo | Atributos detalhados por meio de objetos `ResourceSlice`, incluindo ID do dispositivo, tipo de instância, topologia, versão do driver e localização do EFA | Contagem de inteiros de recursos estendidos `aws.amazon.com/neuron` e `aws.amazon.com/neuroncore` | 
| Subconjuntos de dispositivos conectados | Alocar subconjuntos de 1, 4, 8 ou 16 dispositivos Neuron conectados utilizando restrições de topologia | Requer a [extensão do agendador Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/containers/tutorials/k8s-neuron-scheduler.html) para alocação contígua de dispositivos | 
| Configuração da LNC | Configuração do Logical NeuronCore por workload (LNC=1 ou LNC=2) por meio de parâmetros `ResourceClaimTemplate` | É necessário realizar pré-configuração nos modelos de lançamento do EC2 | 
| Seleção baseada em atributos | Filtrar dispositivos por tipo de instância, versão do driver e outros atributos usando expressões CEL | Não compatível | 
| Alocação de EFA com reconhecimento de topologia | Reconhecimento de topologia nativo de DRA | Reconhecimento de topologia automático (apenas AMIs AL2023 otimizadas para o EKS) | 

## Instale o driver do Neuron DRA
<a name="neuron-dra-driver"></a>

O driver Neuron DRA apresenta os dispositivos Neuron como objetos `ResourceSlice` com o nome `DeviceClass` `neuron.aws.com`. O driver é executado como um DaemonSet e detecta automaticamente os dispositivos Neuron e seus atributos de topologia.

Informações detalhadas sobre o driver Neuron DRA estão disponíveis na [documentação do Neuron DRA](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/containers/neuron-dra.html#neuron-dra-driver-attributes-reference).

### Pré-requisitos
<a name="_prerequisites"></a>
+ Um cluster do Amazon EKS que executa a versão 1.34 ou versões posteriores do Kubernetes com grupos de nós gerenciados pelo EKS ou com grupos de nós autogerenciados.
+ Nós com os tipos de instância Trainium AWS ou Inferentia2.
+ O Helm instalado em seu ambiente de linha de comando. Consulte as [Instruções de configuração do Helm](helm.md) para obter mais informações.
+  `kubectl` configurado para se comunicar com o seu cluster; consulte [Instalar ou atualizar o `kubectl`](install-kubectl.md#kubectl-install-update) para obter mais informações.

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

**Importante**  
Não instale o driver Neuron DRA em nós nos quais o plug-in do dispositivo Neuron esteja em execução. Os dois mecanismos não podem coexistir no mesmo nó. Consulte o [KEP-5004](https://github.com/kubernetes/enhancements/issues/5004) do Kubernetes para obter atualizações.

1. Instale o driver do Neuron DRA usando o 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"
   ```

   Por padrão, a implantação do driver é realizada como um DaemonSet no namespace `neuron-dra-driver` com o `DeviceClass` `neuron.aws.com`.

1. Verifique se o DaemonSet do driver DRA está em execução.

   ```
   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. Verifique se `DeviceClass` foi criado.

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

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

1. Verifique se objetos `ResourceSlice` estão sendo anunciados para seus nós.

   ```
   kubectl get resourceslice
   ```

Consulte a [documentação do Neuron DRA](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/containers/neuron-dra.html#neuron-dra-driver-attributes-reference) para obter informações sobre os atributos de objetos `ResourceSlice` disponíveis.

### Solicitar dispositivos Neuron em um Pod
<a name="_request_neuron_devices_in_a_pod"></a>

Para solicitar dispositivos Neuron usando o driver DRA, crie um `ResourceClaimTemplate` que faça referência a `neuron.aws.com` `DeviceClass` e inclua-o na especificação do seu Pod.

O exemplo a seguir solicita todos os dispositivos Neuron em uma instância `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
```

### Alocar subconjuntos de dispositivos conectados
<a name="_allocate_connected_device_subsets"></a>

O driver Neuron DRA pode alocar subconjuntos de dispositivos Neuron conectados sem a necessidade da [extensão do agendador Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/containers/tutorials/k8s-neuron-scheduler.html). Os tamanhos de subconjuntos suportados são 1, 4, 8 ou 16 dispositivos. Use a restrição `matchAttribute` com um ID de grupo de topologia para garantir que os dispositivos estejam conectados.

O exemplo a seguir solicita 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"
```

Os valores `matchAttribute` com suporte para subconjuntos conexos são `resource.aws.com/devicegroup1_id`, `resource.aws.com/devicegroup4_id`, `resource.aws.com/devicegroup8_id` e `resource.aws.com/devicegroup16_id`. O número contido no nome do atributo `devicegroup` representa a quantidade de dispositivos do Neuron presentes no grupo de topologia conectado. Por exemplo, o atributo `resource.aws.com/devicegroup1_id` identifica apenas um dispositivo do Neuron, enquanto `resource.aws.com/devicegroup4_id` identifica um grupo de 4 dispositivos interconectados. Da mesma forma, `resource.aws.com/devicegroup8_id` e `resource.aws.com/devicegroup16_id` identificam, respectivamente, grupos de 8 e 16 dispositivos conectados. Escolha o `matchAttribute` que corresponda à `count` de dispositivos solicitada, garantindo que os dispositivos alocados pertençam ao mesmo grupo de topologia conectado. Para obter mais informações sobre esses atributos, consulte a [documentação do driver de DRA do Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/containers/neuron-dra.html).

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

O driver Neuron DRA permite a configuração do Logical NeuronCore por workload por meio de parâmetros `ResourceClaimTemplate`. Isso elimina a necessidade de pré-configurar o LNC nos modelos de lançamento do EC2.

O exemplo a seguir solicita todos os dispositivos Neuron com o LNC definido como 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
```

### Alocação de dispositivos do Neuron com interfaces EFA alinhadas
<a name="_allocate_neuron_devices_with_aligned_efa_interfaces"></a>

Consulte [Alocação de dispositivos EFA com GPU e dispositivos do Neuron com reconhecimento de topologia](device-management-efa.md#efa-dra-topology-aware) 

## Instalar o plug-in de dispositivos do Neuron para Kubernetes
<a name="neuron-device-plugin"></a>

O plug-in de dispositivo Neuron para Kubernetes expõe dispositivos Neuron como `aws.amazon.com/neuron` e os NeuronCores como recursos estendidos `aws.amazon.com/neuroncore`. Você solicita dispositivos Neuron nas solicitações e limites de recursos de contêineres.

### Pré-requisitos
<a name="_prerequisites_2"></a>
+ Um cluster do Amazon EKS.
+ Nós com componentes no nível do host instalados para instâncias do AWS Trainium ou do AWS Inferentia. Esses recursos estão incluídos caso você utilize as AMIs aceleradas do EKS AL2023 ou as AMIs Bottlerocket do EKS.
+ O Helm instalado em seu ambiente de linha de comando. Consulte as [Instruções de configuração do Helm](helm.md) para obter mais informações.
+  `kubectl` configurado para se comunicar com o seu cluster; consulte [Instalar ou atualizar o `kubectl`](install-kubectl.md#kubectl-install-update) para obter mais informações.

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

1. Instale o plug-in de dispositivo Neuron Kubernetes usando o Helm.

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

1. Verifique se o DaemonSet do plug-in do dispositivo Neuron está em execução.

   ```
   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. Verifique se os seus nós possuem dispositivos Neuron alocáveis.

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

### Verifique os dispositivos Neuron com um Pod de teste
<a name="_verify_neuron_devices_with_a_test_pod"></a>

Você pode verificar se os dispositivos Neuron estão acessíveis executando a ferramenta `neuron-ls` em um Pod de teste.

1. Crie um arquivo denominado `neuron-ls.yaml` com os conteúdos a seguir. Este manifesto executa um contêiner do [Neuron Monitor](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/tools/neuron-sys-tools/neuron-monitor-user-guide.html) com a ferramenta `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
         requests:
           aws.amazon.com/neuron: 1
     tolerations:
     - key: "aws.amazon.com/neuron"
       operator: "Exists"
       effect: "NoSchedule"
   ```

1. Aplique o manifesto.

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

1. Depois que o Pod terminar de ser executado, visualize seus logs.

   ```
   kubectl logs neuron-ls
   ```

   Veja abaixo um exemplo de saída.

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

**nota**  
Ao usar o plug-in do dispositivo Neuron, a alocação contígua de dispositivos em instâncias com vários dispositivos Neuron (como `trn2.48xlarge`) é necessária a [extensão do agendador do Kubernetes para Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/containers/tutorials/k8s-neuron-scheduler.html). O driver Neuron DRA lida com isso automaticamente por meio de restrições de topologia.

Para obter mais informações sobre como usar dispositivos Neuron com o Amazon EKS, consulte a [documentação do Neuron sobre a execução no EKS](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/containers/kubernetes-getting-started.html).