

 **Bantu meningkatkan halaman ini ** 

Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

Untuk berkontribusi pada panduan pengguna ini, pilih GitHub ** tautan ** Edit halaman ini di yang terletak di panel kanan setiap halaman.

Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Kelola perangkat Neuron di Amazon EKS
<a name="device-management-neuron"></a>

 AWS Trainium dan AWS Inferentia adalah chip pembelajaran mesin yang dibuat khusus yang dirancang oleh. AWS Amazon EKS mendukung dua mekanisme untuk mengelola perangkat Neuron di cluster EKS: driver * Neuron DRA * dan plugin perangkat * Neuron Kubernetes. *

Sebaiknya gunakan driver DRA untuk penerapan baru dengan Kubernetes versi 1.34 dan yang lebih baru saat menggunakan penyediaan kapasitas [ statis ](https://karpenter.sh/docs/concepts/nodepools/#static-nodepool) di Karpenter, grup node terkelola EKS, atau node yang dikelola sendiri. DRA saat ini tidak didukung dengan Mode Otomatis EKS. Driver Neuron DRA menyediakan alokasi sadar topologi, penjadwalan subset perangkat yang terhubung, konfigurasi Logis NeuronCore (LNC), dan alokasi UltraServer multi-node tanpa memerlukan ekstensi penjadwal khusus.

## Driver Neuron DRA vs plugin perangkat Neuron
<a name="_neuron_dra_driver_vs_neuron_device_plugin"></a>


| Fitur | Driver Neuron DRA | Plugin perangkat neuron | 
| --- | --- | --- | 
| Versi Kubernetes minimum | 1.34 | Semua versi EKS-supported Kubernetes | 
| Komputasi EKS | Karpenter (hanya kapasitas statis), grup node terkelola, node yang dikelola sendiri | Mode Otomatis EKS, Karpenter, grup simpul terkelola, node yang dikelola sendiri | 
| EKS-optimized Dukungan AMI | AL2023 (Neuron), Bottlerocket | AL2023 (Neuron), Bottlerocket | 
| Iklan perangkat | Atribut kaya melalui `ResourceSlice` objek termasuk ID perangkat, tipe instance, topologi, versi driver, dan lokalitas EFA | Jumlah integer `aws.amazon.com/neuron` dan sumber daya yang `aws.amazon.com/neuroncore` diperluas | 
| Subset perangkat yang terhubung | Alokasikan himpunan bagian dari 1, 4, 8, atau 16 perangkat Neuron yang terhubung menggunakan batasan topologi | Memerlukan ekstensi penjadwal [ Neuron ](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/containers/tutorials/k8s-neuron-scheduler.html) untuk alokasi perangkat yang berdekatan | 
| Konfigurasi LNC | Per-workload NeuronCore Konfigurasi logis (LNC=1 atau LNC=2) melalui parameter `ResourceClaimTemplate` | Membutuhkan pra-konfigurasi dalam template peluncuran EC2 | 
| Attribute-based seleksi | Filter perangkat berdasarkan jenis instance, versi driver, dan atribut lainnya menggunakan ekspresi CEL | Tidak didukung | 
| Topology-aware Alokasi EFA | DRA-native kesadaran topologi | Kesadaran topologi otomatis (hanya AMI EKS-optimized AL2023) | 

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

Driver Neuron DRA mengiklankan perangkat Neuron sebagai `ResourceSlice` objek dengan `DeviceClass` nama`neuron.aws.com`. Driver berjalan sebagai DaemonSet a dan secara otomatis menemukan perangkat Neuron dan atribut topologinya.

Informasi terperinci tentang driver Neuron DRA tersedia di dokumentasi [ Neuron DRA](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/containers/neuron-dra.html#neuron-dra-driver-attributes-reference).

### Prasyarat
<a name="_prerequisites"></a>
+ Cluster Amazon EKS yang menjalankan Kubernetes versi 1.34 atau yang lebih baru dengan kapasitas statis yang disediakan oleh Karpenter, grup node yang dikelola EKS, atau grup node yang dikelola sendiri.
+ Node dengan tipe AWS instance Trainium atau Inferentia2.
+ Helm diinstal di lingkungan baris perintah Anda, lihat petunjuk Peng [ aturan Helm ](helm.md) untuk informasi selengkapnya.
+  `kubectl`dikonfigurasi untuk berkomunikasi dengan cluster Anda, lihat [Instal atau perbarui `kubectl`](install-kubectl.md#kubectl-install-update) untuk informasi selengkapnya.

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

**penting**  
Jangan menginstal driver Neuron DRA pada node tempat plugin perangkat Neuron berjalan. Kedua mekanisme tidak dapat hidup berdampingan pada node yang sama. Melakukannya dapat menyebabkan kelebihan langganan senyap dari perangkat yang mendasarinya ke beberapa pod pada node yang sama.

1. Instal driver Neuron DRA menggunakan 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"
   ```

   Driver digunakan sebagai a DaemonSet di `neuron-dra-driver` namespace secara default dengan. `DeviceClass` `neuron.aws.com`

1. Verifikasi bahwa driver DRA DaemonSet sedang berjalan.

   ```
   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. Verifikasi bahwa `DeviceClass` itu dibuat.

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

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

1. Verifikasi bahwa `ResourceSlice` objek diiklankan untuk node Anda.

   ```
   kubectl get resourceslice
   ```

Lihat dokumentasi [ Neuron DRA ](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/containers/neuron-dra.html#neuron-dra-driver-attributes-reference) untuk informasi tentang atribut `ResourceSlice` objek yang tersedia.

### Minta perangkat Neuron di Pod
<a name="_request_neuron_devices_in_a_pod"></a>

Untuk meminta perangkat Neuron menggunakan driver DRA, buat `ResourceClaimTemplate` yang mereferensikan `neuron.aws.com` `DeviceClass` dan mereferensikannya dalam spesifikasi Pod Anda.

Contoh berikut meminta semua perangkat Neuron pada sebuah `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
```

### Alokasikan subset perangkat yang terhubung
<a name="_allocate_connected_device_subsets"></a>

Driver Neuron DRA dapat mengalokasikan subset perangkat Neuron yang terhubung tanpa memerlukan ekstensi penjadwal [ Neuron. ](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/containers/tutorials/k8s-neuron-scheduler.html) Ukuran subset yang didukung adalah 1, 4, 8, atau 16 perangkat. Gunakan batasan `matchAttribute` dengan ID grup topologi untuk memastikan perangkat terhubung.

Contoh berikut meminta 4 perangkat Neuron yang terhubung:

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

Nilai yang didukung `matchAttribute` untuk himpunan bagian yang terhubung adalah`resource.aws.com/devicegroup1_id`,`resource.aws.com/devicegroup4_id`,`resource.aws.com/devicegroup8_id`, dan`resource.aws.com/devicegroup16_id`. Angka dalam nama `devicegroup` atribut sesuai dengan jumlah perangkat Neuron dalam grup topologi yang terhubung. Misalnya, `resource.aws.com/devicegroup1_id` mengidentifikasi satu perangkat Neuron, `resource.aws.com/devicegroup4_id` mengidentifikasi sekelompok 4 perangkat yang terhubung, `resource.aws.com/devicegroup8_id` dan `resource.aws.com/devicegroup16_id` mengidentifikasi kelompok 8 dan 16 perangkat yang terhubung masing-masing. Pilih `matchAttribute` yang cocok dengan perangkat `count` dalam permintaan Anda sehingga perangkat yang dialokasikan milik grup topologi terhubung yang sama. Untuk informasi lebih lanjut tentang atribut ini, lihat dokumentasi driver [ Neuron DRA](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/containers/neuron-dra.html).

### Konfigurasikan Logis NeuronCores (LNC)
<a name="_configure_logical_neuroncores_lnc"></a>

Driver Neuron DRA memungkinkan NeuronCore konfigurasi Logis per beban kerja melalui `ResourceClaimTemplate` parameter. Ini menghilangkan kebutuhan untuk pra-mengkonfigurasi LNC di Template Peluncuran EC2.

Contoh berikut meminta semua perangkat Neuron dengan LNC disetel ke 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
```

### Alokasikan perangkat Neuron dengan antarmuka EFA yang selaras
<a name="_allocate_neuron_devices_with_aligned_efa_interfaces"></a>

Lihat [Topology-aware EFA dan alokasi GPU/Neuron perangkat](device-management-efa.md#efa-dra-topology-aware) 

## Instal plugin perangkat Neuron Kubernetes
<a name="neuron-device-plugin"></a>

Plugin perangkat Neuron Kubernetes mengiklankan perangkat Neuron sebagai `aws.amazon.com/neuron` dan NeuronCores sebagai sumber daya yang diperluas. `aws.amazon.com/neuroncore` Anda meminta perangkat Neuron dalam permintaan dan batasan sumber daya kontainer.

### Prasyarat
<a name="_prerequisites_2"></a>
+ Cluster Amazon EKS.
+ Node dengan komponen tingkat host yang diinstal untuk instance AWS Trainium atau AWS Inferentia. Ini termasuk jika menggunakan AMI akselerasi EKS AL2023 atau AMI Bottlerocket EKS.
+ Helm diinstal di lingkungan baris perintah Anda, lihat petunjuk Peng [ aturan Helm ](helm.md) untuk informasi selengkapnya.
+  `kubectl`dikonfigurasi untuk berkomunikasi dengan cluster Anda, lihat [Instal atau perbarui `kubectl`](install-kubectl.md#kubectl-install-update) untuk informasi selengkapnya.

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

1. Instal plugin perangkat Neuron Kubernetes menggunakan Helm.

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

1. Verifikasi plugin perangkat Neuron DaemonSet sedang berjalan.

   ```
   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. Verifikasi bahwa node Anda memiliki perangkat Neuron yang dapat dialokasikan.

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

### Verifikasi perangkat Neuron dengan Pod uji
<a name="_verify_neuron_devices_with_a_test_pod"></a>

Anda dapat memverifikasi bahwa perangkat Neuron dapat diakses dengan menjalankan `neuron-ls` alat di Pod uji.

1. Buat file bernama `neuron-ls.yaml` dengan isi berikut ini. Manifes ini meluncurkan [ wadah ](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/tools/neuron-sys-tools/neuron-monitor-user-guide.html) Neuron Monitor yang memiliki `neuron-ls` alat yang diinstal.

   ```
   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. Terapkan manifes.

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

1. Setelah Pod selesai berjalan, lihat lognya.

   ```
   kubectl logs neuron-ls
   ```

   Contoh output adalah sebagai berikut.

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

**catatan**  
Saat menggunakan plugin perangkat Neuron, alokasi perangkat yang berdekatan pada instance dengan beberapa perangkat Neuron (seperti`trn2.48xlarge`) memerlukan ekstensi penjadwal [ Neuron Kubernetes. ](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/containers/tutorials/k8s-neuron-scheduler.html) Driver Neuron DRA menangani ini secara otomatis melalui batasan topologi.

Untuk informasi selengkapnya tentang menggunakan perangkat Neuron dengan Amazon EKS, lihat dokumentasi [ Neuron untuk menjalankan EKS](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/containers/kubernetes-getting-started.html).