

 **Bantu tingkatkan 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 **Edit halaman ini pada GitHub** tautan 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.

# Jalankan pelatihan pembelajaran mesin di Amazon EKS dengan Adaptor Kain Elastis
<a name="node-efa"></a>

Topik ini menjelaskan cara mengintegrasikan Elastic Fabric Adapter (EFA) dengan Pod yang di-deploy di cluster Amazon EKS Anda. Elastic Fabric Adapter (EFA) adalah antarmuka jaringan untuk instans Amazon EC2 yang dapat Anda aktifkan untuk menjalankan aplikasi yang membutuhkan komunikasi antar-simpul tingkat tinggi dalam hitungan skala pada AWS. Ini merupakan sistem operasi antarmuka bypass hardware yang meningkatkan performa komunikasi antar-instans, yang sangat penting untuk skala aplikasi ini. Dengan EFA, aplikasi High Performance Computing (HPC) yang menggunakan aplikasi Message Passing Interface (MPI) dan Machine Learning (ML) menggunakan NVIDIA Collective Communications Library (NCCL) dapat menskalakan hingga ribuan atau. CPUs GPUs Hasilnya, Anda mendapatkan kinerja aplikasi klaster HPC lokal dengan elastisitas dan fleksibilitas cloud sesuai permintaan. AWS Mengintegrasikan EFA dengan aplikasi yang berjalan di klaster Amazon EKS dapat mengurangi waktu untuk menyelesaikan beban kerja pelatihan yang terdistribusi pada skala besar tanpa harus menambahkan instans tambahan terhadap klaster Anda. Untuk informasi selengkapnya, lihat [Elastic Fabric Adaptor](https://aws.amazon.com/hpc/efa/).

## Jenis instans dengan EFA
<a name="efa-instances"></a>

*Plugin Perangkat AWS Kubernetes EFA mendukung semua jenis instans* Amazon EC2 yang memiliki EFA. Untuk melihat daftar semua jenis instans yang memiliki EFA, lihat [Jenis instans yang didukung](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html#efa-instance-types) di Panduan Pengguna *Amazon EC2*. Namun, untuk menjalankan aplikasi ML dengan cepat, kami merekomendasikan bahwa sebuah instance memiliki chip akselerasi perangkat keras seperti NVidia GPUs, chip [AWS Inferentia](https://aws.amazon.com/machine-learning/inferentia/), atau chip [AWS Trainium](https://aws.amazon.com/machine-learning/trainium/), selain EFA. Untuk melihat daftar jenis instans yang memiliki chip akselerasi perangkat keras dan EFA, lihat [Komputasi yang dipercepat](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html#efa-instance-types) di Panduan *Pengguna Amazon EC2*.

Saat Anda membandingkan jenis instance untuk dipilih di antara mereka, pertimbangkan jumlah kartu jaringan EFA yang tersedia untuk jenis instance tersebut serta jumlah kartu akselerator, jumlah CPU, dan jumlah memori. Anda dapat menetapkan hingga satu EFA per kartu jaringan. EFA dihitung sebagai antarmuka jaringan.. Untuk melihat berapa banyak EFA yang tersedia untuk setiap jenis instans yang memiliki EFA, lihat daftar [Kartu jaringan](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html#network-cards) di Panduan Pengguna *Amazon EC2*.

## Antarmuka khusus EFA dan EFA
<a name="efa-only-interfaces"></a>

*Elastic Fabric Adapter (EFA)* adalah antarmuka jaringan yang menggabungkan kemampuan Elastic Network Adapter (ENA) dan antarmuka OS-bypass, didukung oleh protokol AWS Scalable Reliable Datagram (SRD). Fungsionalitas EFA memungkinkan aplikasi untuk berkomunikasi langsung dengan perangkat keras untuk transportasi latensi rendah. Anda dapat memilih untuk mengakses hanya kemampuan EFA menggunakan antarmuka khusus *EFA*, membatasi komunikasi ke antarmuka dalam Availability Zone yang sama.

Untuk membuat node yang dapat memiliki antarmuka khusus EFA, Anda harus menggunakan Template Peluncuran EC2 kustom dan menyetelnya ke. `InterfaceType` `efa-only` Di Template Peluncuran kustom Anda, Anda tidak dapat mengatur kartu jaringan `0` ke antarmuka khusus EFA, karena itu adalah kartu jaringan utama dan antarmuka jaringan dari instans EC2. Anda harus memiliki versi VPC CNI `1.18.5` atau yang lebih baru untuk antarmuka khusus EFA. Jika Anda menggunakan Amazon Linux 2, versi ami harus `v20240928` atau lebih baru untuk antarmuka khusus EFA.

Prosedur berikut memandu Anda untuk membuat cluster EKS `eksctl` dengan node yang memiliki antarmuka NVidia GPUs dan EFA. Anda tidak dapat menggunakan `eksctl` untuk membuat node dan grup node yang menggunakan antarmuka khusus EFA.

## Prasyarat
<a name="efa-prereqs"></a>
+ Sebuah klaster Amazon EKS yang sudah ada. Jika Anda tidak memiliki cluster yang ada, buat satu menggunakan[Memulai dengan Amazon EKS](getting-started.md).. Klaster Anda harus men-deploy pada VPC yang memiliki setidaknya satu subnet privat dengan memiliki cukup alamat IP yang tersedia untuk men-deploy pada simpul. Subnet privat harus memiliki akses internet luar yang disediakan oleh perangkat eksternal, seperti gateway NAT.

  Jika Anda berencana untuk menggunakan `eksctl` untuk membuat grup node Anda, juga `eksctl` dapat membuat cluster untuk Anda.
+ Versi `2.12.3` atau yang lebih baru atau versi `1.27.160` atau yang lebih baru dari AWS Command Line Interface (AWS CLI) diinstal dan dikonfigurasi pada perangkat Anda atau. AWS CloudShell Untuk memeriksa versi Anda saat ini, gunakan`aws --version | cut -d / -f2 | cut -d ' ' -f1`. Package manager seperti `yum``apt-get`,, atau Homebrew untuk macOS seringkali merupakan beberapa versi di belakang versi terbaru CLI. AWS Untuk menginstal versi terbaru, lihat [Menginstal](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) dan [Konfigurasi cepat dengan aws configure](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-config) di *Panduan Pengguna Antarmuka Baris AWS Perintah*. Versi AWS CLI yang diinstal AWS CloudShell mungkin juga beberapa versi di belakang versi terbaru. Untuk memperbaruinya, lihat [Menginstal AWS CLI ke direktori home Anda](https://docs.aws.amazon.com/cloudshell/latest/userguide/vm-specs.html#install-cli-software) di * AWS CloudShell Panduan Pengguna*.
+ Alat baris `kubectl` perintah diinstal pada perangkat Anda atau AWS CloudShell. Versinya bisa sama dengan atau hingga satu versi minor lebih awal atau lebih lambat dari versi Kubernetes dari klaster Anda. Misalnya, jika versi cluster Anda`1.29`, Anda dapat menggunakan `kubectl` versi`1.28`,`1.29`, atau `1.30` dengan itu. Untuk menginstal atau memutakhirkan `kubectl`, lihat [Mengatur `kubectl` dan `eksctl`](install-kubectl.md).
+ Anda harus memiliki plugin Amazon VPC CNI untuk versi Kubernetes `1.7.10` atau yang lebih baru diinstal sebelum meluncurkan node pekerja yang mendukung beberapa Adaptor Kain Elastis, seperti or. `p4d` `p5` Untuk informasi selengkapnya tentang memperbarui plugin Amazon VPC CNI untuk versi Kubernetes, lihat. [Tetapkan IPs ke Pod dengan Amazon VPC CNI](managing-vpc-cni.md)
+ Untuk instans p6-b200, Anda harus menggunakan EFA Device Plugin versi v0.5.6 atau yang lebih baru.

**penting**  
Sebuah pertimbangan penting yang diperlukan untuk mengadopsi EFA dengan Kubernetes untuk mengkonfigurasi dan mengelola Huge Pages sebagai sumber daya dalam klaster. Untuk informasi selengkapnya, lihat [Mengelola Halaman Besar](https://kubernetes.io/docs/tasks/manage-hugepages/scheduling-hugepages/) dalam dokumentasi Kubernetes. Instans Amazon EC2 dengan driver EFA yang diinstal sebelumnya mengalokasikan 5128 2MiB Halaman Besar, yang dapat Anda minta sebagai sumber daya untuk digunakan dalam spesifikasi pekerjaan Anda.

## Buat grup simpul
<a name="efa-create-nodegroup"></a>

Prosedur berikut membantu Anda membuat grup node dengan grup node yang `p4d.24xlarge` didukung dengan antarmuka EFA dan GPUDirect RDMA, dan menjalankan contoh pengujian NVIDIA Collective Communications Library (NCCL) untuk menggunakan Kinerja NCCL multi-node. EFAs Contoh ini dapat digunakan template untuk pelatihan pembelajaran mendalam terdistribusi di Amazon EKS menggunakan EFAs.

1. Tentukan jenis instans Amazon EC2 yang mendukung EFA yang tersedia di AWS Wilayah tempat Anda ingin menerapkan node. Ganti *region-code* dengan AWS Region tempat Anda ingin menyebarkan grup node Anda.

   ```
   aws ec2 describe-instance-types --region region-code \
       --filters Name=network-info.efa-supported,Values=true \
       --query "InstanceTypes[*].[InstanceType]" --output text
   ```

   Saat Anda menerapkan node, jenis instance yang ingin Anda terapkan harus tersedia di AWS Wilayah tempat klaster Anda berada.

1. Tentukan Availability Zone tempat tipe instans yang ingin Anda gunakan tersedia. Dalam tutorial ini, jenis `p5.48xlarge` instance digunakan dan harus dikembalikan dalam output untuk AWS Wilayah yang Anda tentukan pada langkah sebelumnya. Saat Anda menerapkan node di cluster produksi, ganti *p5.48xlarge* dengan jenis instance apa pun yang dikembalikan pada langkah sebelumnya.

   ```
   aws ec2 describe-instance-type-offerings --region region-code \
       --location-type availability-zone --filters Name=instance-type,Values=p4d.24xlarge,p5.48xlarge \
       --query 'InstanceTypeOfferings[*].Location' --output text
   ```

   Contoh output adalah sebagai berikut.

   ```
   us-west-2a    us-west-2c    us-west-2b
   ```

   Perhatikan Availability Zones yang dikembalikan untuk digunakan di langkah selanjutnya. Saat Anda menyebarkan node ke cluster, VPC Anda harus memiliki subnet dengan alamat IP yang tersedia di salah satu Availability Zone yang dikembalikan dalam output.

1. Buat grup simpul menggunakan`eksctl`. Anda memerlukan versi `0.215.0` atau yang lebih baru dari alat baris `eksctl` perintah yang diinstal pada perangkat Anda atau AWS CloudShell. Untuk menginstal atau memperbarui`eksctl`, lihat [Instalasi](https://eksctl.io/installation) dalam `eksctl` dokumentasi.

   1. Salin isi konten berikut kedalam sebuah file dengan nama *efa-cluster.yaml*. Ganti Contoh nilai dengan nilai Anda sendiri. Anda dapat mengganti `p5.48xlarge` dengan instance yang berbeda, tetapi jika Anda melakukannya, pastikan bahwa nilai untuk `availabilityZones` adalah Availability Zones yang dikembalikan untuk jenis instance di langkah 1.

      ```
      apiVersion: eksctl.io/v1alpha5
      kind: ClusterConfig
      
      metadata:
        name: my-efa-cluster
        region: region-code
        version: "1.XX"
      
      iam:
        withOIDC: true
      
      availabilityZones: ["us-west-2a", "us-west-2c"]
      
      managedNodeGroups:
        - name: my-efa-ng
          instanceType: p5.48xlarge
          minSize: 1
          desiredCapacity: 2
          maxSize: 3
          availabilityZones: ["us-west-2a"]
          volumeSize: 300
          privateNetworking: true
          efaEnabled: true
      ```

   1. Membuat grup simpul yang dikelola dalam klaster yang sudah ada.

      ```
      eksctl create nodegroup -f efa-cluster.yaml
      ```

      Jika Anda tidak memiliki cluster yang ada, Anda dapat menjalankan perintah berikut untuk membuat cluster dan grup node.

      ```
      eksctl create cluster -f efa-cluster.yaml
      ```
**catatan**  
Karena tipe instance yang digunakan dalam contoh ini memiliki GPUs, `eksctl` secara otomatis menginstal plugin perangkat NVIDIA Kubernetes pada setiap instance untuk Anda saat menggunakan Amazon Linux 2. Ini tidak diperlukan untuk Bottlerocket, karena plugin perangkat NVIDIA dibangun ke dalam varian EKS NVIDIA Bottlerocket. Ketika `efaEnabled` diatur ke `true` dalam konfigurasi nodegroup, juga `eksctl` akan secara otomatis menyebarkan plugin perangkat EFA pada node.

### Menggunakan Bottlerocket dengan EFA
<a name="efa-bottlerocket"></a>

Bottlerocket AMI versi 1.28.0 dan yang lebih baru termasuk dukungan resmi untuk EFA. Untuk menggunakan Bottlerocket untuk node yang mendukung EFA, tentukan dalam konfigurasi Anda. `amiFamily: Bottlerocket` Jika Anda perlu menggunakan ID AMI kustom, Anda harus menggunakan standar `nodeGroups` alih-alih`managedNodeGroups`.

Berikut adalah contoh konfigurasi:

```
apiVersion: eksctl.io/v1alpha5
kind: ClusterConfig

metadata:
  name: my-efa-bottlerocket-cluster
  region: region-code
  version: "1.XX"

iam:
  withOIDC: true

availabilityZones: ["us-west-2a", "us-west-2c"]

managedNodeGroups:
  - name: my-efa-bottlerocket-ng
    instanceType: p5.48xlarge
    minSize: 1
    desiredCapacity: 2
    maxSize: 3
    availabilityZones: ["us-west-2a"]
    volumeSize: 300
    privateNetworking: true
    efaEnabled: true
    amiFamily: Bottlerocket
    bottlerocket:
      enableAdminContainer: true
      settings:
        kernel:
          sysctl:
            "vm.nr_hugepages": "3000"  # Configures 3000 * 2Mi = 6000Mi hugepages
```

Pengaturan `vm.nr_hugepages` sysctl di atas mengonfigurasi jumlah halaman besar 2Mi. Dalam contoh ini, 3000 berarti 3000 \$1 2Mi = 6000Mi halaman besar.

### Verifikasi instalasi plugin perangkat EFA
<a name="verify-efa-device-plugin"></a>

Ketika Anda membuat grup node dengan`efaEnabled: true`, `eksctl` secara otomatis menyebarkan plugin perangkat EFA Kubernetes untuk Anda. Anda dapat memverifikasi bahwa plugin perangkat diinstal dan berfungsi dengan benar:

1. Periksa DaemonSet statusnya:

   ```
   kubectl get daemonsets -n kube-system
   ```

   Contoh output:

   ```
   NAME                                  DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   NODE SELECTOR   AGE
   aws-efa-k8s-device-plugin-daemonset   2         2         2       2            2           <none>          6m16s
   ...
   ```

   Di sini, plugin DaemonSet perangkat EFA berjalan pada dua node. Keduanya sudah siap dan tersedia.

1. Selanjutnya, verifikasi pod yang dibuat oleh DaemonSet:

   ```
   kubectl get pods -n kube-system -l name=aws-efa-k8s-device-plugin
   ```

   Contoh output:

   ```
   NAME                                        READY   STATUS    RESTARTS   AGE
   aws-efa-k8s-device-plugin-daemonset-d68bs   1/1     Running   0          6m16s
   aws-efa-k8s-device-plugin-daemonset-w4l8t   1/1     Running   0          6m16s
   ```

   Pod plugin perangkat EFA berada dalam status Running, mengonfirmasi bahwa plugin berhasil digunakan dan dioperasikan.

1. Verifikasi pendaftaran sumber daya:

   Anda dapat mengonfirmasi bahwa `vpc.amazonaws.com/efa` sumber daya terdaftar dengan kubelet dengan menjelaskan node:

   ```
   kubectl describe nodes
   ```

   Jika sumber daya EFA terdaftar dengan benar, Anda akan melihatnya terdaftar di bawah Capacity and Allocatable resources node. Contoh:

   ```
   Capacity:
     ...
     vpc.amazonaws.com/efa:  4
   Allocatable:
     ...
     vpc.amazonaws.com/efa:  4
   ```

   Output ini mengonfirmasi bahwa node mengenali sumber daya EFA, membuatnya tersedia untuk pod yang memintanya.

## (Opsional) Uji kinerja EFA
<a name="efa-application"></a>

Kami menyarankan Anda menguji pengaturan EFA. Anda dapat menggunakan [Tes NCCL di `aws-samples/awsome-distributed-training` repositori](https://github.com/aws-samples/awsome-distributed-training/tree/main/micro-benchmarks/nccl-tests) pada. GitHub [Tes NCCL](https://github.com/NVIDIA/nccl-tests) mengevaluasi kinerja jaringan menggunakan Perpustakaan Komunikasi Kolektif Nvidia. Langkah-langkah berikut mengirimkan tes NCCL di Amazon EKS.

1. Menerapkan Operator MPI Kubeflow:

   Untuk tes NCCL Anda dapat menerapkan Operasi Kubeflow MPI. Operasi MPI mempermudah untuk menjalankan pelatihan terdistribusi tipe-Allreduce di Kubernetes. Untuk informasi lebih lanjut, lihat [Operator MPI](https://github.com/kubeflow/mpi-operator) di GitHub.

1. Jalankan Uji Kinerja NCCL multi-node untuk memverifikasi RDMA/EFA: GPUDirect

   Untuk memverifikasi kinerja NCCL dengan GPUDirect RDMA melalui EFA, jalankan uji Kinerja NCCL standar. Untuk informasi lebih lanjut, lihat repo [NCCL-Tests](https://github.com/NVIDIA/nccl-tests.git) resmi di. GitHub

   Selesaikan langkah-langkah berikut ini untuk menjalankan dua simpul uji kinerja NCCL. Dalam contoh pekerjaan pengujian NCCL, setiap pekerja meminta delapan, 5210Mi GPUs, empat`hugepages-2Mi`, dan 8000Mi memori EFAs, yang secara efektif berarti setiap pekerja mengkonsumsi semua sumber daya dari sebuah instance. `p5.48xlarge`

   1. Buat MPIJob manifes:

      Salin berikut ini ke file bernama`nccl-tests.yaml`:

      ```
      apiVersion: kubeflow.org/v2beta1
      kind: MPIJob
      metadata:
        name: nccl-tests
      spec:
        runPolicy:
          cleanPodPolicy: Running
          backoffLimit: 20
        slotsPerWorker: 8
        mpiReplicaSpecs:
          Launcher:
            replicas: 1
            template:
               spec:
                restartPolicy: OnFailure
                containers:
                - image: public.ecr.aws/hpc-cloud/nccl-tests:latest
                  imagePullPolicy: IfNotPresent
                  name: test-nccl-launcher
                  env:
                   - name: PATH
                     value: $PATH:/opt/amazon/efa/bin:/usr/bin
                  command:
                  - /opt/amazon/openmpi/bin/mpirun
                  - --allow-run-as-root
                  - --tag-output
                  - -np
                  - "16"
                  - -N
                  - "8"
                  - --bind-to
                  - none
                  - -x
                  - PATH
                  - -x
                  - LD_LIBRARY_PATH
                  - -x
                  - NCCL_DEBUG=INFO
                  - -x
                  - NCCL_BUFFSIZE=8388608
                  - -x
                  - NCCL_P2P_NET_CHUNKSIZE=524288
                  - -x
                  - NCCL_TUNER_PLUGIN=/opt/amazon/ofi-nccl/lib/x86_64-linux-gnu/libnccl-ofi-tuner.so
                  - --mca
                  - pml
                  - ^cm,ucx
                  - --mca
                  - btl
                  - tcp,self
                  - --mca
                  - btl_tcp_if_exclude
                  - lo,docker0,veth_def_agent
                  - /opt/nccl-tests/build/all_reduce_perf
                  - -b
                  - "8"
                  - -e
                  - "16G"
                  - -f
                  - "2"
                  - -g
                  - "1"
                  - -c
                  - "1"
                  - -n
                  - "100"
          Worker:
            replicas: 2
            template:
              spec:
                nodeSelector:
                  node.kubernetes.io/instance-type: "p5.48xlarge"
                containers:
                - image: public.ecr.aws/hpc-cloud/nccl-tests:latest
                  imagePullPolicy: IfNotPresent
                  name: nccl-tests-worker
                  volumeMounts:
                  - name: shmem
                    mountPath: /dev/shm
                  resources:
                    limits:
                      nvidia.com/gpu: 8
                      hugepages-2Mi: 5120Mi
                      vpc.amazonaws.com/efa: 32
                      memory: 32000Mi
                    requests:
                      nvidia.com/gpu: 8
                      hugepages-2Mi: 5120Mi
                      vpc.amazonaws.com/efa: 32
                      memory: 32000Mi
                volumes:
                - name: shmem
                  hostPath:
                    path: /dev/shm
      ```

   1. Terapkan MPIJob NCCL-Tests:

      Kirim `MPIJob` dengan menerapkan manifes. Ini akan membuat dua `p5.48xlarge` instans Amazon EC2.

      ```
      kubectl apply -f nccl-tests.yaml
      ```

      Contoh output adalah sebagai berikut.

      ```
      mpijob.kubeflow.org/nccl-tests created
      ```

   1. Verifikasi bahwa pekerjaan memulai pod:

      Lihat Pod yang sedang berjalan.

      ```
      kubectl get pods
      ```

      Contoh output adalah sebagai berikut.

      ```
      NAME                             READY   STATUS     RESTARTS   AGE
      nccl-tests-launcher-nbql9    0/1     Init:0/1   0          2m49s
      nccl-tests-worker-0          1/1     Running    0          2m49s
      nccl-tests-worker-1          1/1     Running    0          2m49s
      ```

      Operator MPI membuat Pod peluncur dan 2 Pod pekerja (satu di setiap node).

   1. Verifikasi bahwa pekerjaan berjalan dengan sukses dengan log:

      Lihat log untuk `nccl-tests-launcher` Pod. Ganti *nbql9* dengan nilai dari output Anda.

      ```
      kubectl logs -f nccl-tests-launcher-nbql9
      ```

Jika tes berhasil diselesaikan, Anda dapat menyebarkan aplikasi Anda yang menggunakan Perpustakaan Komunikasi Kolektif Nvidia.