

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

# Pertimbangan memori dan vCPU untuk Amazon AWS Batch EKS
<a name="memory-cpu-batch-eks"></a>

 AWS Batch Di Amazon EKS, Anda dapat menentukan sumber daya yang tersedia untuk wadah. Misalnya, Anda dapat menentukan `requests` atau `limits` nilai untuk vCPU dan sumber daya memori.

Berikut ini adalah kendala untuk menentukan sumber daya vCPU:
+ Setidaknya satu vCPU `requests` atau `limits` nilai harus ditentukan.
+ Satu unit vCPU setara dengan satu inti fisik atau virtual. 
+ Nilai vCPU harus dimasukkan dalam bilangan bulat atau dengan penambahan 0,25. 
+ Nilai vCPU valid terkecil adalah 0,25.
+ Jika keduanya ditentukan, `requests` nilainya harus kurang dari atau sama dengan `limits` nilainya. Dengan cara ini, Anda dapat mengonfigurasi konfigurasi vCPU lunak dan keras.
+ Nilai vCPU tidak dapat ditentukan dalam bentuk milliCPU. Misalnya, `100m` bukan nilai yang valid.
+ AWS Batch menggunakan `requests` nilai untuk keputusan penskalaan. Jika `requests` nilai tidak ditentukan, `limits` nilai disalin ke `requests` nilai.

Berikut ini adalah kendala untuk menentukan sumber daya memori:
+ Setidaknya satu memori `requests` atau `limits` nilai harus ditentukan.
+ Nilai memori harus dalam mebibytes (MiBs).
+ Jika keduanya ditentukan, `requests` nilainya harus sama dengan `limits` nilainya.
+ AWS Batch menggunakan `requests` nilai untuk keputusan penskalaan. Jika `requests` nilai tidak ditentukan, `limits` nilai disalin ke `requests` nilai.

Berikut ini adalah kendala untuk menentukan sumber daya GPU:
+ Jika keduanya ditentukan, `requests` nilainya harus sama dengan `limits` nilainya.
+ AWS Batch menggunakan `requests` nilai untuk keputusan penskalaan. Jika `requests` nilai tidak ditentukan, `limits` nilai disalin ke `requests` nilai.

## Contoh: definisi pekerjaan
<a name="memory-cpu-batch-eks-example-job-definition"></a>

Berikut ini AWS Batch pada definisi pekerjaan Amazon EKS mengonfigurasi pembagian vCPU lunak. Ini memungkinkan AWS Batch di Amazon EKS menggunakan semua kapasitas vCPU untuk jenis instans. Namun, jika ada pekerjaan lain yang berjalan, pekerjaan tersebut dialokasikan maksimal `2` vCPUs. Memori dibatasi hingga 2 GB.

```
{
   "jobDefinitionName": "MyJobOnEks_Sleep",
   "type": "container",
   "eksProperties": {
       "podProperties": {
           "containers": [
               {
                   "image": "public.ecr.aws/amazonlinux/amazonlinux:2",
                   "command": ["sleep", "60"],
                   "resources": {
                       "requests": {
                           "cpu": "2",
                           "memory": "2048Mi"
                       }
                   }
               }
           ]
       }
   }
}
```

Berikut ini AWS Batch di Amazon EKS definisi pekerjaan memiliki `request` nilai `1` dan mengalokasikan maksimum `4` v CPUs untuk pekerjaan.

```
{
   "jobDefinitionName": "MyJobOnEks_Sleep",
   "type": "container",
   "eksProperties": {
       "podProperties": {
           "containers": [
               {
                   "image": "public.ecr.aws/amazonlinux/amazonlinux:2",
                   "command": ["sleep", "60"],
                   "resources": {
                       "requests": {
                           "cpu": "1"
                       },
                       "limits": {
                           "cpu": "4",
                           "memory": "2048Mi"
                       }
                   }
               }
           ]
       }
   }
}
```

Berikut ini AWS Batch di Amazon EKS definisi pekerjaan menetapkan `limits` nilai vCPU `1` dan `limits` nilai memori 1 GB.

```
{
   "jobDefinitionName": "MyJobOnEks_Sleep",
   "type": "container",
   "eksProperties": {
       "podProperties": {
           "containers": [
               {
                   "image": "public.ecr.aws/amazonlinux/amazonlinux:2",
                   "command": ["sleep", "60"],
                   "resources": {
                       "limits": {
                           "cpu": "1",
                           "memory": "1024Mi"
                       }
                   }
               }
           ]
       }
   }
}
```

Saat AWS Batch menerjemahkan pekerjaan AWS Batch di Amazon EKS ke dalam pod Amazon EKS, AWS Batch salin `limits` nilainya ke `requests` nilainya. Ini jika `requests` nilai tidak ditentukan. Saat Anda mengirimkan contoh definisi pekerjaan sebelumnya, pod `spec` adalah sebagai berikut.

```
apiVersion: v1
kind: Pod
...
spec:
  ...
  containers:
    - command:
        - sleep
        - 60
      image: public.ecr.aws/amazonlinux/amazonlinux:2
      resources:
        limits:
          cpu: 1
          memory: 1024Mi
        requests:
          cpu: 1
          memory: 1024Mi
      ...
```

## Node CPU dan reservasi memori
<a name="memory-cpu-batch-eks-node-cpu-memory-reservations"></a>

AWS Batch bergantung pada logika default `bootstrap.sh` file untuk vCPU dan reservasi memori. Untuk informasi selengkapnya tentang `bootstrap.sh` file, lihat [bootstrap.sh](https://github.com/awslabs/amazon-eks-ami/blob/main/templates/al2/runtime/bootstrap.sh). Saat Anda mengukur vCPU dan sumber daya memori Anda, pertimbangkan contoh berikut.

**catatan**  
Jika tidak ada instance yang berjalan, vCPU dan reservasi memori pada awalnya dapat AWS Batch memengaruhi logika penskalaan dan pengambilan keputusan. Setelah instance berjalan, AWS Batch sesuaikan alokasi awal.

## Contoh: Reservasi CPU Node
<a name="memory-cpu-batch-eks-node-cpu-reservations"></a>

Nilai reservasi CPU dihitung dalam millicores menggunakan jumlah total v CPUs yang tersedia untuk instance.


| Nomor vCPU | Persentase dicadangkan | 
| --- | --- | 
| 1 | 6% | 
| 2 | 1% | 
| 3-4 | 0,5% | 
| 4 dan di atas | 0,25% | 

Menggunakan nilai-nilai sebelumnya, berikut ini benar:
+ Nilai reservasi CPU untuk `c5.large` instance dengan 2 v CPUs adalah 70 m. Ini dihitung dengan cara berikut: *(1\$160) \$1 (1\$110)* = 70 m.
+ Nilai reservasi CPU untuk `c5.24xlarge` instance dengan 96 v CPUs adalah 310 m. Ini dihitung dengan cara berikut: (1\$160) \$1 (1\$110) \$1 (2\$15) \$1 (92\$12.5) = 310 m.

Dalam contoh ini, ada 1930 (dihitung 2000-70) unit vCPU millicore yang tersedia untuk menjalankan pekerjaan pada sebuah instance. `c5.large` Misalkan pekerjaan Anda membutuhkan `2` (2\$1 1000 m) unit vCPU, pekerjaan tidak cocok pada satu instance. `c5.large` Namun, pekerjaan yang membutuhkan unit `1.75` vCPU cocok.

## Contoh: Reservasi memori node
<a name="memory-cpu-batch-eks-node-memory-reservations"></a>

Nilai reservasi memori dihitung dalam mebibytes menggunakan yang berikut ini:
+ Kapasitas instance dalam mebibytes. Misalnya, instance 8 GB adalah 7.748MiB.
+ `kubeReserved`Nilainya. `kubeReserved`Nilainya adalah jumlah memori yang akan dicadangkan untuk daemon sistem. `kubeReserved`Nilai dihitung dengan cara berikut: *((11 \$1 jumlah maksimum pod yang didukung oleh tipe instance) \$1 255)*. Untuk informasi tentang jumlah maksimum pod yang didukung oleh tipe instance, lihat [eni-max-pods.txt](https://github.com/awslabs/amazon-eks-ami/blob/main/nodeadm/internal/kubelet/eni-max-pods.txt) 
+ `HardEvictionLimit`Nilainya. Ketika memori yang tersedia jatuh di bawah `HardEvictionLimit` nilai, instance mencoba untuk mengusir pod.

Rumus untuk menghitung memori yang dapat dialokasikan adalah sebagai berikut: (*instance\$1capacity\$1in\$1MiB*) - (11 \$1 (*maximum\$1number\$1of\$1pods*)) - 255 - ()). *`HardEvictionLimit` value.*

 Sebuah `c5.large` instance mendukung hingga 29 pod. Untuk `c5.large` instance 8 GB dengan `HardEvictionLimit` nilai 100 MiB, memori yang dapat dialokasikan adalah 7074. MiB Ini dihitung dengan cara berikut: *(7748 - (11 \$1 29) -255 -100) =* 7074 MiB. Dalam contoh ini, 8.192 MiB pekerjaan tidak cocok dengan instance ini meskipun itu adalah instance 8 gibibyte (GiB).

## DaemonSets
<a name="memory-cpu-batch-eks-reservations-daemonset-scaling"></a>

Saat Anda menggunakanDaemonSets, pertimbangkan hal berikut:
+ Jika tidak ada instans AWS Batch Amazon EKS yang berjalan, awalnya DaemonSets dapat memengaruhi logika AWS Batch penskalaan dan pengambilan keputusan. AWS Batch awalnya mengalokasikan 0,5 unit vCPU dan 500 MiB untuk yang diharapkan. DaemonSets Setelah instance berjalan, AWS Batch sesuaikan alokasi awal.
+ Jika a DaemonSet mendefinisikan vCPU atau batas memori, AWS Batch di Amazon EKS pekerjaan memiliki lebih sedikit sumber daya. Kami menyarankan Anda menjaga jumlah DaemonSets yang ditugaskan untuk AWS Batch pekerjaan serendah mungkin.