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

# Kasus penggunaan definisi tugas Amazon ECS
<a name="use-cases"></a>

Pelajari lebih lanjut tentang cara menulis definisi tugas untuk berbagai AWS layanan dan fitur.

Bergantung pada beban kerja Anda, ada parameter definisi tugas tertentu yang perlu diatur. Juga untuk EC2, Anda harus memilih instance tertentu yang direkayasa untuk beban kerja.

**Topics**
+ [Definisi tugas Amazon ECS untuk beban kerja GPU](ecs-gpu.md)
+ [Definisi tugas Amazon ECS untuk beban kerja transcoding video](ecs-vt1.md)
+ [Definisi tugas Amazon ECS untuk beban kerja pembelajaran mesin AWS Neuron](ecs-inference.md)
+ [Definisi tugas Amazon ECS untuk instans pembelajaran mendalam](ecs-dl1.md)
+ [Definisi tugas Amazon ECS untuk beban kerja ARM 64-bit](ecs-arm64.md)
+ [Kirim log Amazon ECS ke CloudWatch](using_awslogs.md)
+ [Kirim log Amazon ECS ke AWS layanan atau AWS Partner](using_firelens.md)
+ [Menggunakan gambar AWS non-kontainer di Amazon ECS](private-auth.md)
+ [Mulai ulang kontainer individual dalam tugas Amazon ECS dengan kebijakan restart kontainer](container-restart-policy.md)
+ [Meneruskan data sensitif ke wadah Amazon ECS](specifying-sensitive-data.md)

# Definisi tugas Amazon ECS untuk beban kerja GPU
<a name="ecs-gpu"></a>

Amazon ECS mendukung beban kerja yang menggunakan GPU, saat Anda membuat cluster dengan instance container yang mendukung GPU. Instans container berbasis GPU Amazon EC2 yang menggunakan tipe instans p2, p3, p5, g3, g4, dan g5 menyediakan akses ke NVIDIA. GPUs Untuk informasi selengkapnya, lihat [Instans Komputasi Akselerasi Linux](https://docs.aws.amazon.com/ec2/latest/instancetypes/ac.html) di panduan *Jenis Instans Amazon EC2*.

Amazon ECS menyediakan AMI yang dioptimalkan untuk GPU yang dilengkapi dengan driver kernel NVIDIA yang telah dikonfigurasi sebelumnya dan runtime GPU Docker. Untuk informasi selengkapnya, lihat [Linux Amazon ECS yang dioptimalkan AMIs](ecs-optimized_AMI.md).

Anda dapat menunjuk sejumlah definisi GPUs tugas Anda untuk pertimbangan penempatan tugas di tingkat kontainer. Amazon ECS menjadwalkan instans kontainer yang tersedia yang mendukung GPUs dan menyematkan fisik GPUs ke kontainer yang tepat untuk kinerja optimal. 

Berikut tipe instans Amazon EC2 berbasis GPU yang didukung. [https://aws.amazon.com/ec2/instance-types/g5/](https://aws.amazon.com/ec2/instance-types/g5/)


|  Tipe instans  |  GPUs  |  Memori GPU (GiB)  |  v CPUs  |  Memori (GiB)  | 
| --- | --- | --- | --- | --- | 
|  p3.2xlarge  |  1  |  16  |  8  |  61  | 
|  p3.8xlarge  |  4  |  64  |  32  |  244  | 
|  p3.16xlarge  |  8  |  128  |  64  |  488  | 
|  p3dn.24xlarge  |  8  |  256  |  96  |  768  | 
|  p4d.24xlarge  | 8 | 320 | 96 | 1152 | 
| p5.48xlarge | 8 | 640 | 192 | 2048 | 
|  g3s.xlarge  |  1  |  8  |  4  |  30,5  | 
|  g3.4xlarge  |  1  |  8  |  16  |  122  | 
|  g3.8xlarge  |  2  |  16  |  32  |  244  | 
|  g3.16xlarge  |  4  |  32  |  64  |  488  | 
|  g4dn.xlarge  |  1  |  16  |  4  |  16  | 
|  g4dn.2xlarge  |  1  |  16  |  8  |  32  | 
|  g4dn.4xlarge  |  1  |  16  |  16  |  64  | 
|  g4dn.8xlarge  |  1  |  16  |  32  |  128  | 
|  g4dn.12xlarge  |  4  |  64  |  48  |  192  | 
|  g4dn.16xlarge  |  1  |  16  |  64  |  256  | 
|  g5.xlarge  |  1  |  24  |  4  |  16  | 
|  g5.2xlarge  |  1  |  24  |  8  |  32  | 
|  g5.4xlarge  |  1  |  24  |  16  |  64  | 
|  g5.8xlarge  |  1  |  24  |  32  |  128  | 
|  g5.16xlarge  |  1  |  24  |  64  |  256  | 
|  g5.12xlarge  |  4  |  96  |  48  |  192  | 
|  g5.24xlarge  |  4  |  96  |  96  |  384  | 
|  g5.48xlarge  |  8  |  192  |  192  |  768  | 
| g6.xlarge | 1 | 24 | 4 | 16 | 
| g6.2xlarge | 1 | 24 | 8 | 32 | 
| g6.4xlarge | 1 | 24 | 16 | 64 | 
| g6.8xlarge | 1 | 24 | 32 | 128 | 
| g6.16.xlarge | 1 | 24 | 64 | 256 | 
| g6.12xlarge | 4 | 96 | 48 | 192 | 
| g6.24xlarge | 4 | 96 | 96 | 384 | 
| g6.48xlarge | 8 | 192 | 192 | 768 | 
| g6.logam | 8 | 192 | 192 | 768 | 
| gr6.4xbesar | 1 | 24 | 16 | 128 | 
| g6e.xlarge | 1 | 48 | 4 | 32 | 
| g6e.2xlarge | 1 | 48 | 8 | 64 | 
| g6e.4xlarge | 1 | 48 | 16 | 128 | 
| g6e.8xlarge | 1 | 48 | 32 | 256 | 
| g6e16.xlarge | 1 | 48 | 64 | 512 | 
| g6e12.xlarge | 4 | 192 | 48 | 384 | 
| g6e24.xlarge | 4 | 192 | 96 | 768 | 
| g6e48.xlarge | 8 | 384 | 192 | 1536 | 
| gr6.8xbesar | 1 | 24 | 32 | 256 | 

Anda dapat mengambil ID Amazon Machine Image (AMI) untuk Amazon ECS yang dioptimalkan AMIs dengan menanyakan Parameter Store API. AWS Systems Manager Dengan menggunakan parameter ini, Anda tidak perlu mencari AMI yang dioptimalkan Amazon ECS secara manual. IDs Untuk informasi selengkapnya tentang Systems Manager Parameter Store API, lihat [GetParameter](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_GetParameter.html). Pengguna yang Anda gunakan harus memiliki izin `ssm:GetParameter` IAM untuk mengambil metadata AMI Amazon ECS yang dioptimalkan.

```
aws ssm get-parameters --names /aws/service/ecs/optimized-ami/amazon-linux-2/gpu/recommended --region us-east-1
```

# Digunakan GPUs dengan Instans Terkelola Amazon ECS
<a name="managed-instances-gpu"></a>

Instans Terkelola Amazon ECS mendukung komputasi akselerasi GPU untuk beban kerja seperti pembelajaran mesin, komputasi berkinerja tinggi, dan pemrosesan video melalui jenis instans Amazon EC2 berikut. Untuk informasi selengkapnya tentang jenis instans yang didukung oleh Instans Terkelola Amazon ECS, lihat. [Tipe instans Instans Terkelola Amazon ECS](managed-instances-instance-types.md)

Berikut ini adalah subset tipe instans berbasis GPU yang didukung pada Instans Terkelola Amazon ECS:
+ `g4dn`: Didukung olehNVIDIA T4 GPUs, cocok untuk inferensi pembelajaran mesin, visi komputer, dan aplikasi grafis intensif.
+ `g5`: Didukung olehNVIDIA A10G GPUs, menawarkan kinerja yang lebih tinggi untuk aplikasi grafis intensif dan beban kerja pembelajaran mesin.
+ `p3`: Didukung olehNVIDIA V100 GPUs, dirancang untuk komputasi kinerja tinggi dan pelatihan pembelajaran mendalam.
+ `p4d`: Didukung olehNVIDIA A100 GPUs, menawarkan kinerja tertinggi untuk pelatihan pembelajaran mesin dan komputasi kinerja tinggi.

Saat Anda menggunakan jenis instans berkemampuan GPU dengan Instans Terkelola Amazon ECS, NVIDIA driver dan CUDA toolkit sudah diinstal sebelumnya pada instans, sehingga memudahkan menjalankan beban kerja yang dipercepat GPU.

## Pemilihan instans berkemampuan GPU
<a name="managed-instances-gpu-instance-selection"></a>

Untuk memilih jenis instans berkemampuan GPU untuk beban kerja Instans Terkelola Amazon ECS, gunakan `instanceRequirements` objek dalam templat peluncuran penyedia kapasitas. Cuplikan berikut menunjukkan atribut yang dapat digunakan untuk memilih instance berkemampuan GPU.

```
{
  "instanceRequirements": {
    "acceleratorTypes": "gpu",
    "acceleratorCount": 1,
    "acceleratorManufacturers": ["nvidia"]
  }
}
```

Cuplikan berikut menunjukkan atribut yang dapat digunakan untuk menentukan jenis instance berkemampuan GPU di template peluncuran.

```
{
  "instanceRequirements": {
    "allowedInstanceTypes": ["g4dn.xlarge", "p4de.24xlarge"]
  }
}
```

## Gambar kontainer berkemampuan GPU
<a name="managed-instances-gpu-container-images"></a>

Untuk digunakan GPUs dalam wadah Anda, Anda perlu menggunakan gambar kontainer yang berisi pustaka dan alat GPU yang diperlukan. NVIDIAmenyediakan beberapa gambar kontainer bawaan yang dapat Anda gunakan sebagai dasar untuk beban kerja GPU Anda, termasuk yang berikut ini:
+ `nvidia:cuda`: Gambar dasar dengan CUDA toolkit untuk komputasi GPU.
+ `tensorflow/tensorflow:latest-gpu`: TensorFlow dengan dukungan GPU.
+ `pytorch/pytorch:latest-cuda`: PyTorch dengan dukungan GPU.

Untuk contoh definisi tugas untuk Amazon ECS di Instans Terkelola Amazon ECS yang melibatkan penggunaan, lihat. GPUs [Menentukan GPUs dalam definisi tugas Amazon ECS](ecs-gpu-specifying.md)

## Pertimbangan-pertimbangan
<a name="gpu-considerations"></a>

**catatan**  
Dukungan untuk tipe keluarga instans g2 telah usang.  
Jenis keluarga instans p2 hanya didukung pada versi yang lebih awal dari AMI yang `20230912` dioptimalkan untuk GPU Amazon ECS. Jika Anda perlu terus menggunakan instance p2, lihat. [Apa yang harus dilakukan jika Anda membutuhkan instance P2](#p2-instance)  
Pembaruan NVIDIA/CUDA driver di tempat pada kedua tipe keluarga instans ini akan menyebabkan potensi kegagalan beban kerja GPU.

Kami menyarankan Anda mempertimbangkan hal berikut sebelum Anda mulai bekerja dengan GPUs Amazon ECS.
+ Klaster Anda dapat terdiri dari campuran GPU dan instans kontainer non-GPU.
+ Anda dapat menjalankan beban kerja GPU pada instance eksternal. Saat mendaftarkan instance eksternal dengan cluster Anda, pastikan `--enable-gpu` flag disertakan pada skrip instalasi. Untuk informasi selengkapnya, lihat [Mendaftarkan instans eksternal ke kluster Amazon ECS](ecs-anywhere-registration.md).
+ Anda harus mengatur `ECS_ENABLE_GPU_SUPPORT` ke `true` dalam file konfigurasi agen Anda. Untuk informasi selengkapnya, lihat [Konfigurasi agen kontainer Amazon ECS](ecs-agent-config.md).
+ Saat menjalankan tugas atau membuat layanan, Anda dapat menggunakan atribut tipe instance saat mengonfigurasi batasan penempatan tugas untuk menentukan instance kontainer tempat tugas akan diluncurkan. Dengan melakukan hal tersebut, Anda bisa lebih efektif menggunakan sumber daya Anda. Untuk informasi selengkapnya, lihat [Cara Amazon ECS Menempatkan Tugas di Instans Kontainer](task-placement.md).

  Contoh berikut meluncurkan tugas pada instans kontainer `g4dn.xlarge` di klaster default Anda.

  ```
  aws ecs run-task --cluster default --task-definition ecs-gpu-task-def \
       --placement-constraints type=memberOf,expression="attribute:ecs.instance-type ==  g4dn.xlarge" --region us-east-2
  ```
+ Untuk setiap kontainer yang memiliki persyaratan sumber daya GPU yang ditentukan dalam definisi kontainer, Amazon ECS menetapkan runtime kontainer menjadi runtime kontainer NVIDIA.
+ Runtime kontainer NVIDIA membutuhkan beberapa variabel lingkungan untuk disetel dalam wadah agar berfungsi dengan baik. Untuk daftar variabel lingkungan ini, lihat [Konfigurasi Khusus dengan Docker](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/docker-specialized.html?highlight=environment%20variable). Amazon ECS menetapkan nilai variabel `NVIDIA_VISIBLE_DEVICES` lingkungan menjadi daftar perangkat GPU yang ditetapkan IDs Amazon ECS ke wadah. Untuk variabel lingkungan lain yang diperlukan, Amazon ECS tidak mengaturnya. Jadi, pastikan image container Anda menyetelnya atau disetel dalam definisi container.
+ Keluarga tipe instans p5 didukung pada versi `20230929` dan yang lebih baru dari AMI yang dioptimalkan untuk GPU Amazon ECS. 
+ Keluarga tipe instans g4 didukung pada versi `20230913` dan yang lebih baru dari AMI yang dioptimalkan untuk GPU Amazon ECS. Untuk informasi selengkapnya, lihat [Linux Amazon ECS yang dioptimalkan AMIs](ecs-optimized_AMI.md). Ini tidak didukung dalam alur kerja Create Cluster di konsol Amazon ECS. Untuk menggunakan jenis instans ini, Anda harus menggunakan konsol Amazon EC2 AWS CLI, atau API dan mendaftarkan instans secara manual ke cluster Anda.
+ Tipe instans p4d.24xlarge hanya bekerja dengan CUDA 11 atau yang lebih baru.
+ AMI yang dioptimalkan oleh GPU Amazon ECS IPv6 telah diaktifkan, yang menyebabkan masalah saat menggunakan. `yum` Ini dapat diatasi dengan mengkonfigurasi `yum` untuk digunakan IPv4 dengan perintah berikut.

  ```
  echo "ip_resolve=4" >> /etc/yum.conf
  ```
+  Saat Anda membuat image kontainer yang tidak menggunakan gambar NVIDIA/CUDA dasar, Anda harus menyetel variabel runtime `NVIDIA_DRIVER_CAPABILITIES` container ke salah satu nilai berikut:
  + `utility,compute`
  + `all`

  Untuk informasi tentang cara mengatur variabel, lihat [Mengontrol Runtime Kontainer NVIDIA](https://sarus.readthedocs.io/en/stable/user/custom-cuda-images.html#controlling-the-nvidia-container-runtime) di situs web NVIDIA.
+ GPUs tidak didukung pada wadah Windows.

# Luncurkan instans kontainer GPU untuk Amazon ECS
<a name="gpu-launch"></a>

Untuk menggunakan instans GPU di Amazon ECS di Amazon EC2, Anda perlu membuat template peluncuran, file data pengguna, dan meluncurkan instance.

Anda kemudian dapat menjalankan tugas yang menggunakan definisi tugas yang dikonfigurasi untuk GPU.

## Menggunakan templat peluncuran
<a name="gpu-launch-template"></a>

Anda dapat membuat template peluncuran.
+ Buat template peluncuran yang menggunakan ID AMI GPU Amazon ECS yang dioptimalkan Untuk AMI. Untuk informasi tentang cara membuat templat peluncuran, lihat [Membuat templat peluncuran baru menggunakan parameter yang Anda tentukan](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/create-launch-template.html#create-launch-template-define-parameters) di *Panduan Pengguna Amazon EC2*.

  Gunakan ID AMI dari langkah sebelumnya untuk **image Amazon Machine**. Untuk informasi tentang cara menentukan ID AMI dengan parameter Systems Manager, lihat [Menentukan parameter Systems Manager dalam template peluncuran](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/create-launch-template.html#use-an-ssm-parameter-instead-of-an-ami-id) di *Panduan Pengguna Amazon EC2*.

  Tambahkan yang berikut ini ke **data Pengguna** di template peluncuran. Ganti *cluster-name* dengan nama klaster Anda.

  ```
  #!/bin/bash
  echo ECS_CLUSTER=cluster-name >> /etc/ecs/ecs.config;
  echo ECS_ENABLE_GPU_SUPPORT=true >> /etc/ecs/ecs.config
  ```

## Gunakan AWS CLI
<a name="gpu-launch-cli"></a>

Anda dapat menggunakan AWS CLI untuk meluncurkan instance container.

1. Buat file yang dipanggil`userdata.toml`. File ini digunakan untuk data pengguna contoh. Ganti *cluster-name* dengan nama klaster Anda.

   ```
   #!/bin/bash
   echo ECS_CLUSTER=cluster-name >> /etc/ecs/ecs.config;
   echo ECS_ENABLE_GPU_SUPPORT=true >> /etc/ecs/ecs.config
   ```

1. Jalankan perintah berikut untuk mendapatkan ID AMI GPU. Anda menggunakan ini pada langkah berikut.

   ```
   aws ssm get-parameters --names /aws/service/ecs/optimized-ami/amazon-linux-2/gpu/recommended --region us-east-1
   ```

1. Jalankan perintah berikut untuk meluncurkan instance GPU. Ingatlah untuk mengganti parameter berikut:
   + Ganti *subnet* dengan ID subnet pribadi atau publik tempat instans Anda akan diluncurkan.
   + Ganti *gpu\$1ami* dengan ID AMI dari langkah sebelumnya.
   + Ganti *t3.large* dengan jenis instance yang ingin Anda gunakan.
   + Ganti *region* dengan kode Region.

   ```
   aws ec2 run-instances --key-name ecs-gpu-example \
      --subnet-id subnet \
      --image-id gpu_ami \
      --instance-type t3.large \
      --region region \
      --tag-specifications 'ResourceType=instance,Tags=[{Key=GPU,Value=example}]' \
      --user-data file://userdata.toml \
      --iam-instance-profile Name=ecsInstanceRole
   ```

1. Jalankan perintah berikut untuk memverifikasi bahwa instance container terdaftar ke cluster. Saat Anda menjalankan perintah ini, ingatlah untuk mengganti parameter berikut:
   + Ganti *cluster* dengan nama klaster Anda.
   + Ganti *region* dengan kode Wilayah Anda.

   ```
   aws ecs list-container-instances --cluster cluster-name --region region
   ```

# Menentukan GPUs dalam definisi tugas Amazon ECS
<a name="ecs-gpu-specifying"></a>

Untuk menggunakan instance GPUs on a container dan runtime GPU Docker, pastikan Anda menetapkan jumlah container yang dibutuhkan dalam definisi GPUs tugas. Saat wadah yang mendukung GPUs ditempatkan, agen kontainer Amazon ECS menyematkan jumlah fisik yang diinginkan GPUs ke wadah yang sesuai. Jumlah GPUs cadangan untuk semua kontainer dalam tugas tidak dapat melebihi jumlah yang tersedia GPUs pada instance kontainer tempat tugas diluncurkan. Untuk informasi selengkapnya, lihat [Membuat definisi tugas Amazon ECS menggunakan konsol](create-task-definition.md).

**penting**  
Jika persyaratan GPU Anda tidak ditentukan dalam ketentuan tugas, tugas akan menggunakan waktu aktif Docker default.

Berikut ini menunjukkan format JSON untuk persyaratan GPU dalam ketentuan tugas:

```
{
  "containerDefinitions": [
     {
        ...
        "resourceRequirements" : [
            {
               "type" : "GPU", 
               "value" : "2"
            }
        ],
     },
...
}
```

Contoh berikut menunjukkan sintaksis untuk kontainer Docker yang menentukan persyaratan GPU. Wadah ini menggunakan dua GPUs, menjalankan `nvidia-smi` utilitas, dan kemudian keluar.

```
{
  "containerDefinitions": [
    {
      "memory": 80,
      "essential": true,
      "name": "gpu",
      "image": "nvidia/cuda:11.0.3-base",
      "resourceRequirements": [
         {
           "type":"GPU",
           "value": "2"
         }
      ],
      "command": [
        "sh",
        "-c",
        "nvidia-smi"
      ],
      "cpu": 100
    }
  ],
  "family": "example-ecs-gpu"
}
```

Contoh definisi tugas berikut menunjukkan TensorFlow wadah yang mencetak jumlah yang tersedia GPUs. Tugas berjalan di Instans Terkelola Amazon ECS, memerlukan satu GPU, dan menggunakan instance. `g4dn.xlarge`

```
{
  "family": "tensorflow-gpu",
  "networkMode": "awsvpc",
  "executionRoleArn": "arn:aws:iam::account-id:role/ecsTaskExecutionRole",
  "containerDefinitions": [
    {
      "name": "tensorflow",
      "image": "tensorflow/tensorflow:latest-gpu",
      "essential": true,
      "command": [
        "python",
        "-c",
        "import tensorflow as tf; print('Num GPUs Available: ', len(tf.config.list_physical_devices('GPU')))"
      ],
      "resourceRequirements": [
        {
          "type": "GPU",
          "value": "1"
        }
      ],
      "logConfiguration": {
        "logDriver": "awslogs",
        "options": {
          "awslogs-group": "/ecs/tensorflow-gpu",
          "awslogs-region": "region",
          "awslogs-stream-prefix": "ecs"
        }
      }
    }
  ],
  "requiresCompatibilities": [
    "MANAGED_INSTANCES"
  ],
  "cpu": "4096",
  "memory": "8192",
}
```

## Bagikan GPUs
<a name="share-gpu"></a>

Saat Anda ingin berbagi GPUs, Anda perlu mengkonfigurasi yang berikut ini.

1. Hapus persyaratan sumber daya GPU dari definisi tugas Anda sehingga Amazon ECS tidak mencadangkan semua GPUs yang harus dibagikan.

1. Tambahkan data pengguna berikut ke instance Anda saat Anda ingin berbagi GPUs. Ini akan menjadikan nvidia sebagai runtime kontainer Docker default pada instance container sehingga semua container Amazon ECS dapat menggunakan. GPUs Untuk informasi selengkapnya, lihat [Menjalankan perintah saat Anda meluncurkan instans EC2 dengan input data pengguna](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/user-data.html) di Panduan Pengguna *Amazon EC2*.

   ```
   const userData = ec2.UserData.forLinux();
    userData.addCommands(
    'sudo rm /etc/sysconfig/docker',
    'echo DAEMON_MAXFILES=1048576 | sudo tee -a /etc/sysconfig/docker',
    'echo OPTIONS="--default-ulimit nofile=32768:65536 --default-runtime nvidia" | sudo tee -a /etc/sysconfig/docker',
    'echo DAEMON_PIDFILE_TIMEOUT=10 | sudo tee -a /etc/sysconfig/docker',
    'sudo systemctl restart docker',
   );
   ```

1. Atur variabel `NVIDIA_VISIBLE_DEVICES` lingkungan pada wadah Anda. Anda dapat melakukan ini dengan menentukan variabel lingkungan dalam definisi tugas Anda. Untuk informasi tentang nilai yang valid, lihat [Pencacahan GPU](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/docker-specialized.html#gpu-enumeration) di situs dokumentasi NVIDIA.

## Apa yang harus dilakukan jika Anda membutuhkan instance P2
<a name="p2-instance"></a>

Jika Anda perlu menggunakan instance P2, Anda dapat menggunakan salah satu opsi berikut untuk terus menggunakan instance.

Anda harus memodifikasi data pengguna instance untuk kedua opsi. Untuk informasi selengkapnya, lihat [Menjalankan perintah saat Anda meluncurkan instans EC2 dengan input data pengguna](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/user-data.html) di Panduan Pengguna *Amazon EC2*.

**Gunakan AMI yang dioptimalkan GPU terakhir yang didukung**

Anda dapat menggunakan `20230906` versi AMI yang dioptimalkan untuk GPU, dan menambahkan yang berikut ini ke data pengguna instance.

Ganti nama cluster dengan nama cluster Anda.

```
#!/bin/bash
echo "exclude=*nvidia* *cuda*" >> /etc/yum.conf
echo "ECS_CLUSTER=cluster-name" >> /etc/ecs/ecs.config
```

**Gunakan AMI terbaru yang dioptimalkan untuk GPU, dan perbarui data pengguna**

Anda dapat menambahkan berikut ini ke data pengguna instance. Ini menghapus instalasi driver Nvidia 535/Cuda12.2, dan kemudian menginstal driver Nvidia 470/Cuda11.4 dan memperbaiki versi.

```
#!/bin/bash
yum remove -y cuda-toolkit* nvidia-driver-latest-dkms*
tmpfile=$(mktemp)
cat >$tmpfile <<EOF
[amzn2-nvidia]
name=Amazon Linux 2 Nvidia repository
mirrorlist=\$awsproto://\$amazonlinux.\$awsregion.\$awsdomain/\$releasever/amzn2-nvidia/latest/\$basearch/mirror.list
priority=20
gpgcheck=1
gpgkey=https://developer.download.nvidia.com/compute/cuda/repos/rhel7/x86_64/7fa2af80.pub
enabled=1
exclude=libglvnd-*
EOF

mv $tmpfile /etc/yum.repos.d/amzn2-nvidia-tmp.repo
yum install -y system-release-nvidia cuda-toolkit-11-4 nvidia-driver-latest-dkms-470.182.03
yum install -y libnvidia-container-1.4.0 libnvidia-container-tools-1.4.0 nvidia-container-runtime-hook-1.4.0 docker-runtime-nvidia-1

echo "exclude=*nvidia* *cuda*" >> /etc/yum.conf
nvidia-smi
```

**Buat AMI yang dioptimalkan dengan GPU yang kompatibel dengan P2 Anda sendiri**

Anda dapat membuat AMI yang dioptimalkan untuk GPU Amazon ECS kustom Anda sendiri yang kompatibel dengan instans P2, lalu meluncurkan instans P2 menggunakan AMI.

1. Jalankan perintah berikut untuk mengkloning file. `amazon-ecs-ami repo`

   ```
   git clone https://github.com/aws/amazon-ecs-ami
   ```

1. Tetapkan agen Amazon ECS yang diperlukan dan sumber versi AMI Amazon Linux di `release.auto.pkrvars.hcl` atau`overrides.auto.pkrvars.hcl`.

1. Jalankan perintah berikut untuk membangun AMI EC2 yang kompatibel dengan P2 pribadi.

   Ganti region dengan Region dengan instance Region.

   ```
   REGION=region make al2keplergpu
   ```

1. Gunakan AMI dengan data pengguna instans berikut untuk menyambung ke klaster Amazon ECS.

   Ganti nama cluster dengan nama cluster Anda.

   ```
   #!/bin/bash
   echo "ECS_CLUSTER=cluster-name" >> /etc/ecs/ecs.config
   ```

# Definisi tugas Amazon ECS untuk beban kerja transcoding video
<a name="ecs-vt1"></a>

[Untuk menggunakan beban kerja transcoding video di Amazon ECS, daftarkan instans Amazon EC2. VT1](https://aws.amazon.com/ec2/instance-types/vt1/) Setelah mendaftarkan instans ini, Anda dapat menjalankan beban kerja transcoding video langsung dan pra-render sebagai tugas di Amazon ECS. VT1 Instans Amazon EC2 menggunakan kartu transcoding media Xilinx U30 untuk mempercepat beban kerja transcoding video langsung dan pra-render.

**catatan**  
[Untuk petunjuk tentang cara menjalankan beban kerja transcoding video dalam wadah selain Amazon ECS, lihat dokumentasi Xilinx.](https://xilinx.github.io/video-sdk/v1.5/container_setup.html#working-with-docker-vt1)

## Pertimbangan-pertimbangan
<a name="ecs-vt1-considerations"></a>

Sebelum Anda mulai menerapkan VT1 di Amazon ECS, pertimbangkan hal berikut:
+ Cluster Anda dapat berisi campuran VT1 dan VT1 non-instance.
+ Anda memerlukan aplikasi Linux yang menggunakan kartu transcoding media Xilinx U30 dengan codec AVC (H.264) dan HEVC (H.265) yang dipercepat.
**penting**  
Aplikasi yang menggunakan codec lain mungkin tidak memiliki kinerja yang lebih baik pada VT1 instance.
+ Hanya satu tugas transcoding yang dapat dijalankan pada kartu U30. Setiap kartu memiliki dua perangkat yang terkait dengannya. Anda dapat menjalankan tugas transcoding sebanyak mungkin karena ada kartu untuk setiap VT1 instance Anda.
+ Saat membuat layanan atau menjalankan tugas mandiri, Anda dapat menggunakan atribut tipe instance saat mengonfigurasi batasan penempatan tugas. Ini memastikan bahwa tugas diluncurkan pada instance container yang Anda tentukan. Melakukannya membantu memastikan bahwa Anda menggunakan sumber daya Anda secara efektif dan bahwa tugas Anda untuk beban kerja transcoding video ada di instans Anda VT1 . Untuk informasi selengkapnya, lihat [Cara Amazon ECS Menempatkan Tugas di Instans Kontainer](task-placement.md).

  Dalam contoh berikut, tugas dijalankan pada `vt1.3xlarge` instance di `default` cluster Anda.

  ```
  aws ecs run-task \
       --cluster default \
       --task-definition vt1-3xlarge-xffmpeg-processor \
       --placement-constraints type=memberOf,expression="attribute:ecs.instance-type == vt1.3xlarge"
  ```
+ Anda mengonfigurasi kontainer untuk menggunakan kartu U30 spesifik yang tersedia pada instance wadah host. Anda dapat melakukan ini dengan menggunakan `linuxParameters` parameter dan menentukan detail perangkat. Untuk informasi selengkapnya, lihat [Persyaratan ketentuan tugas](#ecs-vt1-requirements).

## Menggunakan VT1 AMI
<a name="ecs-vt1-ami"></a>

Anda memiliki dua opsi untuk menjalankan AMI di Amazon EC2 untuk instans penampung Amazon ECS. Opsi pertama adalah menggunakan AMI resmi Xilinx di. AWS Marketplace Opsi kedua adalah membangun AMI Anda sendiri dari repositori sampel.
+ [Xilinx menawarkan AMIs ](https://aws.amazon.com/marketplace/pp/prodview-phvk6d4mq3hh6) pada. AWS Marketplace
+ Amazon ECS menyediakan contoh repositori yang dapat Anda gunakan untuk membangun AMI untuk beban kerja transcoding video. AMI ini hadir dengan driver Xilinx U30. Anda dapat menemukan repositori yang berisi skrip Packer di. [GitHub](https://github.com/aws-samples/aws-vt-baseami-pipeline) Untuk informasi selengkapnya tentang Packer, lihat dokumentasi [Packer](https://developer.hashicorp.com/packer/docs).

## Persyaratan ketentuan tugas
<a name="ecs-vt1-requirements"></a>

Untuk menjalankan kontainer transcoding video di Amazon ECS, definisi tugas Anda harus berisi aplikasi transcoding video yang menggunakan codec H.264/AVC dan H.265/HEVC yang dipercepat. Anda dapat membuat gambar kontainer dengan mengikuti langkah-langkah di [ GitHubXilinx](https://xilinx.github.io/video-sdk/v1.5/container_setup.html#creating-a-docker-image-for-vt1-usage).

Definisi tugas harus spesifik untuk jenis instance. Jenis instans adalah 3xlarge, 6xlarge, dan 24xlarge. Anda harus mengonfigurasi kontainer untuk menggunakan perangkat Xilinx U30 tertentu yang tersedia pada instance wadah host. Anda dapat melakukannya dengan menggunakan `linuxParameters` parameter. Tabel berikut merinci kartu dan perangkat SoCs yang spesifik untuk setiap jenis instance.


| Tipe Instans | v CPUs | RAM (GiB) | Kartu akselerator U30 | Perangkat SoC yang dapat dialamatkan XCU30  | Jalur Perangkat | 
| --- | --- | --- | --- | --- | --- | 
| vt1.3xlarge | 12 | 24 | 1 | 2 | /dev/dri/renderD128,/dev/dri/renderD129 | 
| vt1.6xlarge | 24 | 48 | 2 | 4 | /dev/dri/renderD128,/dev/dri/renderD129,/dev/dri/renderD130,/dev/dri/renderD131 | 
| vt1.24xlarge | 96 | 182 | 8 | 16 | /dev/dri/renderD128,/dev/dri/renderD129,/dev/dri/renderD130,/dev/dri/renderD131,/dev/dri/renderD132,/dev/dri/renderD133,/dev/dri/renderD134,/dev/dri/renderD135,/dev/dri/renderD136,/dev/dri/renderD137,/dev/dri/renderD138,/dev/dri/renderD139,/dev/dri/renderD140,/dev/dri/renderD141,/dev/dri/renderD142,/dev/dri/renderD143 | 

**penting**  
Jika definisi tugas mencantumkan perangkat yang tidak dimiliki instans EC2, tugas gagal dijalankan. Ketika tugas gagal, pesan kesalahan berikut muncul di`stoppedReason`:`CannotStartContainerError: Error response from daemon: error gathering device information while adding custom device "/dev/dri/renderD130": no such file or directory`.

# Menentukan transcoding video dalam definisi tugas Amazon ECS
<a name="task-def-video-transcode"></a>

Dalam contoh berikut, sintaks yang digunakan untuk definisi tugas dari wadah Linux di Amazon EC2 disediakan. Definisi tugas ini adalah untuk gambar kontainer yang dibangun mengikuti prosedur yang disediakan dalam dokumentasi [Xilinx](https://xilinx.github.io/video-sdk/v1.5/container_setup.html#creating-a-docker-image-for-vt1-usage). Jika Anda menggunakan contoh ini, ganti `image` dengan gambar Anda sendiri, dan salin file video Anda ke instance di `/home/ec2-user` direktori.

------
#### [ vt1.3xlarge ]

1. Buat file teks yang diberi nama `vt1-3xlarge-ffmpeg-linux.json` dengan konten berikut.

   ```
   {
       "family": "vt1-3xlarge-xffmpeg-processor",
       "requiresCompatibilities": ["EC2"],
       "placementConstraints": [
           {
               "type": "memberOf",
               "expression": "attribute:ecs.os-type == linux"
           },
           {
               "type": "memberOf",
               "expression": "attribute:ecs.instance-type == vt1.3xlarge"
           }
       ],
       "containerDefinitions": [
           {
               "entryPoint": [
                   "/bin/bash",
                   "-c"
               ],
               "command": ["/video/ecs_ffmpeg_wrapper.sh"],
               "linuxParameters": {
                   "devices": [
                       {
                           "containerPath": "/dev/dri/renderD128",
                           "hostPath": "/dev/dri/renderD128",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD129",
                           "hostPath": "/dev/dri/renderD129",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       }
                   ]
               },
               "mountPoints": [
                   {
                       "containerPath": "/video",
                       "sourceVolume": "video_file"
                   }
               ],
               "cpu": 0,
               "memory": 12000,
               "image": "0123456789012.dkr.ecr.us-west-2.amazonaws.com/aws/xilinx-xffmpeg",
               "essential": true,
               "name": "xilinix-xffmpeg"
           }
       ],
       "volumes": [
           {
               "name": "video_file",
               "host": {"sourcePath": "/home/ec2-user"}
           }
       ]
   }
   ```

1. Mendaftarkan ketentuan tugas.

   ```
   aws ecs register-task-definition --family vt1-3xlarge-xffmpeg-processor --cli-input-json file://vt1-3xlarge-xffmpeg-linux.json --region us-east-1
   ```

------
#### [ vt1.6xlarge ]

1. Buat file teks yang diberi nama `vt1-6xlarge-ffmpeg-linux.json` dengan konten berikut.

   ```
   {
       "family": "vt1-6xlarge-xffmpeg-processor",
       "requiresCompatibilities": ["EC2"],
       "placementConstraints": [
           {
               "type": "memberOf",
               "expression": "attribute:ecs.os-type == linux"
           },
           {
               "type": "memberOf",
               "expression": "attribute:ecs.instance-type == vt1.6xlarge"
           }
       ],
       "containerDefinitions": [
           {
               "entryPoint": [
                   "/bin/bash",
                   "-c"
               ],
               "command": ["/video/ecs_ffmpeg_wrapper.sh"],
               "linuxParameters": {
                   "devices": [
                       {
                           "containerPath": "/dev/dri/renderD128",
                           "hostPath": "/dev/dri/renderD128",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD129",
                           "hostPath": "/dev/dri/renderD129",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD130",
                           "hostPath": "/dev/dri/renderD130",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD131",
                           "hostPath": "/dev/dri/renderD131",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       }
                   ]
               },
               "mountPoints": [
                   {
                       "containerPath": "/video",
                       "sourceVolume": "video_file"
                   }
               ],
               "cpu": 0,
               "memory": 12000,
               "image": "0123456789012.dkr.ecr.us-west-2.amazonaws.com/aws/xilinx-xffmpeg",
               "essential": true,
               "name": "xilinix-xffmpeg"
           }
       ],
       "volumes": [
           {
               "name": "video_file",
               "host": {"sourcePath": "/home/ec2-user"}
           }
       ]
   }
   ```

1. Mendaftarkan ketentuan tugas.

   ```
   aws ecs register-task-definition --family vt1-6xlarge-xffmpeg-processor --cli-input-json file://vt1-6xlarge-xffmpeg-linux.json --region us-east-1
   ```

------
#### [ vt1.24xlarge ]

1. Buat file teks yang diberi nama `vt1-24xlarge-ffmpeg-linux.json` dengan konten berikut.

   ```
   {
       "family": "vt1-24xlarge-xffmpeg-processor",
       "requiresCompatibilities": ["EC2"],
       "placementConstraints": [
           {
               "type": "memberOf",
               "expression": "attribute:ecs.os-type == linux"
           },
           {
               "type": "memberOf",
               "expression": "attribute:ecs.instance-type == vt1.24xlarge"
           }
       ],
       "containerDefinitions": [
           {
               "entryPoint": [
                   "/bin/bash",
                   "-c"
               ],
               "command": ["/video/ecs_ffmpeg_wrapper.sh"],
               "linuxParameters": {
                   "devices": [
                       {
                           "containerPath": "/dev/dri/renderD128",
                           "hostPath": "/dev/dri/renderD128",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD129",
                           "hostPath": "/dev/dri/renderD129",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD130",
                           "hostPath": "/dev/dri/renderD130",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD131",
                           "hostPath": "/dev/dri/renderD131",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD132",
                           "hostPath": "/dev/dri/renderD132",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD133",
                           "hostPath": "/dev/dri/renderD133",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD134",
                           "hostPath": "/dev/dri/renderD134",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD135",
                           "hostPath": "/dev/dri/renderD135",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD136",
                           "hostPath": "/dev/dri/renderD136",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD137",
                           "hostPath": "/dev/dri/renderD137",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD138",
                           "hostPath": "/dev/dri/renderD138",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD139",
                           "hostPath": "/dev/dri/renderD139",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD140",
                           "hostPath": "/dev/dri/renderD140",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD141",
                           "hostPath": "/dev/dri/renderD141",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD142",
                           "hostPath": "/dev/dri/renderD142",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD143",
                           "hostPath": "/dev/dri/renderD143",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       }
                   ]
               },
               "mountPoints": [
                   {
                       "containerPath": "/video",
                       "sourceVolume": "video_file"
                   }
               ],
               "cpu": 0,
               "memory": 12000,
               "image": "0123456789012.dkr.ecr.us-west-2.amazonaws.com/aws/xilinx-xffmpeg",
               "essential": true,
               "name": "xilinix-xffmpeg"
           }
       ],
       "volumes": [
           {
               "name": "video_file",
               "host": {"sourcePath": "/home/ec2-user"}
           }
       ]
   }
   ```

1. Mendaftarkan ketentuan tugas.

   ```
   aws ecs register-task-definition --family vt1-24xlarge-xffmpeg-processor --cli-input-json file://vt1-24xlarge-xffmpeg-linux.json --region us-east-1
   ```

------

# Definisi tugas Amazon ECS untuk beban kerja pembelajaran mesin AWS Neuron
<a name="ecs-inference"></a>

Anda dapat mendaftarkan [instans Amazon EC2 Trn1, Amazon](https://aws.amazon.com/ec2/instance-types/trn1/) EC2 [Trn2, Amazon EC2 Inf1,](https://aws.amazon.com/ec2/instance-types/trn2/) [dan [Amazon EC2](https://aws.amazon.com/ec2/instance-types/inf2/) Inf2](https://aws.amazon.com/ec2/instance-types/inf1/) ke cluster Anda untuk beban kerja pembelajaran mesin.

[Instans Amazon EC2 Trn1 dan Trn2 didukung oleh chip Trainium.AWS](https://aws.amazon.com/ai/machine-learning/trainium/) Instans ini memberikan pelatihan berkinerja tinggi dan biaya rendah untuk pembelajaran mesin di cloud. Anda dapat melatih model inferensi pembelajaran mesin menggunakan kerangka pembelajaran mesin dengan AWS Neuron pada instance Trn1 atau Trn2. Kemudian, Anda dapat menjalankan model pada instance Inf1, atau instance Inf2 untuk menggunakan akselerasi chip AWS Inferentia.

Instans Amazon EC2 Inf1 dan instans Inf2 didukung oleh chip [AWS Inferentia. Instans ini memberikan kinerja tinggi dan inferensi](https://aws.amazon.com/ai/machine-learning/inferentia/) biaya terendah di cloud.

Model pembelajaran mesin digunakan ke wadah menggunakan [AWS Neuron](https://aws.amazon.com/ai/machine-learning/neuron/), yang merupakan Kit Pengembang Perangkat Lunak (SDK) khusus. SDK terdiri dari compiler, runtime, dan alat profiling yang mengoptimalkan kinerja machine learning chip machine learning. AWS AWS Neuron mendukung kerangka kerja pembelajaran mesin populer seperti TensorFlow, PyTorch, dan MXNet Apache.

## Pertimbangan-pertimbangan
<a name="ecs-inference-considerations"></a>

Sebelum Anda mulai menerapkan Neuron di Amazon ECS, pertimbangkan hal berikut:
+ Cluster Anda dapat berisi campuran Trn1, Trn2, Inf1, Inf2 dan instance lainnya.
+ Anda memerlukan aplikasi Linux dalam wadah yang menggunakan kerangka pembelajaran mesin yang mendukung AWS Neuron.
**penting**  
Aplikasi yang menggunakan kerangka kerja lain mungkin tidak meningkatkan kinerja pada instance Trn1, Trn2, Inf1, dan Inf2.
+ [Hanya satu tugas inferensi atau pelatihan inferensi yang dapat dijalankan pada setiap chip [AWS Trainium](https://aws.amazon.com/ai/machine-learning/trainium/) atau Inferentia.AWS](https://aws.amazon.com/ai/machine-learning/inferentia/) Untuk Inf1, setiap chip memiliki 4 NeuronCores. Untuk Trn1, Trn2, dan Inf2 setiap chip memiliki 2. NeuronCores Anda dapat menjalankan tugas sebanyak mungkin karena ada chip untuk setiap instans Trn1, Trn2, Inf1, dan Inf2 Anda.
+ Saat membuat layanan atau menjalankan tugas mandiri, Anda dapat menggunakan atribut tipe instance saat mengonfigurasi batasan penempatan tugas. Ini memastikan bahwa tugas diluncurkan pada instance container yang Anda tentukan. Melakukannya dapat membantu Anda mengoptimalkan pemanfaatan sumber daya secara keseluruhan dan memastikan bahwa tugas untuk beban kerja inferensi ada di instans Trn1, Trn2, Inf1, dan Inf2 Anda. Untuk informasi selengkapnya, lihat [Cara Amazon ECS Menempatkan Tugas di Instans Kontainer](task-placement.md).

  Dalam contoh berikut, tugas dijalankan pada `Inf1.xlarge` instance di `default` cluster Anda.

  ```
  aws ecs run-task \
       --cluster default \
       --task-definition ecs-inference-task-def \
       --placement-constraints type=memberOf,expression="attribute:ecs.instance-type == Inf1.xlarge"
  ```
+ Persyaratan sumber daya neuron tidak dapat didefinisikan dalam definisi tugas. Sebagai gantinya, Anda mengonfigurasi wadah untuk menggunakan chip AWS Trainium atau AWS Inferentia tertentu yang tersedia di instance wadah host. Lakukan ini dengan menggunakan `linuxParameters` parameter dan menentukan detail perangkat. Untuk informasi selengkapnya, lihat [Persyaratan ketentuan tugas](#ecs-inference-requirements).

## Gunakan AMI Amazon Linux 2023 (Neuron) Amazon ECS yang dioptimalkan oleh Amazon
<a name="ecs-inference-ami2023"></a>

Amazon ECS menyediakan AMI Amazon ECS yang dioptimalkan yang didasarkan pada Amazon Linux 2023 untuk beban kerja AWS Trainium dan Inferentia. AWS Muncul dengan driver AWS Neuron dan runtime untuk Docker. AMI ini membuat menjalankan beban kerja inferensi pembelajaran mesin lebih mudah di Amazon ECS.

Sebaiknya gunakan AMI Amazon Linux 2023 (Neuron) Amazon ECS yang dioptimalkan Amazon ECS saat meluncurkan instans Amazon EC2 Trn1, Inf1, dan Inf2 Anda. 

Anda dapat mengambil AMI Amazon Linux 2023 (Neuron) Amazon ECS yang dioptimalkan saat AWS CLI ini menggunakan perintah berikut.

```
aws ssm get-parameters --names /aws/service/ecs/optimized-ami/amazon-linux-2023/neuron/recommended
```

## Persyaratan ketentuan tugas
<a name="ecs-inference-requirements"></a>

Untuk menerapkan Neuron di Amazon ECS, definisi tugas Anda harus berisi definisi penampung untuk wadah bawaan yang menyajikan model inferensi. TensorFlow Ini disediakan oleh AWS Deep Learning Containers. Wadah ini berisi runtime AWS Neuron dan aplikasi TensorFlow Serving. Saat startup, penampung ini mengambil model Anda dari Amazon S3, meluncurkan Penyajian TensorFlow Neuron dengan model yang disimpan, dan menunggu permintaan prediksi. Dalam contoh berikut, gambar kontainer memiliki TensorFlow 1.15 dan Ubuntu 18.04. Daftar lengkap Deep Learning Containers pra-bangun yang dioptimalkan untuk Neuron GitHub dipertahankan. Untuk informasi lebih lanjut, lihat [Menggunakan TensorFlow Penyajian AWS Neuron](https://docs.aws.amazon.com/dlami/latest/devguide/tutorial-inferentia-tf-neuron-serving.html).

```
763104351884.dkr.ecr.us-east-1.amazonaws.com/tensorflow-inference-neuron:1.15.4-neuron-py37-ubuntu18.04
```

Atau, Anda dapat membangun sendiri citra kontainer Neuron sespan. Untuk informasi lebih lanjut, lihat [Tutorial: TensorFlow Penyajian Neuron](https://github.com/aws-neuron/aws-neuron-sdk/blob/master/frameworks/tensorflow/tensorflow-neuron/tutorials/tutorials-tensorflow-utilizing-neuron-capabilities.rst) di *Panduan AWS Deep Learning AMIs Pengembang*.

Definisi tugas harus spesifik untuk satu jenis instance. Anda harus mengonfigurasi wadah untuk menggunakan perangkat AWS Trainium atau AWS Inferentia tertentu yang tersedia di instance wadah host. Anda dapat melakukannya dengan menggunakan `linuxParameters` parameter. Untuk contoh definisi tugas, lihat[Menentukan pembelajaran mesin AWS Neuron dalam definisi tugas Amazon ECS](ecs-inference-task-def.md). Tabel berikut merinci chip yang spesifik untuk setiap jenis instance.


| Tipe Instans | v CPUs | RAM (GiB) | AWS Chip akselerator mL | Jalur Perangkat | 
| --- | --- | --- | --- | --- | 
| trn1.2xlarge | 8 | 32 | 1 | /dev/neuron0 | 
| trn1.32xlarge | 128 | 512 | 16 |  /dev/neuron0, /dev/neuron1, /dev/neuron2, /dev/neuron3, /dev/neuron4, /dev/neuron5, /dev/neuron6, /dev/neuron7, /dev/neuron8, /dev/neuron9, /dev/neuron10, /dev/neuron11, /dev/neuron12, /dev/neuron13, /dev/neuron14, /dev/neuron15  | 
| trn2.48xlarge | 192 | 1536 | 16 |  /dev/neuron0, /dev/neuron1, /dev/neuron2, /dev/neuron3, /dev/neuron4, /dev/neuron5, /dev/neuron6, /dev/neuron7, /dev/neuron8, /dev/neuron9, /dev/neuron10, /dev/neuron11, /dev/neuron12, /dev/neuron13, /dev/neuron14, /dev/neuron15  | 
| inf1.xlarge | 4 | 8 | 1 | /dev/neuron0 | 
| inf1.2xlarge | 8 | 16 | 1 | /dev/neuron0 | 
| inf1.6xlarge | 24 | 48 | 4 | /dev/neuron0, /dev/neuron1, /dev/neuron2, /dev/neuron3 | 
| inf1.24xlarge | 96 | 192 | 16 |  /dev/neuron0, /dev/neuron1, /dev/neuron2, /dev/neuron3, /dev/neuron4, /dev/neuron5, /dev/neuron6, /dev/neuron7, /dev/neuron8, /dev/neuron9, /dev/neuron10, /dev/neuron11, /dev/neuron12, /dev/neuron13, /dev/neuron14, /dev/neuron15  | 
| inf2.xlarge | 8 | 16 | 1 | /dev/neuron0 | 
| inf2.8xlarge | 32 | 64 | 1 | /dev/neuron0 | 
| inf2.24xlarge | 96 | 384 | 6 | /dev/neuron0, /dev/neuron1, /dev/neuron2, /dev/neuron3, /dev/neuron4, /dev/neuron5,  | 
| inf2.48xlarge | 192 | 768 | 12 | /dev/neuron0, /dev/neuron1, /dev/neuron2, /dev/neuron3, /dev/neuron4, /dev/neuron5, /dev/neuron6, /dev/neuron7, /dev/neuron8, /dev/neuron9, /dev/neuron10, /dev/neuron11 | 

# Menentukan pembelajaran mesin AWS Neuron dalam definisi tugas Amazon ECS
<a name="ecs-inference-task-def"></a>

Berikut ini adalah contoh definisi tugas Linux untuk`inf1.xlarge`, menampilkan sintaks yang akan digunakan.

```
{
    "family": "ecs-neuron",
    "requiresCompatibilities": ["EC2"],
    "placementConstraints": [
        {
            "type": "memberOf",
            "expression": "attribute:ecs.os-type == linux"
        },
        {
            "type": "memberOf",
            "expression": "attribute:ecs.instance-type == inf1.xlarge"
        }
    ],
    "executionRoleArn": "${YOUR_EXECUTION_ROLE}",
    "containerDefinitions": [
        {
            "entryPoint": [
                "/usr/local/bin/entrypoint.sh",
                "--port=8500",
                "--rest_api_port=9000",
                "--model_name=resnet50_neuron",
                "--model_base_path=s3://amzn-s3-demo-bucket/resnet50_neuron/"
            ],
            "portMappings": [
                {
                    "hostPort": 8500,
                    "protocol": "tcp",
                    "containerPort": 8500
                },
                {
                    "hostPort": 8501,
                    "protocol": "tcp",
                    "containerPort": 8501
                },
                {
                    "hostPort": 0,
                    "protocol": "tcp",
                    "containerPort": 80
                }
            ],
            "linuxParameters": {
                "devices": [
                    {
                        "containerPath": "/dev/neuron0",
                        "hostPath": "/dev/neuron0",
                        "permissions": [
                            "read",
                            "write"
                        ]
                    }
                ],
                "capabilities": {
                    "add": [
                        "IPC_LOCK"
                    ]
                }
            },
            "cpu": 0,
            "memoryReservation": 1000,
            "image": "763104351884.dkr.ecr.us-east-1.amazonaws.com/tensorflow-inference-neuron:1.15.4-neuron-py37-ubuntu18.04",
            "essential": true,
            "name": "resnet50"
        }
    ]
}
```

# Definisi tugas Amazon ECS untuk instans pembelajaran mendalam
<a name="ecs-dl1"></a>

Untuk menggunakan beban kerja pembelajaran mendalam di Amazon ECS, daftarkan instans [Amazon DL1 EC2](https://aws.amazon.com/ec2/instance-types/dl1/) ke cluster Anda. DL1 Instans Amazon EC2 didukung oleh akselerator Gaudi dari Habana Labs (perusahaan Intel). Gunakan Habana SynapSeai SDK untuk terhubung ke akselerator Habana Gaudi. SDK mendukung kerangka kerja pembelajaran mesin yang populer, TensorFlow dan. PyTorch

## Pertimbangan-pertimbangan
<a name="ecs-dl1-considerations"></a>

Sebelum Anda mulai menerapkan DL1 di Amazon ECS, pertimbangkan hal berikut:
+ Cluster Anda dapat berisi campuran DL1 dan DL1 non-instance.
+ Saat membuat layanan atau menjalankan tugas mandiri, Anda dapat menggunakan atribut tipe instance secara khusus saat mengonfigurasi batasan penempatan tugas untuk memastikan bahwa tugas Anda diluncurkan pada instance container yang Anda tentukan. Melakukannya memastikan bahwa sumber daya Anda digunakan secara efektif dan bahwa tugas Anda untuk beban kerja pembelajaran mendalam ada di DL1 instans Anda. Untuk informasi selengkapnya, lihat [Cara Amazon ECS Menempatkan Tugas di Instans Kontainer](task-placement.md).

  Contoh berikut menjalankan tugas pada instans `dl1.24xlarge` di klaster `default` Anda.

  ```
  aws ecs run-task \
       --cluster default \
       --task-definition ecs-dl1-task-def \
       --placement-constraints type=memberOf,expression="attribute:ecs.instance-type == dl1.24xlarge"
  ```

## Menggunakan DL1 AMI
<a name="ecs-dl1-ami"></a>

Anda memiliki tiga opsi untuk menjalankan AMI di DL1 instans Amazon EC2 untuk Amazon ECS:
+ AWS Marketplace AMIs yang disediakan oleh Habana [di sini](https://aws.amazon.com/marketplace/pp/prodview-h24gzbgqu75zq).
+ Habana Deep Learning AMIs yang disediakan oleh Amazon Web Services. Karena tidak termasuk, Anda perlu menginstal agen kontainer Amazon ECS secara terpisah.
+ Gunakan Packer untuk membuat AMI khusus yang disediakan oleh [GitHubrepo](https://github.com/aws-samples/aws-habana-baseami-pipeline). Untuk informasi selengkapnya, lihat [dokumentasi Packer](https://developer.hashicorp.com/packer/docs).

# Menentukan pembelajaran mendalam dalam definisi tugas Amazon ECS
<a name="ecs-dl1-requirements"></a>

Untuk menjalankan wadah pembelajaran mendalam yang dipercepat Habana Gaudi di Amazon ECS, definisi tugas Anda harus berisi definisi wadah untuk wadah pra-bangun yang menyajikan model pembelajaran mendalam untuk TensorFlow atau PyTorch menggunakan Habana SynapSeai yang disediakan oleh Deep Learning Containers. AWS 

Gambar kontainer berikut memiliki TensorFlow 2.7.0 dan Ubuntu 20.04. Daftar lengkap Deep Learning Containers pra-bangun yang dioptimalkan untuk akselerator Habana Gaudi dipertahankan. GitHub Untuk informasi lebih lanjut, lihat [Wadah Pelatihan Habana](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#habana-training-containers).

```
763104351884.dkr.ecr.us-east-1.amazonaws.com/tensorflow-training-habana:2.7.0-hpu-py38-synapseai1.2.0-ubuntu20.04
```

Berikut ini adalah contoh definisi tugas untuk wadah Linux di Amazon EC2, menampilkan sintaks yang akan digunakan. Contoh ini menggunakan gambar yang berisi Habana Labs System Management Interface Tool (HL-SMI) yang ditemukan di sini: `vault.habana.ai/gaudi-docker/1.1.0/ubuntu20.04/habanalabs/tensorflow-installer-tf-cpu-2.6.0:1.1.0-614`

```
{
    "family": "dl-test",
    "requiresCompatibilities": ["EC2"],
    "placementConstraints": [
        {
            "type": "memberOf",
            "expression": "attribute:ecs.os-type == linux"
        },
        {
            "type": "memberOf",
            "expression": "attribute:ecs.instance-type == dl1.24xlarge"
        }
    ],
    "networkMode": "host",
    "cpu": "10240",
    "memory": "1024",
    "containerDefinitions": [
        {
            "entryPoint": [
                "sh",
                "-c"
            ],
            "command": ["hl-smi"],
            "cpu": 8192,
            "environment": [
                {
                    "name": "HABANA_VISIBLE_DEVICES",
                    "value": "all"
                }
            ],
            "image": "vault.habana.ai/gaudi-docker/1.1.0/ubuntu20.04/habanalabs/tensorflow-installer-tf-cpu-2.6.0:1.1.0-614",
            "essential": true,
            "name": "tensorflow-installer-tf-hpu"
        }
    ]
}
```

# Definisi tugas Amazon ECS untuk beban kerja ARM 64-bit
<a name="ecs-arm64"></a>

Amazon ECS mendukung penggunaan aplikasi ARM 64-bit. Anda dapat menjalankan aplikasi Anda di platform yang didukung oleh [AWS Graviton](https://aws.amazon.com/ec2/graviton/) Processors. Ini cocok untuk berbagai macam beban kerja. Ini termasuk beban kerja seperti server aplikasi, layanan mikro, komputasi kinerja tinggi, inferensi pembelajaran mesin berbasis CPU, pengkodean video, otomatisasi desain elektronik, game, database sumber terbuka, dan cache dalam memori.

## Pertimbangan-pertimbangan
<a name="ecs-arm64-considerations"></a>

Sebelum Anda mulai menerapkan definisi tugas yang menggunakan arsitektur ARM 64-bit, pertimbangkan hal berikut:
+ Aplikasi dapat menggunakan Fargate atau. EC2s
+ Aplikasi hanya dapat menggunakan sistem operasi Linux.
+ Untuk tipe Fargate, aplikasi harus menggunakan versi platform Fargate atau yang lebih baru. `1.4.0`
+ Aplikasi dapat digunakan Fluent Bit atau CloudWatch untuk pemantauan.
+ Untuk Fargate, berikut ini Wilayah AWS tidak mendukung beban kerja ARM 64-bit:
  + AS Timur (Virginia N.), Zona `use1-az3` Ketersediaan
+  Untuk EC2, lihat berikut ini untuk memverifikasi bahwa Wilayah tempat Anda berada mendukung jenis instans yang ingin Anda gunakan:
  + [Instans Amazon EC2 M6g](https://aws.amazon.com/ec2/instance-types/m6)
  +  [Instans Amazon EC2 T4G](https://aws.amazon.com/ec2/instance-types/t4/)
  +  [Instans Amazon EC2 C6g](https://aws.amazon.com/ec2/instance-types/c6g/)
  +  [Instans Amazon EC2 R6gd](https://aws.amazon.com/ec2/instance-types/r6/)
  +  [Instans Amazon EC2 x2GD](https://aws.amazon.com/ec2/instance-types/x2/)

  Anda juga dapat menggunakan `describe-instance-type-offerings` perintah Amazon EC2 dengan filter untuk melihat penawaran instans untuk Wilayah Anda. 

  ```
  aws ec2 describe-instance-type-offerings --filters Name=instance-type,Values=instance-type --region region
  ```

  Contoh berikut memeriksa ketersediaan tipe instans M6 di Wilayah AS Timur (Virginia N.) (us-east-1).

  ```
  aws ec2 describe-instance-type-offerings --filters "Name=instance-type,Values=m6*" --region us-east-1
  ```

  Untuk informasi selengkapnya, lihat [describe-instance-type-offerings ](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-instance-type-offerings.html)di Referensi *Baris Perintah Amazon EC2*.

# Menentukan arsitektur ARM dalam definisi tugas Amazon ECS
<a name="ecs-arm-specifying"></a>

Untuk menggunakan arsitektur ARM, `ARM64` tentukan parameter definisi `cpuArchitecture` tugas. 

Dalam contoh berikut, arsitektur ARM ditentukan dalam definisi tugas. Ini dalam format JSON.

```
{
    "runtimePlatform": {
        "operatingSystemFamily": "LINUX",
        "cpuArchitecture": "ARM64"
    },
...
}
```

Dalam contoh berikut, definisi tugas untuk arsitektur ARM menampilkan “hello world.”

```
{
 "family": "arm64-testapp",
 "networkMode": "awsvpc",
 "containerDefinitions": [
    {
        "name": "arm-container",
        "image": "public.ecr.aws/docker/library/busybox:latest",
        "cpu": 100,
        "memory": 100,
        "essential": true,
        "command": [ "echo hello world" ],
        "entryPoint": [ "sh", "-c" ]
    }
 ],
 "requiresCompatibilities": [ "EC2" ],
 "cpu": "256",
 "memory": "512",
 "runtimePlatform": {
        "operatingSystemFamily": "LINUX",
        "cpuArchitecture": "ARM64"
  },
 "executionRoleArn": "arn:aws:iam::123456789012:role/ecsTaskExecutionRole"
}
```

# Kirim log Amazon ECS ke CloudWatch
<a name="using_awslogs"></a>

Anda dapat mengonfigurasi kontainer dalam tugas Anda untuk mengirim informasi CloudWatch log ke Log. Jika Anda menggunakan Fargate untuk tugas Anda, Anda dapat melihat log dari wadah Anda. Jika Anda menggunakan EC2, Anda dapat melihat log yang berbeda dari kontainer Anda di satu lokasi yang nyaman, dan ini mencegah log kontainer Anda mengambil ruang disk pada instance kontainer Anda.

**catatan**  
Jenis informasi yang dicatat oleh kontainer dalam tugas Anda sebagian besar bergantung pada perintah `ENTRYPOINT` mereka. Secara default, log yang diambil menunjukkan output perintah yang biasanya Anda lihat di terminal interaktif jika Anda menjalankan kontainer secara lokal, yang merupakan aliran `STDOUT` dan `STDERR` I/O. Driver `awslogs` log hanya meneruskan log ini dari Docker ke CloudWatch Logs. Untuk informasi selengkapnya tentang cara log Docker diproses, termasuk cara alternatif untuk menangkap berbagai pengaliran atau data file, lihat [Melihat log untuk kontainer atau layanan](https://docs.docker.com/engine/logging/) dalam dokumentasi Docker.

Untuk mengirim log sistem dari instans penampung Amazon ECS Anda ke CloudWatch Log, lihat [Memantau Kuota File Log](https://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/WhatIsCloudWatchLogs.html) [dan CloudWatch Log di Panduan](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/cloudwatch_limits_cwl.html) Pengguna *Amazon CloudWatch Logs*.

## Fargate
<a name="enable_awslogs"></a>

Jika Anda menggunakan Fargate untuk tugas Anda, Anda perlu menambahkan `logConfiguration` parameter yang diperlukan ke definisi tugas Anda untuk mengaktifkan driver `awslogs` log. Untuk informasi selengkapnya, lihat [Contoh definisi tugas Amazon ECS: Rute log ke CloudWatch](specify-log-config.md).

Untuk wadah Windows di Fargate, lakukan salah satu opsi berikut ketika salah satu parameter definisi tugas Anda memiliki karakter khusus seperti,: `& \ < > ^ |`
+ Tambahkan escape (`\`) dengan tanda kutip ganda di sekitar seluruh string parameter

  Contoh

  ```
  "awslogs-multiline-pattern": "\"^[|DEBUG|INFO|WARNING|ERROR\"",
  ```
+ Tambahkan karakter escape (`^`) di sekitar setiap karakter khusus

  Contoh

  ```
  "awslogs-multiline-pattern": "^^[^|DEBUG^|INFO^|WARNING^|ERROR",
  ```

## EC2
<a name="ec2-considerations"></a>

Jika Anda menggunakan EC2 untuk tugas Anda dan ingin mengaktifkan driver `awslogs` log, instans penampung Amazon ECS Anda memerlukan setidaknya versi 1.9.0 dari agen penampung. Untuk informasi tentang cara memeriksa versi agen Anda dan memperbarui ke versi terbaru, lihat[Memperbarui agen kontainer Amazon ECS](ecs-agent-update.md).

**catatan**  
Anda harus menggunakan AMI Amazon ECS yang dioptimalkan atau AMI khusus dengan setidaknya `1.9.0-1` versi paket. `ecs-init` Saat menggunakan AMI kustom, Anda harus menentukan bahwa driver `awslogs` logging tersedia di instans Amazon EC2 saat Anda memulai agen dengan menggunakan variabel lingkungan berikut dalam file variabel **docker run** pernyataan atau lingkungan Anda.  

```
ECS_AVAILABLE_LOGGING_DRIVERS=["json-file","awslogs"]
```

Instans penampung Amazon ECS Anda juga memerlukan `logs:CreateLogStream` dan `logs:PutLogEvents` izin pada peran IAM yang dapat digunakan untuk meluncurkan instans penampung. Jika Anda membuat peran instans penampung Amazon ECS sebelum dukungan driver `awslogs` log diaktifkan di Amazon ECS, Anda mungkin perlu menambahkan izin ini. `ecsTaskExecutionRole`Ini digunakan saat ditugaskan ke tugas dan kemungkinan berisi izin yang benar. Untuk informasi tentang peran eksekusi tugas, lihat[Peran IAM pelaksanaan tugas Amazon ECS](task_execution_IAM_role.md). Jika instance container Anda menggunakan kebijakan IAM terkelola untuk instance container, instance container Anda kemungkinan memiliki izin yang benar. Untuk informasi tentang kebijakan IAM terkelola untuk instance container, lihat. [Peran IAM instans kontainer Amazon ECS](instance_IAM_role.md)

# Contoh definisi tugas Amazon ECS: Rute log ke CloudWatch
<a name="specify-log-config"></a>

Sebelum kontainer Anda dapat mengirim log ke CloudWatch, Anda harus menentukan driver `awslogs` log untuk kontainer dalam definisi tugas Anda. Untuk informasi selengkapnya tentang parameter log, lihat [Penyimpanan dan pencatatan log](task_definition_parameters.md#container_definition_storage)

Definisi tugas JSON yang berikut memiliki `logConfiguration` objek yang ditentukan untuk setiap kontainer. Salah satunya adalah untuk WordPress wadah yang mengirim log ke grup log yang dipanggil`awslogs-wordpress`. Yang lainnya adalah untuk wadah MySQL yang mengirimkan log ke grup log yang dipanggil. `awslogs-mysql` Kedua kontainer menggunakan prefiks pengaliran log `awslogs-example`.

```
{
    "containerDefinitions": [
        {
            "name": "wordpress",
            "links": [
                "mysql"
            ],
            "image": "public.ecr.aws/docker/library/wordpress:latest",
            "essential": true,
            "portMappings": [
                {
                    "containerPort": 80,
                    "hostPort": 80
                }
            ],
            "logConfiguration": {
                "logDriver": "awslogs",
                "options": {
                    "awslogs-create-group": "true",
                    "awslogs-group": "awslogs-wordpress",
                    "awslogs-region": "us-west-2",
                    "awslogs-stream-prefix": "awslogs-example"
                }
            },
            "memory": 500,
            "cpu": 10
        },
        {
            "environment": [
                {
                    "name": "MYSQL_ROOT_PASSWORD",
                    "value": "password"
                }
            ],
            "name": "mysql",
            "image": "public.ecr.aws/docker/library/mysql:latest",
            "cpu": 10,
            "memory": 500,
            "essential": true,
            "logConfiguration": {
                "logDriver": "awslogs",
                "options": {
                    "awslogs-create-group": "true",
                    "awslogs-group": "awslogs-mysql",
                    "awslogs-region": "us-west-2",
                    "awslogs-stream-prefix": "awslogs-example",
                    "mode": "non-blocking", 
                    "max-buffer-size": "25m" 
                }
            }
        }
    ],
    "family": "awslogs-example"
}
```

## Langkah selanjutnya
<a name="specify-log-config-next-steps"></a>
+ Anda dapat menetapkan kebijakan retensi untuk grup log secara opsional menggunakan CloudWatch AWS CLI atau API. Untuk informasi selengkapnya, lihat [put-retention-policy](https://docs.aws.amazon.com/cli/latest/reference/logs/put-retention-policy.html) dalam *Referensi AWS Command Line Interface *. 
+ Setelah Anda mendaftarkan definisi tugas dengan driver `awslogs` log dalam konfigurasi log definisi kontainer, Anda dapat menjalankan tugas atau membuat layanan dengan definisi tugas tersebut untuk mulai mengirim CloudWatch log ke Log. Untuk informasi selengkapnya, lihat [Menjalankan aplikasi sebagai tugas Amazon ECS](standalone-task-create.md) dan [Membuat penyebaran pembaruan bergulir Amazon ECS](create-service-console-v2.md).

# Kirim log Amazon ECS ke AWS layanan atau AWS Partner
<a name="using_firelens"></a>

Anda dapat menggunakan Amazon ECS FireLens untuk menggunakan parameter definisi tugas untuk merutekan log ke AWS layanan atau tujuan AWS Partner Network (APN) untuk penyimpanan log dan analitik. AWS Partner Network Ini adalah komunitas mitra global yang memanfaatkan program, keahlian, dan sumber daya untuk membangun, memasarkan, dan menjual penawaran pelanggan. Untuk informasi lebih lanjut lihat [AWS Partner](https://aws.amazon.com/partners/work-with-partners/). FireLensbekerja dengan [Fluentd](https://www.fluentd.org/) dan[Fluent Bit](https://fluentbit.io/). Kami menyediakan AWS untuk Fluent Bit gambar atau Anda dapat menggunakan gambar Anda sendiri Fluentd atau Fluent Bit gambar.

Secara default, Amazon ECS mengonfigurasi dependensi penampung sehingga kontainer Firelens dimulai sebelum penampung apa pun yang menggunakannya. Wadah Firelens juga berhenti setelah semua wadah yang menggunakannya berhenti.

Untuk menggunakan fitur ini, Anda harus membuat peran IAM untuk tugas Anda yang memberikan izin yang diperlukan untuk menggunakan AWS layanan apa pun yang diperlukan tugas. Misalnya, jika kontainer merutekan log ke Firehose, tugas tersebut memerlukan izin untuk memanggil `firehose:PutRecordBatch` API. Untuk informasi selengkapnya, silakan lihat [Menambahkan dan Menghapus Izin Identitas IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) dalam *Panduan Pengguna IAM*.

Tugas Anda mungkin juga memerlukan peran eksekusi tugas Amazon ECS dalam kondisi berikut. Untuk informasi selengkapnya, lihat [Peran IAM pelaksanaan tugas Amazon ECS](task_execution_IAM_role.md).
+ Jika tugas Anda di-host di Fargate dan Anda menarik gambar kontainer dari Amazon ECR atau mereferensikan data sensitif dari AWS Secrets Manager konfigurasi log Anda, maka Anda harus menyertakan peran IAM eksekusi tugas.
+ Saat Anda menggunakan file konfigurasi khusus yang di-host di Amazon S3, peran IAM eksekusi tugas Anda harus menyertakan izin. `s3:GetObject`

Pertimbangkan hal berikut saat menggunakan FireLens untuk Amazon ECS:
+ Kami menyarankan Anda `my_service_` menambahkan nama wadah log sehingga Anda dapat dengan mudah membedakan nama kontainer di konsol.
+ Amazon ECS menambahkan dependensi pesanan kontainer awal antara container aplikasi dan FireLens container secara default. Saat Anda menentukan urutan kontainer antara wadah aplikasi dan FireLens kontainer, maka urutan kontainer awal default diganti.
+ FireLensuntuk Amazon ECS didukung untuk tugas-tugas yang di-host AWS Fargate di Linux dan Amazon EC2 di Linux. Kontainer Windows tidak mendukungFireLens.

  Untuk informasi tentang cara mengonfigurasi pencatatan terpusat untuk kontainer Windows, lihat [Pencatatan terpusat untuk kontainer Windows di Amazon ECS menggunakan](https://aws.amazon.com/blogs/containers/centralized-logging-for-windows-containers-on-amazon-ecs-using-fluent-bit/) Bit Lancar.
+ Anda dapat menggunakan CloudFormation templat FireLens untuk mengonfigurasi Amazon ECS. Untuk informasi selengkapnya, lihat [AWS::ECS::TaskDefinition FirelensConfiguration](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-taskdefinition-firelensconfiguration.html)di *Panduan AWS CloudFormation Pengguna*
+ FireLensmendengarkan di port`24224`, jadi untuk memastikan bahwa router FireLens log tidak dapat dijangkau di luar tugas, Anda tidak boleh mengizinkan lalu lintas masuk pada port `24224` dalam grup keamanan yang digunakan tugas Anda. Untuk tugas yang menggunakan mode `awsvpc` jaringan, ini adalah grup keamanan yang terkait dengan tugas tersebut. Untuk tugas yang menggunakan mode `host` jaringan, ini adalah grup keamanan yang terkait dengan instans Amazon EC2 yang menghosting tugas tersebut. Untuk tugas yang menggunakan mode `bridge` jaringan, jangan membuat pemetaan port apa pun yang menggunakan port. `24224`
+ Untuk tugas yang menggunakan mode `bridge` jaringan, wadah dengan FireLens konfigurasi harus dimulai sebelum wadah aplikasi apa pun yang mengandalkannya dimulai. Untuk mengendalikan urutan mulai kontainer Anda, gunakan syarat dependensi dalam ketentuan tugas Anda. Untuk informasi selengkapnya, lihat [Dependensi kontainer](task_definition_parameters.md#container_definition_dependson).
**catatan**  
Jika Anda menggunakan parameter kondisi ketergantungan dalam definisi kontainer dengan FireLens konfigurasi, pastikan bahwa setiap kontainer memiliki persyaratan `START` atau `HEALTHY` kondisi.
+ Secara default, FireLens tambahkan nama definisi klaster dan tugas serta Amazon Resource Name (ARN) klaster sebagai kunci metadata ke log container Anda. stdout/stderr Berikut ini adalah contoh format metadata.

  ```
  "ecs_cluster": "cluster-name",
  "ecs_task_arn": "arn:aws:ecs:region:111122223333:task/cluster-name/f2ad7dba413f45ddb4EXAMPLE",
  "ecs_task_definition": "task-def-name:revision",
  ```

  Jika Anda tidak ingin metadata di log Anda, atur `enable-ecs-log-metadata` ke `false` `firelensConfiguration` bagian definisi tugas.

  ```
  "firelensConfiguration":{
     "type":"fluentbit",
     "options":{
        "enable-ecs-log-metadata":"false",
        "config-file-type":"file",
        "config-file-value":"/extra.conf"
  }
  ```

Anda dapat mengonfigurasi FireLens wadah untuk dijalankan sebagai pengguna non-root. Pertimbangkan hal berikut:
+  Untuk mengonfigurasi FireLens wadah agar dijalankan sebagai pengguna non-root, Anda harus menentukan pengguna dalam salah satu format berikut:
  + `uid`
  + `uid:gid`
  + `uid:group`

  Untuk informasi selengkapnya tentang menentukan pengguna dalam definisi container, lihat [ContainerDefinition](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ContainerDefinition.html)di *Referensi API Amazon Elastic Container Service*.

  FireLensWadah menerima log aplikasi melalui UNIX soket. Agen Amazon ECS menggunakan `uid` untuk menetapkan kepemilikan direktori soket ke wadah. FireLens
+ Mengonfigurasi FireLens penampung untuk dijalankan sebagai pengguna non-root didukung pada versi Amazon ECS Agent dan yang lebih baru, `1.96.0` serta versi AMI Amazon ECS yang dioptimalkan dan yang lebih baru. `v20250716`
+ Ketika Anda menentukan pengguna untuk FireLens wadah, `uid` harus unik dan tidak digunakan untuk proses lain milik kontainer lain dalam tugas atau instance kontainer.

Untuk informasi tentang cara menggunakan beberapa file konfigurasi dengan Amazon ECS, termasuk file yang Anda host atau file di Amazon S3, [lihat Proses init untuk Bit Lancar di ECS](https://github.com/aws/aws-for-fluent-bit/tree/mainline/use_cases/init-process-for-fluent-bit), dukungan multi-konfigurasi.

Untuk informasi tentang konfigurasi contoh, lihat[Contoh definisi tugas Amazon ECS: Rute log ke FireLens](firelens-taskdef.md).

Untuk informasi selengkapnya tentang mengonfigurasi log untuk throughput tinggi, lihat. [Mengkonfigurasi log Amazon ECS untuk throughput tinggi](firelens-docker-buffer-limit.md)

# Mengkonfigurasi log Amazon ECS untuk throughput tinggi
<a name="firelens-docker-buffer-limit"></a>

Untuk skenario throughput log tinggi, sebaiknya gunakan driver `awsfirelens` log dengan FireLens danFluent Bit. Fluent Bitadalah prosesor log ringan yang efisien dengan sumber daya dan dapat menangani jutaan catatan log. Namun, mencapai kinerja optimal pada skala memerlukan penyetelan konfigurasinya.

Bagian ini mencakup teknik Fluent Bit pengoptimalan lanjutan untuk menangani throughput log tinggi sambil menjaga stabilitas sistem dan memastikan tidak ada kehilangan data.

Untuk informasi tentang cara menggunakan file konfigurasi kustom dengan FireLens, lihat[Gunakan file konfigurasi khusus](firelens-taskdef.md#firelens-taskdef-customconfig). Untuk contoh tambahan, lihat [ FireLens contoh Amazon ECS](https://github.com/aws-samples/amazon-ecs-firelens-examples) di GitHub.

**catatan**  
Beberapa opsi konfigurasi di bagian ini, seperti `workers` dan`threaded`, memerlukan AWS Fluent Bit versi 3 atau yang lebih baru. Untuk informasi tentang versi yang tersedia, lihat [AWS untuk rilis Fluent Bit](https://github.com/aws/aws-for-fluent-bit/releases).

## Memahami potongan
<a name="firelens-understanding-chunks"></a>

Fluent BitMemproses data dalam satuan yang disebut *chunks*. Ketika plugin INPUT menerima data, mesin membuat potongan yang disimpan dalam memori atau pada sistem file sebelum dikirim ke tujuan OUTPUT.

Perilaku buffering tergantung pada `storage.type` pengaturan di bagian INPUT Anda. Secara default, Fluent Bit menggunakan buffering memori. Untuk skenario throughput atau produksi tinggi, buffering sistem file memberikan ketahanan yang lebih baik.

Untuk informasi lebih lanjut, lihat [Potongan](https://docs.fluentbit.io/manual/administration/buffering-and-storage#chunks) dalam Fluent Bit dokumentasi dan [Apa itu Potongan?](https://github.com/aws-samples/amazon-ecs-firelens-examples/tree/mainline/examples/fluent-bit/oomkill-prevention#what-is-a-chunk) dalam repositori AWS untuk Fluent Bit contoh.

## Buffering memori (default)
<a name="firelens-memory-buffering"></a>

Secara default, Fluent Bit menggunakan memori buffering (`storage.type memory`). Anda dapat membatasi penggunaan memori per plugin INPUT menggunakan `Mem_Buf_Limit` parameter.

Contoh berikut menunjukkan konfigurasi masukan buffered memori:

```
[INPUT]
    Name          tcp
    Tag           ApplicationLogs
    Port          5170
    storage.type  memory
    Mem_Buf_Limit 5MB
```

**penting**  
Ketika `Mem_Buf_Limit` terlampaui untuk sebuah plugin, Fluent Bit jeda input dan catatan baru hilang. Ini dapat menyebabkan tekanan balik dan memperlambat aplikasi Anda. Peringatan berikut muncul di Fluent Bit log:  

```
[input] tcp.1 paused (mem buf overlimit)
```

Buffering memori cocok untuk kasus penggunaan sederhana dengan throughput log rendah hingga sedang. Untuk skenario throughput atau produksi tinggi di mana kehilangan data menjadi perhatian, gunakan buffering sistem file sebagai gantinya.

Untuk informasi selengkapnya, lihat [Buffering dan Memory](https://docs.fluentbit.io/manual/administration/buffering-and-storage#buffering-and-memory) dalam Fluent Bit dokumentasi dan [Memory Buffering Only](https://github.com/aws-samples/amazon-ecs-firelens-examples/tree/mainline/examples/fluent-bit/oomkill-prevention#case-1-memory-buffering-only-default-or-storagetype-memory) di repositori AWS for Fluent Bit examples.

## Penyangga sistem file
<a name="firelens-filesystem-buffering"></a>

Untuk skenario throughput tinggi, sebaiknya gunakan buffering sistem file. Untuk informasi selengkapnya tentang cara Fluent Bit mengelola buffering dan penyimpanan, lihat [Buffering dan Storage](https://docs.fluentbit.io/manual/administration/buffering-and-storage) dalam dokumentasi. Fluent Bit

Filesystem buffering memberikan keuntungan sebagai berikut:
+ **Kapasitas buffer yang lebih besar** — Ruang disk biasanya lebih melimpah daripada memori.
+ **Persistensi** — Data buffered bertahan Fluent Bit restart.
+ **Degradasi anggun** — Selama kegagalan output, data terakumulasi pada disk daripada menyebabkan kelelahan memori.

Untuk mengaktifkan buffering sistem file, sediakan file konfigurasi khusus. Fluent Bit Contoh berikut menunjukkan konfigurasi yang disarankan:

```
[SERVICE]
    # Flush logs every 1 second
    Flush 1
    # Wait 120 seconds during shutdown to flush remaining logs
    Grace 120
    # Directory for filesystem buffering
    storage.path             /var/log/flb-storage/
    # Limit chunks stored 'up' in memory (reduce for memory-constrained environments)
    storage.max_chunks_up    32
    # Flush backlog chunks to destinations during shutdown (prevents log loss)
    storage.backlog.flush_on_shutdown On

[INPUT]
    Name forward
    unix_path /var/run/fluent.sock
    # Run input in separate thread to prevent blocking
    threaded true
    # Enable filesystem buffering for persistence
    storage.type filesystem

[OUTPUT]
    Name cloudwatch_logs
    Match *
    region us-west-2
    log_group_name /aws/ecs/my-app
    log_stream_name $(ecs_task_id)
    # Use multiple workers for parallel processing
    workers 2
    # Retry failed flushes up to 15 times
    retry_limit 15
    # Maximum disk space for buffered data for this output
    storage.total_limit_size 10G
```

Parameter konfigurasi kunci:

`storage.path`  
Direktori tempat Fluent Bit menyimpan potongan buffer pada disk.

`storage.backlog.flush_on_shutdown`  
Saat diaktifkan, Fluent Bit mencoba untuk menghapus semua potongan sistem file backlog ke tujuan mereka selama shutdown. Ini membantu memastikan pengiriman data sebelum Fluent Bit berhenti, tetapi dapat meningkatkan waktu shutdown.

`storage.max_chunks_up`  
Jumlah potongan yang tersisa dalam memori. Defaultnya adalah 128 chunks, yang dapat mengkonsumsi 500 MB\$1memori karena setiap potongan dapat menggunakan hingga 4-5 MB. Dalam lingkungan yang dibatasi memori, turunkan nilai ini. Misalnya, jika Anda memiliki 50 MB yang tersedia untuk buffering, atur ini menjadi 8-10 potongan.

`storage.type filesystem`  
Mengaktifkan penyimpanan sistem file untuk plugin input. Terlepas dari namanya, Fluent Bit digunakan `mmap` untuk memetakan potongan ke memori dan disk, memberikan ketekunan tanpa mengorbankan kinerja.

`storage.total_limit_size`  
Ruang disk maksimum untuk data buffer untuk plugin OUTPUT tertentu. Ketika batas ini tercapai, catatan tertua untuk output tersebut dijatuhkan. Untuk informasi lebih lanjut tentang ukuran, lihat[Memahami `storage.total_limit_size`](#firelens-storage-sizing).

`threaded true`  
Menjalankan input di utasnya sendiri, terpisah dari Fluent Bit loop acara utama. Ini mencegah input lambat memblokir seluruh pipa.

Untuk informasi selengkapnya, lihat [Filesystem Buffering](https://docs.fluentbit.io/manual/administration/buffering-and-storage#filesystem-buffering) dalam Fluent Bit dokumentasi dan [Filesystem dan Memory Buffering di repositori](https://github.com/aws-samples/amazon-ecs-firelens-examples/tree/mainline/examples/fluent-bit/oomkill-prevention#case-2-filesystem-and-memory-buffering-storagetype-filesystem) for examples. AWS Fluent Bit

## Memahami `storage.total_limit_size`
<a name="firelens-storage-sizing"></a>

`storage.total_limit_size`Parameter pada setiap plugin OUTPUT mengontrol ruang disk maksimum untuk data buffer untuk output tersebut. Ketika batas ini tercapai, catatan tertua untuk output tersebut dijatuhkan untuk memberi ruang bagi data baru. Ketika ruang disk benar-benar habis, Fluent Bit gagal untuk mengantri catatan dan mereka hilang.

Gunakan rumus berikut untuk menghitung yang sesuai `storage.total_limit_size` berdasarkan tingkat log Anda dan jendela pemulihan yang diinginkan:

```
If log rate is in KB/s, convert to MB/s first:
log_rate (MB/s) = log_rate (KB/s) / 1000

storage.total_limit_size (GB) = log_rate (MB/s) × duration (hours) × 3600 (seconds/hour) / 1000 (MB to GB)
```

Tabel berikut menunjukkan contoh perhitungan untuk tingkat log umum dan jendela pemulihan:


| Tingkat Log | 1 jam | 6 jam | 12 jam | 24 jam | 
| --- | --- | --- | --- | --- | 
| 0, 25 MB/s | 0,9 GB | 5,4 GB | 10,8 GB | 21,6 GB | 
| 0, 5 MB/s | 1,8 GB | 10,8 GB | 21,6 GB | 43,2 GB | 
| 1 MB/s | 3,6 GB | 21,6 GB | 43,2 GB | 86,4 GB | 
| 5 MB/s | 18 GB | 108 GB | 216 GB | 432 GB | 
| 10 MB/s | 36 GB | 216 GB | 432 GB | 864 GB | 

Untuk mengamati throughput puncak dan memilih ukuran buffer yang sesuai, gunakan sampel [ FireLens ukuran-throughput](https://github.com/aws-samples/amazon-ecs-firelens-examples/tree/mainline/examples/measure-throughput).

Gunakan rumus, contoh perhitungan, dan benchmarking untuk memilih yang cocok `storage.total_limit_size` yang menyediakan landasan pacu untuk pemulihan upaya terbaik selama pemadaman.

## Persyaratan penyimpanan tugas Amazon ECS
<a name="firelens-storage-task-requirements"></a>

Jumlahkan semua `storage.total_limit_size` nilai di seluruh bagian OUTPUT dan tambahkan buffer untuk overhead. Total ini menentukan ruang penyimpanan yang dibutuhkan dalam definisi tugas Amazon ECS Anda. Misalnya, 3 output × 10 GB masing-masing = 30 GB\$1buffer (5—10 GB) = 35—40 GB total yang diperlukan. Jika total melebihi penyimpanan yang tersedia, Fluent Bit mungkin gagal untuk mengantri catatan dan mereka akan hilang.

Opsi penyimpanan berikut tersedia:

Bind mount (penyimpanan sementara)  
+ Untuk AWS Fargate, defaultnya adalah penyimpanan sementara 20 GB (maks 200 GB). Konfigurasikan penggunaan `ephemeralStorage` dalam definisi tugas. Untuk informasi selengkapnya, lihat [EphemeralStorage](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-taskdefinition-ephemeralstorage.html) di *AWS CloudFormation Panduan Pengguna*.
+ Untuk EC2, defaultnya adalah 30 GB saat menggunakan AMI Amazon ECS yang dioptimalkan (dibagi antara OS dan Docker). Tingkatkan dengan mengubah ukuran volume root.

Volume Amazon EBS  
+ Menyediakan penyimpanan blok yang sangat tersedia, tahan lama, dan berkinerja tinggi.
+ Memerlukan konfigurasi volume dan `mountPoint` dalam definisi tugas menunjuk ke `storage.path` (default:`/var/log/flb-storage/`).
+ Untuk informasi selengkapnya, lihat [Tunda konfigurasi volume untuk waktu peluncuran dalam definisi tugas Amazon ECS](specify-ebs-config.md).

Volume Amazon EFS  
+ Menyediakan penyimpanan file yang sederhana dan dapat diskalakan.
+ Memerlukan konfigurasi volume dan `mountPoint` dalam definisi tugas menunjuk ke `storage.path` (default:`/var/log/flb-storage/`).
+ Untuk informasi selengkapnya, lihat [Menentukan sistem file Amazon EFS dalam definisi tugas Amazon ECS](specify-efs-config.md).

Untuk informasi selengkapnya tentang volume data, lihat[Opsi penyimpanan untuk tugas Amazon ECS](using_data_volumes.md).

## Optimalkan konfigurasi keluaran
<a name="firelens-output-optimization"></a>

Masalah jaringan, pemadaman layanan, dan pembatasan tujuan dapat mencegah log dikirimkan. Konfigurasi output yang tepat memastikan ketahanan tanpa kehilangan data.

Ketika output flush gagal, Fluent Bit dapat mencoba kembali operasi. Parameter berikut mengontrol perilaku coba lagi:

`retry_limit`  
Jumlah maksimum percobaan ulang setelah upaya awal sebelum menjatuhkan catatan. Default-nya adalah 1. Misalnya, `retry_limit 3` berarti 4 total upaya (1 awal \$13 percobaan ulang). Untuk lingkungan produksi, kami merekomendasikan 15 atau lebih tinggi, yang mencakup beberapa menit pemadaman dengan backoff eksponensial.  
Setel ke `no_limits` atau `False` untuk percobaan ulang tak terbatas:  
+ Dengan buffering memori, percobaan ulang tak terbatas menyebabkan plugin input berhenti saat batas memori tercapai.
+ Dengan buffering sistem file, catatan tertua dijatuhkan saat tercapai. `storage.total_limit_size`
Setelah menghabiskan semua upaya coba lagi (1 percobaan ulang awal \$1`retry_limit`), catatan dijatuhkan. AWS plugin dengan `auto_retry_requests true` (default) menyediakan lapisan coba lagi tambahan sebelum mekanisme coba Fluent Bit lagi. Untuk informasi selengkapnya, lihat [Mengonfigurasi percobaan ulang](https://docs.fluentbit.io/manual/administration/scheduling-and-retries#configure-retries) dalam Fluent Bit dokumentasi.  
Misalnya, `retry_limit 3` dengan pengaturan default (`scheduler.base 5`,`scheduler.cap 2000`,`net.connect_timeout 10s`) menyediakan sekitar 70 detik waktu tunggu penjadwal (10-an\$120-an\$140-an), 40 detik batas waktu koneksi jaringan (4 upaya × 10 detik), ditambah percobaan ulang AWS plugin - total sekitar 2-10 menit tergantung pada kondisi jaringan dan batas waktu OS TCP.

`scheduler.base`  
Detik dasar antara percobaan ulang (default: 5). Kami merekomendasikan 10 detik.

`scheduler.cap`  
Detik maksimum antara percobaan ulang (default: 2000). Kami merekomendasikan 60 detik.

Waktu tunggu antara percobaan ulang menggunakan backoff eksponensial dengan jitter:

```
wait_time = random(base, min(base × 2^retry_number, cap))
```

Misalnya, dengan `scheduler.base 10` dan`scheduler.cap 60`:
+ Coba lagi pertama: tunggu acak antara 10-20 detik
+ Coba lagi kedua: tunggu acak antara 10-40 detik
+ Coba lagi ketiga dan kemudian: tunggu acak antara 10-60 detik (dibatasi)

Untuk informasi selengkapnya, lihat [Mengkonfigurasi waktu tunggu untuk mencoba lagi](https://docs.fluentbit.io/manual/administration/scheduling-and-retries#configure-wait-time-for-retry) dan [Jaringan](https://docs.fluentbit.io/manual/administration/networking) dalam Fluent Bit dokumentasi.

`workers`  
Jumlah thread untuk pemrosesan output paralel. Beberapa pekerja memungkinkan pembilasan bersamaan, meningkatkan throughput saat memproses banyak potongan.

`auto_retry_requests`  
Pengaturan AWS khusus plugin yang menyediakan lapisan coba lagi tambahan sebelum mekanisme coba ulang bawaanFluent Bit. Nilai default-nya `true`. Saat diaktifkan, plugin AWS keluaran mencoba ulang permintaan yang gagal secara internal sebelum permintaan dianggap sebagai flush yang gagal dan tunduk pada konfigurasi. `retry_limit`

`Grace`Parameter di `[SERVICE]` bagian mengatur waktu Fluent Bit menunggu selama shutdown untuk menyiram data buffer. `Grace`Periode harus dikoordinasikan dengan wadah. `stopTimeout` Pastikan bahwa `stopTimeout` melebihi `Grace` periode untuk memungkinkan Fluent Bit untuk menyelesaikan pembilasan sebelum menerima. `SIGKILL` Misalnya, jika `Grace` 120 detik, atur `stopTimeout` ke 150 detik.

Contoh berikut menunjukkan Fluent Bit konfigurasi lengkap dengan semua pengaturan yang direkomendasikan untuk skenario throughput tinggi:

```
[SERVICE]
    # Flush logs every 1 second
    Flush 1
    # Wait 120 seconds during shutdown to flush remaining logs
    Grace 120
    # Directory for filesystem buffering
    storage.path             /var/log/flb-storage/
    # Limit chunks stored 'up' in memory (reduce for memory-constrained environments)
    storage.max_chunks_up    32
    # Flush backlog chunks to destinations during shutdown (prevents log loss)
    storage.backlog.flush_on_shutdown On
    # Minimum seconds between retries
    scheduler.base           10
    # Maximum seconds between retries (exponential backoff cap)
    scheduler.cap            60

[INPUT]
    Name forward
    unix_path /var/run/fluent.sock
    # Run input in separate thread to prevent blocking
    threaded true
    # Enable filesystem buffering for persistence
    storage.type filesystem

[OUTPUT]
    Name cloudwatch_logs
    Match *
    region us-west-2
    log_group_name /aws/ecs/my-app
    log_stream_name $(ecs_task_id)
    # Use multiple workers for parallel processing
    workers 2
    # Retry failed flushes up to 15 times
    retry_limit 15
    # Maximum disk space for buffered data for this output
    storage.total_limit_size 10G
```

## Memahami skenario kehilangan data
<a name="firelens-record-loss-scenarios"></a>

Catatan dapat hilang selama pemadaman yang diperpanjang atau masalah dengan tujuan output. Rekomendasi konfigurasi dalam panduan ini adalah pendekatan upaya terbaik untuk meminimalkan kehilangan data, tetapi tidak dapat menjamin nol kerugian selama kegagalan yang berkepanjangan. Memahami skenario ini membantu Anda mengonfigurasi Fluent Bit untuk memaksimalkan ketahanan.

Rekaman dapat hilang dengan dua cara: catatan tertua dijatuhkan saat penyimpanan terisi, atau catatan terbaru ditolak ketika sistem tidak dapat menerima lebih banyak data.

### Rekor tertua dijatuhkan
<a name="firelens-record-loss-oldest-dropped"></a>

Catatan buffer tertua dijatuhkan ketika upaya coba lagi habis atau saat `storage.total_limit_size` diisi dan perlu memberi ruang untuk data baru.

Batas coba lagi terlampaui  
Terjadi setelah AWS plugin mencoba ulang (jika`auto_retry_requests true`) ditambah 1 Fluent Bit upaya awal ditambah percobaan `retry_limit` ulang. Untuk mengurangi, atur `retry_limit no_limits` per plugin OUTPUT untuk percobaan ulang tak terbatas:  

```
[OUTPUT]
    Name                        cloudwatch_logs
    Match                       ApplicationLogs
    retry_limit                 no_limits
    auto_retry_requests         true
```
Percobaan ulang tak terbatas mencegah jatuhnya catatan karena kelelahan coba lagi, tetapi dapat menyebabkan pengisian. `storage.total_limit_size`

Batas penyimpanan tercapai (buffering sistem file)  
Terjadi ketika tujuan output tidak tersedia lebih lama dari buffer yang `storage.total_limit_size` dapat dikonfigurasi. Misalnya, buffer 10 GB pada 1 MB/s log rate menyediakan sekitar 2,7 jam buffering. Untuk mengurangi, tingkatkan `storage.total_limit_size` per plugin OUTPUT dan sediakan penyimpanan tugas Amazon ECS yang memadai:  

```
[OUTPUT]
    Name                        cloudwatch_logs
    Match                       ApplicationLogs
    storage.total_limit_size    10G
```

### Catatan terbaru ditolak
<a name="firelens-record-loss-newest-rejected"></a>

Catatan terbaru dijatuhkan saat ruang disk habis atau saat input dijeda karena. `Mem_Buf_Limit`

Ruang disk habis (buffering sistem file)  
Terjadi ketika ruang disk benar-benar habis. Fluent Bitgagal mengantri catatan baru dan hilang. Untuk mengurangi, jumlahkan semua `storage.total_limit_size` nilai dan sediakan penyimpanan tugas Amazon ECS yang memadai. Untuk informasi selengkapnya, lihat [Persyaratan penyimpanan tugas Amazon ECS](#firelens-storage-task-requirements).

Batas memori tercapai (buffering memori)  
Terjadi ketika tujuan output tidak tersedia dan buffer memori terisi. Plugin input yang dijeda berhenti menerima catatan baru. Untuk mengurangi, gunakan `storage.type filesystem` untuk ketahanan yang lebih baik, atau tingkatkan. `Mem_Buf_Limit`

### Praktik terbaik untuk meminimalkan kehilangan data
<a name="firelens-record-loss-best-practices"></a>

Pertimbangkan praktik terbaik berikut untuk meminimalkan kehilangan data:
+ **Gunakan buffering sistem file - Tetapkan `storage.type filesystem` untuk ketahanan yang lebih baik selama pemadaman**.
+ **Ukuran penyimpanan dengan tepat** — Hitung `storage.total_limit_size` berdasarkan tingkat log dan jendela pemulihan yang diinginkan.
+ **Menyediakan disk yang memadai** — Pastikan tugas Amazon ECS memiliki penyimpanan sementara yang cukup, Amazon EBS, atau Amazon EFS.
+ **Konfigurasikan perilaku coba lagi** - Seimbangkan antara `retry_limit` (menjatuhkan catatan setelah percobaan ulang yang melelahkan) dan `no_limits` (mencoba ulang tanpa batas tetapi dapat mengisi penyimpanan).

## Gunakan pencatatan multi-tujuan untuk keandalan
<a name="firelens-multi-destination"></a>

Mengirim log ke beberapa tujuan menghilangkan satu titik kegagalan. Misalnya, jika CloudWatch Log mengalami pemadaman, log masih mencapai Amazon S3.

Pencatatan multi-tujuan memberikan manfaat berikut. Plugin keluaran Amazon S3 juga mendukung opsi kompresi seperti format gzip dan Parket, yang dapat mengurangi biaya penyimpanan. Untuk informasi selengkapnya, lihat [kompresi S3](https://docs.fluentbit.io/manual/pipeline/outputs/s3#compression) dalam Fluent Bit dokumentasi.

Pencatatan multi-tujuan dapat memberikan manfaat berikut:
+ **Redundansi** — Jika satu tujuan gagal, log masih mencapai yang lain.
+ **Pemulihan** — Rekonstruksi kesenjangan dalam satu sistem dari yang lain.
+ **Daya Tahan** - Arsipkan log di Amazon S3 untuk retensi jangka panjang.
+ **Pengoptimalan biaya** — Simpan log terbaru dalam layanan kueri cepat seperti CloudWatch Log dengan retensi lebih pendek, sambil mengarsipkan semua log ke penyimpanan Amazon S3 berbiaya lebih rendah untuk retensi jangka panjang.

Fluent BitKonfigurasi berikut mengirimkan log ke CloudWatch Log dan Amazon S3:

```
[OUTPUT]
    Name cloudwatch_logs
    Match *
    region us-west-2
    log_group_name /aws/ecs/my-app
    log_stream_name $(ecs_task_id)
    workers 2
    retry_limit 15

[OUTPUT]
    Name s3
    Match *
    bucket my-logs-bucket
    region us-west-2
    total_file_size 100M
    s3_key_format /fluent-bit-logs/$(ecs_task_id)/%Y%m%d/%H/%M/$UUID
    upload_timeout 10m
    # Maximum disk space for buffered data for this output
    storage.total_limit_size 5G
```

Kedua output menggunakan `Match *` pola yang sama, sehingga semua catatan dikirim ke kedua tujuan secara independen. Selama pemadaman satu tujuan, log terus mengalir ke tujuan lainnya sementara flush yang gagal menumpuk di buffer sistem file untuk dicoba lagi nanti.

## Gunakan logging berbasis file dengan plugin input ekor
<a name="firelens-tail-input"></a>

Untuk skenario throughput tinggi di mana kehilangan log merupakan masalah penting, Anda dapat menggunakan pendekatan alternatif: minta aplikasi Anda menulis log ke file di disk, dan konfigurasikan Fluent Bit untuk membacanya menggunakan plugin `tail` input. Pendekatan ini sepenuhnya melewati lapisan driver logging Docker.

Pencatatan berbasis file dengan plugin ekor memberikan manfaat berikut:
+ **Offset tracking** - Plugin ekor dapat menyimpan offset file dalam file database (menggunakan `DB` opsi), memberikan daya tahan di seluruh Fluent Bit restart. Ini membantu mencegah kehilangan log selama restart kontainer.
+ **Buffering tingkat input** - Anda dapat mengonfigurasi batas buffer memori langsung pada plugin input menggunakan`Mem_Buf_Limit`, memberikan kontrol yang lebih terperinci atas penggunaan memori.
+ **Menghindari overhead Docker** — Log masuk langsung dari file ke Fluent Bit tanpa melewati buffer log Docker.

Untuk menggunakan pendekatan ini, aplikasi Anda harus menulis log ke file alih-alih`stdout`. Baik wadah aplikasi dan Fluent Bit wadah memasang volume bersama tempat file log disimpan.

Contoh berikut menunjukkan konfigurasi input ekor dengan praktik terbaik:

```
[INPUT]
    Name tail
    # File path or glob pattern to tail
    Path /var/log/app.log
    # Database file for storing file offsets (enables resuming after restart)
    DB /var/log/flb_tail.db
    # when true, controls that only fluent-bit will access the database (improves performance)
    DB.locking true
    # Skip long lines instead of skipping the entire file
    Skip_Long_Lines On
    # How often (in seconds) to check for new files matching the glob pattern
    Refresh_Interval 10
    # Extra seconds to monitor a file after rotation to account for pending flush
    Rotate_Wait 30
    # Maximum size of the buffer for a single line
    Buffer_Max_Size 10MB
    # Initial allocation size for reading file data
    Buffer_Chunk_Size 1MB
    # Maximum memory buffer size (tail pauses when full)
    Mem_Buf_Limit 75MB
```

Saat menggunakan plugin input ekor, pertimbangkan hal berikut:
+ Terapkan rotasi log untuk log aplikasi Anda untuk mencegah kelelahan disk. Pantau metrik volume yang mendasarinya untuk mengukur kinerja.
+ Pertimbangkan pengaturan seperti`Ignore_Older`,`Read_from_Head`, dan parser multiline berdasarkan format log Anda.

Untuk informasi selengkapnya, lihat [Ekor](https://docs.fluentbit.io/manual/pipeline/inputs/tail) dalam Fluent Bit dokumentasi. Untuk praktik terbaik, lihat [Konfigurasi ekor dengan praktik terbaik](https://github.com/aws/aws-for-fluent-bit/blob/mainline/troubleshooting/debugging.md#tail-config-with-best-practices) dalam panduan AWS Fluent Bit pemecahan masalah.

## Log langsung ke FireLens
<a name="firelens-environment-variables"></a>

Ketika driver `awsfirelens` log ditentukan dalam definisi tugas, agen penampung Amazon ECS menyuntikkan variabel lingkungan berikut ke dalam wadah:

`FLUENT_HOST`  
Alamat IP yang ditetapkan ke FireLens kontainer.  
Jika Anda menggunakan EC2 dengan mode `bridge` jaringan, variabel `FLUENT_HOST` lingkungan dalam wadah aplikasi Anda dapat menjadi tidak akurat setelah restart wadah router FireLens log (wadah dengan `firelensConfiguration` objek dalam definisi kontainer). Ini karena `FLUENT_HOST` merupakan alamat IP dinamis dan dapat berubah setelah restart. Logging langsung dari wadah aplikasi ke alamat `FLUENT_HOST` IP dapat mulai gagal setelah alamat berubah. Untuk informasi selengkapnya tentang memulai ulang kontainer individual, lihat. [Mulai ulang kontainer individual dalam tugas Amazon ECS dengan kebijakan restart kontainer](container-restart-policy.md)

`FLUENT_PORT`  
Port tempat protokol Fluent Forward mendengarkan.

Anda dapat menggunakan variabel lingkungan ini untuk log langsung ke router Fluent Bit log dari kode aplikasi Anda menggunakan protokol Fluent Forward, alih-alih menulis ke`stdout`. Pendekatan ini melewati lapisan driver logging Docker, yang memberikan manfaat berikut:
+ **Latensi yang lebih rendah** - Log langsung masuk Fluent Bit tanpa melewati infrastruktur logging Docker.
+ **Pencatatan terstruktur** — Kirim data log terstruktur secara native tanpa overhead encoding JSON.
+ **Kontrol yang lebih baik** - Aplikasi Anda dapat menerapkan buffering sendiri dan logika penanganan kesalahan.

Pustaka logger Fluent berikut mendukung protokol Fluent Forward dan dapat digunakan untuk mengirim log langsung ke: Fluent Bit
+ **Go** — [fluent-logger-golang](https://github.com/fluent/fluent-logger-golang)
+ **Python** – [fluent-logger-python](https://github.com/fluent/fluent-logger-python)
+ **Jawa** — [fluent-logger-java](https://github.com/fluent/fluent-logger-java)
+ **Node.js** – [fluent-logger-node](https://github.com/fluent/fluent-logger-node)
+ **Ruby** – [fluent-logger-ruby](https://github.com/fluent/fluent-logger-ruby)

## Konfigurasikan batas buffer Docker
<a name="firelens-buffer-limit"></a>

Saat Anda membuat definisi tugas, Anda dapat menentukan jumlah baris log yang di-buffer dalam memori dengan menentukan nilainya. `log-driver-buffer-limit` Ini mengontrol buffer antara Docker dan. Fluent Bit Untuk informasi selengkapnya, lihat [Driver logging fluentd](https://docs.docker.com/engine/logging/drivers/fluentd/) di dokumentasi Docker.

Gunakan opsi ini ketika ada throughput tinggi, karena Docker mungkin kehabisan memori buffer dan membuang pesan buffer sehingga dapat menambahkan pesan baru.

Pertimbangkan hal berikut saat menggunakan opsi ini:
+ Opsi ini didukung pada jenis EC2 dan Fargate dengan `1.4.0` versi platform atau yang lebih baru.
+ Opsi ini hanya valid ketika `logDriver` diatur ke`awsfirelens`.
+ Batas buffer default adalah baris `1048576` log.
+ Batas buffer harus lebih besar dari atau sama dengan `0` dan kurang dari garis `536870912` log.
+ Jumlah maksimum memori yang digunakan untuk buffer ini adalah produk dari ukuran setiap baris log dan ukuran buffer. Misalnya, jika baris log aplikasi rata-rata `2` KiB, batas buffer 4096 akan menggunakan paling banyak `8` MiB. Jumlah total memori yang dialokasikan pada tingkat tugas harus lebih besar dari jumlah memori yang dialokasikan untuk semua wadah selain buffer memori driver log.

Definisi tugas berikut menunjukkan cara mengkonfigurasi`log-driver-buffer-limit`:

```
{
    "containerDefinitions": [
        {
            "name": "my_service_log_router",
            "image": "public.ecr.aws/aws-observability/aws-for-fluent-bit:3",
            "cpu": 0,
            "memoryReservation": 51,
            "essential": true,
            "firelensConfiguration": {
                "type": "fluentbit"
            }
        },
        {
            "essential": true,
            "image": "public.ecr.aws/docker/library/httpd:latest",
            "name": "app",
            "logConfiguration": {
                "logDriver": "awsfirelens",
                "options": {
                    "Name": "firehose",
                    "region": "us-west-2",
                    "delivery_stream": "my-stream",
                    "log-driver-buffer-limit": "52428800"
                }
            },
            "dependsOn": [
                {
                    "containerName": "my_service_log_router",
                    "condition": "START"
                }
            ],
            "memoryReservation": 100
        }
    ]
}
```

# AWS untuk repositori Fluent Bit gambar untuk Amazon ECS
<a name="firelens-using-fluentbit"></a>

AWS menyediakan Fluent Bit gambar dengan plugin untuk CloudWatch Log dan Firehose. Sebaiknya gunakan Fluent Bit sebagai router log Anda karena memiliki tingkat pemanfaatan sumber daya yang lebih rendah daripadaFluentd. Untuk informasi selengkapnya, lihat [CloudWatch Log untuk Bit Lancar dan [Amazon Kinesis Firehose](https://github.com/aws/amazon-kinesis-firehose-for-fluent-bit) for Fluent](https://github.com/aws/amazon-cloudwatch-logs-for-fluent-bit) Bit.

Gambar **AWS for Fluent Bit** tersedia di Amazon ECR di Galeri Publik Amazon ECR dan di repositori Amazon ECR untuk ketersediaan tinggi.

## Galeri Publik Amazon ECR
<a name="firelens-image-ecrpublic"></a>

Fluent BitGambar AWS untuk tersedia di Galeri Publik Amazon ECR. Ini adalah lokasi yang disarankan untuk mengunduh Fluent Bit gambar AWS for karena ini adalah repositori publik dan tersedia untuk digunakan dari semua. Wilayah AWS Untuk informasi lebih lanjut, lihat [aws-for-fluent-bit](https://gallery.ecr.aws/aws-observability/aws-for-fluent-bit)di Galeri Publik Amazon ECR.

### Linux
<a name="firelens-image-ecrpublic-linux"></a>

Fluent BitGambar AWS for di Galeri Publik Amazon ECR mendukung sistem operasi Amazon Linux dengan `x86-64` arsitektur `ARM64` atau.

Anda dapat menarik Fluent Bit gambar AWS for dari Galeri Publik Amazon ECR dengan menentukan URL repositori dengan tag gambar yang diinginkan. Tag gambar yang tersedia dapat ditemukan di tab **Tag gambar** di Galeri Publik Amazon ECR.

Berikut ini menunjukkan sintaksis yang digunakan untuk Docker CLI.

```
docker pull public.ecr.aws/aws-observability/aws-for-fluent-bit:tag
```

Misalnya, Anda dapat menarik gambar terbaru dalam keluarga “3.x” AWS untuk Fluent Bit rilis menggunakan perintah CLI Docker ini.

```
docker pull public.ecr.aws/aws-observability/aws-for-fluent-bit:3
```

**catatan**  
Penarikan yang tidak diautentikasi diperbolehkan, tetapi memiliki batas kecepatan yang lebih rendah daripada tarikan yang diautentikasi. Untuk mengautentikasi menggunakan AWS akun Anda sebelum menarik, gunakan perintah berikut.  

```
aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws
```

#### AWS untuk Fluent Bit 3.0.0
<a name="firelens-image-ecrpublic-linux-3.0.0"></a>

Selain yang ada AWS untuk Fluent Bit versi`2.x`, AWS untuk Fluent Bit mendukung versi utama baru`3.x`. Versi utama baru termasuk memutakhirkan gambar dari Amazon Linux 2 ke Amazon Linux 2023 dan Fluent Bit versi `1.9.10` ke. `4.1.1` Untuk informasi selengkapnya, lihat [Fluent Bitrepositori AWS for](https://github.com/aws/aws-for-fluent-bit/blob/mainline/VERSIONS.md) on. GitHub

Contoh berikut menunjukkan tag diperbarui AWS untuk Fluent Bit `3.x` gambar:

Anda dapat menggunakan tag multi-arsitektur untuk Fluent Bit gambar AWS for.

```
docker pull public.ecr.aws/aws-observability/aws-for-fluent-bit:3
```

### Windows
<a name="firelens-image-ecrpublic-windows"></a>

Fluent BitGambar AWS for di Galeri Publik Amazon ECR mendukung `AMD64` arsitektur dengan sistem operasi berikut:
+ Windows Server 2022 Lengkap
+ Windows Server 2022 Inti
+ Windows Server 2019 Full
+ Windows Server 2019 Core

Wadah Windows yang ada di AWS Fargate tidak mendukung. FireLens

Anda dapat menarik Fluent Bit gambar AWS for dari Galeri Publik Amazon ECR dengan menentukan URL repositori dengan tag gambar yang diinginkan. Tag gambar yang tersedia dapat ditemukan di tab **Tag gambar** di Galeri Publik Amazon ECR.

Berikut ini menunjukkan sintaksis yang digunakan untuk Docker CLI.

```
docker pull public.ecr.aws/aws-observability/aws-for-fluent-bit:tag
```

Misalnya, Anda dapat menarik stable terbaru AWS untuk Fluent Bit gambar menggunakan perintah CLI Docker ini.

```
docker pull public.ecr.aws/aws-observability/aws-for-fluent-bit:windowsservercore-stable
```

**catatan**  
Penarikan yang tidak diautentikasi diperbolehkan, tetapi memiliki batas kecepatan yang lebih rendah daripada tarikan yang diautentikasi. Untuk mengautentikasi menggunakan AWS akun Anda sebelum menarik, gunakan perintah berikut.  

```
aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws
```

## Amazon ECR
<a name="firelens-image-ecr"></a>

Gambar AWS for Fluent Bit tersedia di Amazon ECR untuk ketersediaan tinggi. Perintah berikut dapat digunakan untuk retreive gambar URIs dan menetapkan ketersediaan gambar dalam bentuk tertentu. Wilayah AWS

### Linux
<a name="firelens-image-ecr-linux"></a>

Stabil terbaru AWS untuk URI gambar Fluent Bit dapat diambil menggunakan perintah berikut.

```
aws ssm get-parameters \
      --names /aws/service/aws-for-fluent-bit/stable \
      --region us-east-1
```

Semua versi image AWS for Fluent Bit dapat dicantumkan menggunakan perintah berikut untuk menanyakan parameter Systems Manager Parameter Store.

```
aws ssm get-parameters-by-path \
      --path /aws/service/aws-for-fluent-bit \
      --region us-east-1
```

Stabil terbaru AWS untuk image Fluent Bit dapat direferensikan dalam CloudFormation template dengan mereferensikan nama penyimpanan parameter Systems Manager. Berikut ini adalah contohnya:

```
Parameters:
  FireLensImage:
    Description: Fluent Bit image for the FireLens Container
    Type: AWS::SSM::Parameter::Value<String>
    Default: /aws/service/aws-for-fluent-bit/stable
```

**catatan**  
Jika perintah gagal atau tidak ada output, gambar tidak tersedia Wilayah AWS di mana perintah dipanggil.

### Windows
<a name="firelens-image-ecr-windows"></a>

Stabil terbaru AWS untuk URI gambar Fluent Bit dapat diambil menggunakan perintah berikut.

```
aws ssm get-parameters \
      --names /aws/service/aws-for-fluent-bit/windowsservercore-stable \
      --region us-east-1
```

Semua versi image AWS for Fluent Bit dapat dicantumkan menggunakan perintah berikut untuk menanyakan parameter Systems Manager Parameter Store.

```
aws ssm get-parameters-by-path \
      --path /aws/service/aws-for-fluent-bit/windowsservercore \
      --region us-east-1
```

Stabil terbaru AWS untuk image Fluent Bit dapat direferensikan dalam CloudFormation template dengan mereferensikan nama penyimpanan parameter Systems Manager. Berikut ini adalah contohnya:

```
Parameters:
  FireLensImage:
    Description: Fluent Bit image for the FireLens Container
    Type: AWS::SSM::Parameter::Value<String>
    Default: /aws/service/aws-for-fluent-bit/windowsservercore-stable
```

# Contoh definisi tugas Amazon ECS: Rute log ke FireLens
<a name="firelens-taskdef"></a>

Untuk menggunakan perutean log kustom denganFireLens, Anda harus menentukan yang berikut dalam definisi tugas Anda:
+ Sebuah wadah log router yang berisi FireLens konfigurasi. Kami merekomendasikan bahwa kontainer ditandai sebagai `essential`.
+ Satu kontainer aplikasi atau lebih yang berisi konfigurasi log menentukan driver log `awsfirelens`.
+ Peran IAM tugas Amazon Resource Name (ARN) yang berisi izin yang diperlukan untuk tugas untuk merutekan log.

Saat membuat definisi tugas baru menggunakan Konsol Manajemen AWS, ada bagian FireLens integrasi yang membuatnya mudah untuk menambahkan wadah router log. Untuk informasi selengkapnya, lihat [Membuat definisi tugas Amazon ECS menggunakan konsol](create-task-definition.md).

Amazon ECS mengonversi konfigurasi log dan menghasilkan konfigurasi output Fluentd atau Fluent Bit. Konfigurasi output dipasang dalam kontainer perutean log di `/fluent-bit/etc/fluent-bit.conf` untuk Fluent Bit dan `/fluentd/etc/fluent.conf` untuk Fluentd.

**penting**  
FireLensmendengarkan di port`24224`. Oleh karena itu, untuk memastikan bahwa router FireLens log tidak dapat dijangkau di luar tugas, Anda tidak boleh mengizinkan lalu lintas masuk pada port `24224` dalam grup keamanan yang digunakan tugas Anda. Untuk tugas yang menggunakan mode `awsvpc` jaringan, ini adalah grup keamanan yang terkait dengan tugas. Untuk tugas yang menggunakan mode `host` jaringan, ini adalah grup keamanan yang terkait dengan instans Amazon EC2 yang menghosting tugas tersebut. Untuk tugas yang menggunakan mode `bridge` jaringan, jangan membuat pemetaan port apa pun yang menggunakan port. `24224`

Secara default, Amazon ECS menambahkan bidang tambahan di entri log Anda yang membantu mengidentifikasi sumber log. 
+ `ecs_cluster`— Nama cluster yang menjadi bagian dari tugas.
+ `ecs_task_arn`— Nama Sumber Daya Amazon (ARN) lengkap dari tugas yang menjadi bagian dari wadah.
+ `ecs_task_definition`— Nama definisi tugas dan revisi yang digunakan tugas.
+ `ec2_instance_id`— ID instans Amazon EC2 tempat penampung di-host. Bidang ini hanya berlaku untuk tugas yang menggunakan tipe peluncuran EC2.

Anda dapat mengatur `enable-ecs-log-metadata` ke `false` jika Anda tidak ingin metadata.

Contoh definisi tugas berikut mendefinisikan wadah router log yang menggunakan Fluent Bit untuk merutekan lognya ke CloudWatch Log. Ini juga mendefinisikan wadah aplikasi yang menggunakan konfigurasi log untuk merutekan log ke Amazon Data Firehose dan menetapkan memori yang digunakan untuk buffer peristiwa ke 2 MiB.

**catatan**  
Untuk contoh definisi tugas lainnya, lihat [ FireLenscontoh Amazon ECS](https://github.com/aws-samples/amazon-ecs-firelens-examples) di GitHub.

```
{
  "family": "firelens-example-firehose",
  "taskRoleArn": "arn:aws:iam::123456789012:role/ecs_task_iam_role",
  "containerDefinitions": [
    {
            "name": "log_router",
            "image": "public.ecr.aws/aws-observability/aws-for-fluent-bit:3",
            "cpu": 0,
            "memoryReservation": 51,
            "portMappings": [],
            "essential": true,
            "environment": [],
            "mountPoints": [],
            "volumesFrom": [],
            "logConfiguration": {
                "logDriver": "awslogs",
                "options": {
                    "awslogs-group": "/ecs/ecs-aws-firelens-sidecar-container",
                    "mode": "non-blocking",
                    "awslogs-create-group": "true",
                    "max-buffer-size": "25m",
                    "awslogs-region": "us-east-1",
                    "awslogs-stream-prefix": "firelens"
                },
                "secretOptions": []
            },
            "systemControls": [],
            "firelensConfiguration": {
                "type": "fluentbit"
            }
        },
    {
      "essential": true,
      "image": "public.ecr.aws/docker/library/httpd:latest",
      "name": "app",
      "logConfiguration": {
        "logDriver": "awsfirelens",
        "options": {
          "Name": "firehose",
          "region": "us-west-2",
          "delivery_stream": "my-stream",
          "log-driver-buffer-limit": "1048576"
        }
      },
      "memoryReservation": 100
    }
  ]
}
```

Pasangan kunci-nilai yang ditentukan sebagai opsi dalam `logConfiguration` objek digunakan untuk menghasilkan konfigurasi Fluentd atau Fluent Bit output. Berikut ini adalah contoh kode dari definisi Fluent Bit output.

```
[OUTPUT]
    Name   firehose
    Match  app-firelens*
    region us-west-2
    delivery_stream my-stream
```

**catatan**  
FireLens mengelola `match` konfigurasi. Anda tidak menentukan `match` konfigurasi dalam definisi tugas Anda. 

## Gunakan file konfigurasi khusus
<a name="firelens-taskdef-customconfig"></a>

Anda dapat menentukan file konfigurasi kustom. Format file konfigurasi adalah format asli untuk router log yang Anda gunakan. [Untuk informasi selengkapnya, lihat [Sintaks File Konfigurasi Fluentd dan Konfigurasi YAMM](https://docs.fluentd.org/configuration/config-file).](https://docs.fluentbit.io/manual/administration/configuring-fluent-bit/yaml)

Dalam file konfigurasi kustom Anda, untuk tugas yang menggunakan mode `awsvpc` jaringan `bridge` atau, jangan setel input forward Fluentd atau Fluent Bit melalui TCP karena FireLens menambahkannya ke konfigurasi input.

FireLensKonfigurasi Anda harus berisi opsi berikut untuk menentukan file konfigurasi kustom:

`config-file-type`  
Lokasi sumber file konfigurasi kustom. Opsi yang tersedia adalah `s3` atau `file`.  
Tugas yang di-host AWS Fargate hanya mendukung jenis file `file` konfigurasi. Namun, Anda dapat menggunakan file konfigurasi yang dihosting di Amazon S3 di AWS Fargate dengan menggunakan wadah for init. AWS Fluent Bit Untuk informasi selengkapnya, lihat [Proses Init untuk Bit Lancar di ECS, dukungan multi-konfigurasi aktif](https://github.com/aws/aws-for-fluent-bit/blob/mainline/use_cases/init-process-for-fluent-bit/README.md). GitHub

`config-file-value`  
Sumber untuk file konfigurasi kustom. Jika jenis file `s3` konfigurasi digunakan, nilai file konfigurasi adalah ARN lengkap dari bucket dan file Amazon S3. Jika jenis file `file` konfigurasi digunakan, nilai file konfigurasi adalah jalur lengkap dari file konfigurasi yang ada baik dalam gambar kontainer atau pada volume yang dipasang di wadah.  
Saat menggunakan file konfigurasi khusus, Anda harus menentukan jalur yang berbeda dari yang FireLens digunakan. Amazon ECS mencadangkan jalur `/fluent-bit/etc/fluent-bit.conf` file untuk Fluent Bit dan Fluentd. `/fluentd/etc/fluent.conf`

Contoh berikut menunjukkan sintaksis yang diperlukan saat menentukan konfigurasi kustom.

**penting**  
Untuk menentukan file konfigurasi kustom yang di-host di Amazon S3, pastikan Anda telah membuat peran IAM eksekusi tugas dengan izin yang tepat. 

Berikut ini menunjukkan sintaks yang diperlukan saat menentukan konfigurasi kustom.

```
{
  "containerDefinitions": [
    {
      "essential": true,
      "image": "906394416424.dkr.ecr.us-west-2.amazonaws.com/aws-for-fluent-bit:3",
      "name": "log_router",
      "firelensConfiguration": {
        "type": "fluentbit",
        "options": {
          "config-file-type": "s3 | file",
          "config-file-value": "arn:aws:s3:::amzn-s3-demo-bucket/fluent.conf | filepath"
        }
      }
    }
  ]
}
```

**catatan**  
Tugas yang dihosting AWS Fargate hanya mendukung jenis file `file` konfigurasi. Namun, Anda dapat menggunakan file konfigurasi yang dihosting di Amazon S3 di AWS Fargate dengan menggunakan wadah for init. AWS Fluent Bit Untuk informasi selengkapnya, lihat [Proses Init untuk Bit Lancar di ECS, dukungan multi-konfigurasi aktif](https://github.com/aws/aws-for-fluent-bit/blob/mainline/use_cases/init-process-for-fluent-bit/README.md). GitHub

# Menggunakan gambar AWS non-kontainer di Amazon ECS
<a name="private-auth"></a>

Gunakan registri pribadi untuk menyimpan kredensil Anda AWS Secrets Manager, dan kemudian mereferensikannya dalam definisi tugas Anda. Ini menyediakan cara untuk mereferensikan gambar kontainer yang ada di pendaftar pribadi di luar AWS yang memerlukan otentikasi dalam definisi tugas Anda. Fitur ini didukung oleh tugas yang dihosting di Fargate, instans Amazon EC2, dan instans eksternal yang menggunakan Amazon ECS Anywhere.

**penting**  
Jika definisi tugas Anda mereferensikan gambar yang disimpan di Amazon ECR, topik ini tidak berlaku. Untuk informasi selengkapnya, lihat [Menggunakan Gambar Amazon ECR dengan Amazon ECS](https://docs.aws.amazon.com/AmazonECR/latest/userguide/ECR_on_ECS.html) di *Panduan Pengguna Amazon Elastic Container Registry*.

Untuk tugas yang dihosting di instans Amazon EC2, fitur ini memerlukan versi `1.19.0` atau yang lebih baru dari agen penampung. Akan tetapi, kami merekomendasikan untuk menggunakan versi agen kontainer terbaru. Untuk informasi tentang cara memeriksa versi agen Anda dan memperbarui ke versi terbaru, lihat[Memperbarui agen kontainer Amazon ECS](ecs-agent-update.md).

Untuk tugas yang dihosting di Fargate, fitur ini memerlukan versi platform `1.2.0` atau yang lebih baru. Untuk informasi, lihat [Versi platform Fargate untuk Amazon ECS](platform-fargate.md).

Dalam definisi kontainer Anda, tentukan `repositoryCredentials` objek dengan detail rahasia yang Anda buat. Rahasia yang direferensikan dapat berasal dari akun yang berbeda Wilayah AWS atau berbeda dari tugas yang menggunakannya.

**catatan**  
Saat menggunakan Amazon ECS API, AWS CLI, atau AWS SDK, jika rahasia ada Wilayah AWS sama dengan tugas yang Anda luncurkan maka Anda dapat menggunakan ARN lengkap atau nama rahasia. Jika rahasia ada di akun yang berbeda, ARN penuh rahasia harus ditentukan. Saat menggunakan Konsol Manajemen AWS, ARN penuh rahasia harus ditentukan selalu.

Berikut ini adalah cuplikan definisi tugas yang menunjukkan parameter yang diperlukan:

Gantikan parameter berikut:
+ *private-repo*dengan nama host repositori pribadi 
+ *private-image*dengan nama gambar
+ *arn:aws:secretsmanager:region:aws\$1account\$1id:secret:secret\$1name*dengan nama sumber daya Amazon rahasia (ARN)

```
"containerDefinitions": [
    {
        "image": "private-repo/private-image",
        "repositoryCredentials": {
            "credentialsParameter": "arn:aws:secretsmanager:region:aws_account_id:secret:secret_name"
        }
    }
]
```

**catatan**  
Metode lain untuk mengaktifkan otentikasi registri pribadi menggunakan variabel lingkungan agen penampung Amazon ECS untuk mengautentikasi ke pendaftar pribadi. Metode ini hanya didukung untuk tugas yang dihosting di instans Amazon EC2. Untuk informasi selengkapnya, lihat [Mengonfigurasi instans penampung Amazon ECS untuk gambar Docker pribadi](private-auth-container-instances.md).

**Untuk menggunakan registri pribadi**

1. Definisi tugas harus memiliki peran eksekusi tugas. Hal ini mengizinkan agen kontainer untuk menarik citra kontainer. Untuk informasi selengkapnya, lihat [Peran IAM pelaksanaan tugas Amazon ECS](task_execution_IAM_role.md).

   Autentikasi registri pribadi memungkinkan tugas Amazon ECS Anda menarik gambar kontainer dari pendaftar pribadi di luar AWS (seperti Docker Hub, Quay.io, atau registri pribadi Anda sendiri) yang memerlukan kredensyal otentikasi. Fitur ini menggunakan Secrets Manager untuk menyimpan kredensyal registri Anda dengan aman, yang kemudian direferensikan dalam definisi tugas Anda menggunakan parameter. `repositoryCredentials`

   Untuk informasi selengkapnya tentang mengonfigurasi autentikasi registri pribadi, lihat [Menggunakan gambar AWS non-kontainer di Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/private-auth.html).

   Untuk menyediakan akses ke rahasia yang berisi kredensyal registri pribadi Anda, tambahkan izin berikut sebagai kebijakan inline ke peran eksekusi tugas. Untuk informasi selengkapnya, lihat [Menambahkan dan Menghapus Kebijakan IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html).
   + `secretsmanager:GetSecretValue`—Diperlukan untuk mengambil kredensyal registri pribadi dari Secrets Manager.
   + `kms:Decrypt`—Wajib hanya jika rahasia Anda menggunakan kunci KMS khusus dan bukan kunci default. Nama Sumber Daya Amazon (ARN) untuk kunci kustom Anda harus ditambahkan sebagai sumber daya.

   Berikut ini adalah contoh kebijakan inline yang menambahkan izin.

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "kms:Decrypt",
                   "secretsmanager:GetSecretValue"
               ],
               "Resource": [
                   "arn:aws:secretsmanager:us-east-1:111122223333:secret:secret_name",
                   "arn:aws:kms:us-east-1:111122223333:key/key_id"
               ]
           }
       ]
   }
   ```

------

1. Gunakan AWS Secrets Manager untuk membuat rahasia untuk kredensil registri pribadi Anda. Untuk informasi tentang cara membuat rahasia, lihat [Membuat AWS Secrets Manager rahasia](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html) di *Panduan AWS Secrets Manager Pengguna*.

   Masukkan kredensyal registri pribadi Anda menggunakan format berikut:

   ```
   {
     "username" : "privateRegistryUsername",
     "password" : "privateRegistryPassword"
   }
   ```

1. Mendaftarkan ketentuan tugas. Untuk informasi selengkapnya, lihat [Membuat definisi tugas Amazon ECS menggunakan konsol](create-task-definition.md).

# Mulai ulang kontainer individual dalam tugas Amazon ECS dengan kebijakan restart kontainer
<a name="container-restart-policy"></a>

Anda dapat mengaktifkan kebijakan restart untuk setiap wadah penting dan non-esensial yang ditentukan dalam definisi tugas Anda, untuk mengatasi kegagalan sementara lebih cepat dan menjaga ketersediaan tugas. Saat Anda mengaktifkan kebijakan restart untuk penampung, Amazon ECS dapat memulai ulang penampung jika keluar, tanpa perlu mengganti tugas.

Kebijakan restart tidak diaktifkan untuk kontainer secara default. Saat mengaktifkan kebijakan restart untuk kontainer, Anda dapat menentukan kode keluar tempat penampung tidak akan dimulai ulang. Ini bisa berupa kode keluar yang menunjukkan keberhasilan, seperti kode keluar`0`, yang tidak memerlukan restart. Anda juga dapat menentukan berapa lama kontainer harus berjalan dengan sukses sebelum restart dapat dicoba. Untuk informasi selengkapnya tentang parameter ini, lihat [Kebijakan Mulai Ulang](task_definition_parameters.md#container_definition_restart_policy). Untuk contoh definisi tugas yang menentukan nilai-nilai ini, lihat[Menentukan kebijakan restart container dalam definisi tugas Amazon ECS](container-restart-policy-example.md).

Anda dapat menggunakan titik akhir metadata tugas Amazon ECS atau CloudWatch Wawasan Kontainer untuk memantau berapa kali penampung dimulai ulang. Untuk informasi selengkapnya tentang titik akhir metadata tugas, lihat dan. [Titik akhir metadata tugas Amazon ECS versi 4](task-metadata-endpoint-v4.md) [Titik akhir metadata tugas Amazon ECS versi 4 untuk tugas di Fargate](task-metadata-endpoint-v4-fargate.md) *Untuk informasi selengkapnya tentang metrik Wawasan Kontainer untuk Amazon ECS, lihat metrik [Amazon ECS Container Insights di Panduan Pengguna](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Container-Insights-metrics-ECS.html) Amazon. CloudWatch *

Kebijakan restart kontainer didukung oleh tugas yang dihosting di Fargate, instans Amazon EC2, dan instans eksternal menggunakan Amazon ECS Anywhere.

## Pertimbangan-pertimbangan
<a name="container-restart-policy-considerations"></a>

Pertimbangkan hal berikut sebelum mengaktifkan kebijakan restart untuk penampung Anda:
+ Kebijakan restart tidak didukung untuk kontainer Windows di Fargate.
+ Untuk tugas yang dihosting di instans Amazon EC2, fitur ini memerlukan versi `1.86.0` atau yang lebih baru dari agen penampung. Akan tetapi, kami merekomendasikan untuk menggunakan versi agen kontainer terbaru. Untuk informasi tentang cara memeriksa versi agen Anda dan memperbarui ke versi terbaru, lihat[Memperbarui agen kontainer Amazon ECS](ecs-agent-update.md).
+ Jika Anda menggunakan EC2 dengan mode `bridge` jaringan, variabel `FLUENT_HOST` lingkungan dalam wadah aplikasi Anda dapat menjadi tidak akurat setelah restart wadah router FireLens log (wadah dengan `firelensConfiguration` objek dalam definisi kontainer). Ini karena `FLUENT_HOST` merupakan alamat IP dinamis dan dapat berubah setelah restart. Logging langsung dari wadah aplikasi ke alamat `FLUENT_HOST` IP dapat mulai gagal setelah alamat berubah. Untuk informasi selengkapnya tentang `FLUENT_HOST`, lihat [Mengkonfigurasi log Amazon ECS untuk throughput tinggi](firelens-docker-buffer-limit.md).
+ Agen Amazon ECS menangani kebijakan restart kontainer. Jika karena alasan yang tidak terduga agen Amazon ECS gagal atau tidak lagi berjalan, penampung tidak akan dimulai ulang.
+  Periode percobaan restart yang ditentukan dalam kebijakan Anda menentukan periode waktu (dalam detik) penampung harus dijalankan sebelum Amazon ECS memulai ulang penampung.

# Menentukan kebijakan restart container dalam definisi tugas Amazon ECS
<a name="container-restart-policy-example"></a>

Untuk menentukan kebijakan restart untuk container dalam definisi tugas, dalam definisi container, tentukan `restartPolicy` objek. Untuk informasi lebih lanjut tentang objek `restartPolicy`, lihat [Kebijakan Mulai Ulang](task_definition_parameters.md#container_definition_restart_policy).

Berikut ini adalah definisi tugas menggunakan wadah Linux di Fargate yang mengatur server web. Definisi kontainer menyertakan `restartPolicy` objek, dengan `enabled` disetel ke true untuk mengaktifkan kebijakan restart untuk penampung. Wadah harus berjalan selama 180 detik sebelum dapat dimulai ulang dan tidak akan dimulai ulang jika keluar dengan kode `0` keluar, yang menunjukkan keberhasilan.

```
{
  "containerDefinitions": [
    {
      "command": [
        "/bin/sh -c \"echo '<html> <head> <title>Amazon ECS Sample App</title> <style>body {margin-top: 40px; background-color: #333;} </style> </head><body> <div style=color:white;text-align:center> <h1>Amazon ECS Sample App</h1> <h2>Congratulations!</h2> <p>Your application is now running on a container in Amazon ECS.</p> </div></body></html>' >  /usr/local/apache2/htdocs/index.html && httpd-foreground\""
      ],
      "entryPoint": ["sh", "-c"],
      "essential": true,
      "image": "public.ecr.aws/docker/library/httpd:2.4",
      "logConfiguration": {
        "logDriver": "awslogs",
        "options": {
          "awslogs-group": "/ecs/fargate-task-definition",
          "awslogs-region": "us-east-1",
          "awslogs-stream-prefix": "ecs"
        }
      },
      "name": "sample-fargate-app",
      "portMappings": [
        {
          "containerPort": 80,
          "hostPort": 80,
          "protocol": "tcp"
        }
      ],
      "restartPolicy": {
        "enabled": true,
        "ignoredExitCodes": [0],
        "restartAttemptPeriod": 180
      }
    }
  ],
  "cpu": "256",
  "executionRoleArn": "arn:aws:iam::012345678910:role/ecsTaskExecutionRole",
  "family": "fargate-task-definition",
  "memory": "512",
  "networkMode": "awsvpc",
  "runtimePlatform": {
    "operatingSystemFamily": "LINUX"
  },
  "requiresCompatibilities": ["FARGATE"]
}
```

Setelah Anda mendaftarkan definisi tugas dengan `restartPolicy` objek dalam definisi kontainer, Anda dapat menjalankan tugas atau membuat layanan dengan definisi tugas tersebut. Untuk informasi selengkapnya, lihat [Menjalankan aplikasi sebagai tugas Amazon ECS](standalone-task-create.md) dan [Membuat penyebaran pembaruan bergulir Amazon ECS](create-service-console-v2.md).

# Meneruskan data sensitif ke wadah Amazon ECS
<a name="specifying-sensitive-data"></a>

Anda dapat meneruskan data sensitif dengan aman, seperti kredensi ke database, ke dalam wadah Anda. 

Rahasia, seperti kunci API dan kredensyal basis data, sering digunakan oleh aplikasi untuk mendapatkan akses sistem lain. Mereka sering terdiri dari nama pengguna dan kata sandi, sertifikat, atau kunci API. Akses ke rahasia ini harus dibatasi pada prinsipal IAM tertentu yang menggunakan IAM dan disuntikkan ke dalam wadah saat runtime.

Rahasia dapat disuntikkan dengan mulus ke dalam wadah dari AWS Secrets Manager dan Amazon EC2 Systems Manager Parameter Store. Rahasia-rahasia ini dapat direferensikan dalam tugas Anda sebagai salah satu dari berikut ini.

1. Mereka direferensikan sebagai variabel lingkungan yang menggunakan parameter definisi `secrets` kontainer.

1. Mereka direferensikan `secretOptions` seolah-olah platform logging Anda memerlukan otentikasi. Untuk informasi selengkapnya, lihat [opsi konfigurasi logging](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_LogConfiguration.html#API_LogConfiguration_Contents).

1. Mereka direferensikan sebagai rahasia yang ditarik oleh gambar yang menggunakan parameter definisi `repositoryCredentials` wadah jika registri tempat penampung ditarik memerlukan otentikasi. Gunakan metode ini saat menarik gambar dari Galeri Publik Amazon ECR. Untuk informasi selengkapnya, lihat [Autentikasi registri pribadi untuk tugas](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/private-auth.html).

Kami menyarankan Anda melakukan hal berikut saat mengatur manajemen rahasia.

## Gunakan AWS Secrets Manager atau AWS Systems Manager Parameter Menyimpan untuk menyimpan materi rahasia
<a name="security-secrets-management-recommendations-storing-secret-materials"></a>

Anda harus menyimpan kunci API, kredensyal database, dan materi rahasia lainnya dengan aman di Secrets Manager atau sebagai parameter terenkripsi di Systems Manager Parameter Store. Layanan ini serupa karena keduanya merupakan penyimpanan nilai kunci terkelola yang digunakan AWS KMS untuk mengenkripsi data sensitif. Secrets Manager, bagaimanapun, juga mencakup kemampuan untuk secara otomatis memutar rahasia, menghasilkan rahasia acak, dan berbagi rahasia di seluruh akun. Untuk memanfaatkan fitur-fitur ini, gunakan Secrets Manager. Jika tidak, gunakan parameter terenkripsi di Systems Manager Parameter Store.

**penting**  
Jika rahasia Anda berubah, Anda harus memaksa penerapan baru atau meluncurkan tugas baru untuk mengambil nilai rahasia terbaru. Untuk informasi selengkapnya, lihat topik berikut:  
Tugas - Hentikan tugas, lalu mulailah. Untuk informasi selengkapnya, lihat [Menghentikan tugas Amazon ECS](standalone-task-stop.md) dan [Menjalankan aplikasi sebagai tugas Amazon ECS](standalone-task-create.md).
Layanan - Perbarui layanan dan gunakan opsi force new deployment. Untuk informasi selengkapnya, lihat [Memperbarui layanan Amazon ECS](update-service-console-v2.md).

## Mengambil data dari bucket Amazon S3 terenkripsi
<a name="security-secrets-management-recommendations-encrypted-s3-buckets"></a>

Anda harus menyimpan rahasia di bucket Amazon S3 terenkripsi dan menggunakan peran tugas untuk membatasi akses ke rahasia tersebut. Ini mencegah nilai variabel lingkungan bocor secara tidak sengaja di log dan terungkap saat dijalankan. `docker inspect` Ketika Anda melakukan ini, aplikasi Anda harus ditulis untuk membaca rahasia dari ember Amazon S3. Untuk petunjuknya, lihat [Menyetel perilaku enkripsi sisi server default untuk bucket Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucket-encryption.html).

## Pasang rahasia ke volume menggunakan wadah sespan
<a name="security-secrets-management-recommendations-mount-secret-volumes"></a>

Karena ada peningkatan risiko kebocoran data dengan variabel lingkungan, Anda harus menjalankan wadah sespan yang membaca rahasia Anda AWS Secrets Manager dan menuliskannya ke volume bersama. Kontainer ini dapat berjalan dan keluar sebelum penampung aplikasi dengan menggunakan [pemesanan kontainer Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ContainerDependency.html). Ketika Anda melakukan ini, wadah aplikasi kemudian memasang volume tempat rahasia itu ditulis. Seperti metode bucket Amazon S3, aplikasi Anda harus ditulis untuk membaca rahasia dari volume bersama. Karena volume tercakup pada tugas, volume secara otomatis dihapus setelah tugas berhenti. Sebagai contoh, lihat proyek [task-def.json](https://github.com/aws-samples/aws-secret-sidecar-injector/blob/master/ecs-task-def/task-def.json).

Di Amazon EC2, volume tempat rahasia ditulis dapat dienkripsi dengan kunci yang AWS KMS dikelola pelanggan. AWS Fargate Aktif, penyimpanan volume secara otomatis dienkripsi menggunakan kunci yang dikelola layanan. 

# Meneruskan variabel lingkungan individual ke wadah Amazon ECS
<a name="taskdef-envfiles"></a>

**penting**  
Sebaiknya simpan data sensitif Anda baik dalam parameter AWS Secrets Manager rahasia atau AWS Systems Manager Parameter Store. Untuk informasi selengkapnya, lihat [Meneruskan data sensitif ke wadah Amazon ECS](specifying-sensitive-data.md).  
Variabel lingkungan yang ditentukan dalam definisi tugas dapat dibaca oleh semua pengguna dan peran yang diizinkan `DescribeTaskDefinition` tindakan untuk definisi tugas.

Anda dapat meneruskan variabel lingkungan ke kontainer Anda dengan cara berikut:
+ Secara individual menggunakan parameter ketentuan kontainer `environment`. Ini memetakan ke `--env` opsi untuk [https://docs.docker.com/reference/cli/docker/container/run/](https://docs.docker.com/reference/cli/docker/container/run/).
+ Secara massal, menggunakan parameter definisi `environmentFiles` kontainer untuk mencantumkan satu atau lebih file yang berisi variabel lingkungan. File harus di-host di Amazon S3. Ini memetakan ke `--env-file` opsi untuk [https://docs.docker.com/reference/cli/docker/container/run/](https://docs.docker.com/reference/cli/docker/container/run/).

Berikut ini adalah potongan ketentuan tugas yang menunjukkan cara menentukan variabel lingkungan individual.

```
{
    "family": "",
    "containerDefinitions": [
        {
            "name": "",
            "image": "",
            ...
            "environment": [
                {
                    "name": "variable",
                    "value": "value"
                }
            ],
            ...
        }
    ],
    ...
}
```

# Meneruskan variabel lingkungan ke wadah Amazon ECS
<a name="use-environment-file"></a>

**penting**  
Sebaiknya simpan data sensitif Anda baik dalam parameter AWS Secrets Manager rahasia atau AWS Systems Manager Parameter Store. Untuk informasi selengkapnya, lihat [Meneruskan data sensitif ke wadah Amazon ECS](specifying-sensitive-data.md).  
File variabel lingkungan adalah objek di Amazon S3 dan semua pertimbangan keamanan Amazon S3 berlaku.   
Anda tidak dapat menggunakan `environmentFiles` parameter pada wadah Windows dan wadah Windows di Fargate.

Anda dapat membuat file variabel lingkungan dan menyimpannya di Amazon S3 untuk meneruskan variabel lingkungan ke wadah Anda.

Dengan menentukan variabel lingkungan dalam file, Anda dapat menyuntikkan variabel lingkungan secara massal. Dalam definisi container Anda, tentukan `environmentFiles` objek dengan daftar bucket Amazon S3 yang berisi file variabel lingkungan Anda.

Amazon ECS tidak memberlakukan batas ukuran pada variabel lingkungan, tetapi file variabel lingkungan yang besar mungkin mengisi ruang disk. Setiap tugas yang menggunakan file variabel lingkungan menyebabkan salinan file diunduh ke disk. Amazon ECS menghapus file sebagai bagian dari pembersihan tugas.

Untuk informasi tentang variabel lingkungan yang didukung, lihat [Parameter definisi kontainer lanjutan- Lingkungan](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html#container_definition_environment).

Pertimbangkan hal berikut saat menentukan file variabel lingkungan dalam definisi wadah.
+ Untuk tugas Amazon ECS di Amazon EC2, instans penampung Anda mengharuskan agen penampung adalah `1.39.0` versi atau yang lebih baru untuk menggunakan fitur ini. Untuk informasi tentang cara memeriksa versi agen Anda dan memperbarui ke versi terbaru, lihat[Memperbarui agen kontainer Amazon ECS](ecs-agent-update.md).
+ Untuk tugas Amazon ECS di AWS Fargate, tugas Anda harus menggunakan `1.4.0` versi platform atau yang lebih baru (Linux) untuk menggunakan fitur ini. Untuk informasi selengkapnya, lihat [Versi platform Fargate untuk Amazon ECS](platform-fargate.md).

  Verifikasi bahwa variabel didukung untuk platform sistem operasi. Untuk informasi selengkapnya, lihat [Definisi kontainer](task_definition_parameters.md#container_definitions) dan [Parameter ketentuan tugas lainnya](task_definition_parameters.md#other_task_definition_params).
+ File harus menggunakan ekstensi file `.env` dan pengodean UTF-8.
+ Peran eksekusi tugas diperlukan untuk menggunakan fitur ini dengan izin tambahan untuk Amazon S3. Ini memungkinkan agen penampung untuk menarik file variabel lingkungan dari Amazon S3. Untuk informasi selengkapnya, lihat [Peran IAM pelaksanaan tugas Amazon ECS](task_execution_IAM_role.md).
+ Ada batas 10 file per definisi tugas.
+ Setiap baris dalam file lingkungan harus berisi variabel lingkungan dalam `VARIABLE=VALUE` format. Spasi atau tanda kutip **disertakan** sebagai bagian dari nilai untuk file Amazon ECS. Baris yang diawali dengan `#` diperlakukan sebagai komentar dan diabaikan. Untuk informasi selengkapnya tentang sintaks file variabel lingkungan, lihat [Mengatur variabel lingkungan (-e, --env, --env-file](https://docs.docker.com/reference/cli/docker/container/run/#env)) dalam dokumentasi. Docker

  Berikut ini adalah sintaks yang sesuai.

  ```
  #This is a comment and will be ignored
  VARIABLE=VALUE
  ENVIRONMENT=PRODUCTION
  ```
+ Jika ada variabel lingkungan yang ditentukan menggunakan parameter `environment` dalam ketentuan kontainer, maka akan lebih diutamakan daripada variabel yang terkandung dalam file lingkungan.
+ Jika beberapa file lingkungan ditentukan dan mereka berisi variabel yang sama, mereka diproses dalam urutan entri. Ini berarti bahwa nilai pertama dari variabel digunakan dan nilai-nilai berikutnya dari variabel duplikat diabaikan. Kami merekomendasikan agar Anda menggunakan nama variabel yang unik.
+ Jika file lingkungan ditentukan sebagai penimpaan kontainer, itu digunakan. Selain itu, file lingkungan lain yang ditentukan dalam definisi wadah diabaikan.
+ Aturan berikut berlaku untuk Fargate:
  + File ini ditangani mirip dengan env-file Docker asli.
  + Definisi kontainer yang mereferensikan variabel lingkungan yang kosong dan disimpan di Amazon S3 tidak muncul di wadah.
  + Tidak ada dukungan untuk penanganan pelarian shell.
  + Titik masuk kontainer menyelingi nilai-nilai. `VARIABLE`

## Contoh
<a name="environment-file-example"></a>

Berikut ini adalah potongan ketentuan tugas yang menunjukkan cara menentukan file variabel lingkungan.

```
{
    "family": "",
    "containerDefinitions": [
        {
            "name": "",
            "image": "",
            ...
            "environmentFiles": [
                {
                    "value": "arn:aws:s3:::amzn-s3-demo-bucket/envfile_object_name.env",
                    "type": "s3"
                }
            ],
            ...
        }
    ],
    ...
}
```

# Lulus rahasia Secrets Manager secara terprogram di Amazon ECS
<a name="secrets-app-secrets-manager"></a>

Alih-alih hardcoding informasi sensitif dalam teks biasa di aplikasi Anda, Anda dapat menggunakan Secrets Manager untuk menyimpan data sensitif.

Kami merekomendasikan metode ini untuk mengambil data sensitif karena jika rahasia Secrets Manager kemudian diperbarui, aplikasi secara otomatis mengambil versi terbaru dari rahasia.

Buat rahasia di Secrets Manager. Setelah Anda membuat rahasia Secrets Manager, perbarui kode aplikasi Anda untuk mengambil rahasia.

Tinjau pertimbangan berikut sebelum mengamankan data sensitif di Secrets Manager.
+ Hanya rahasia yang menyimpan data teks, yang merupakan rahasia yang dibuat dengan `SecretString` parameter [CreateSecret](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_CreateSecret.html)API, yang didukung. Rahasia yang menyimpan data biner, yang merupakan rahasia yang dibuat dengan `SecretBinary` parameter [CreateSecret](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_CreateSecret.html)API tidak didukung.
+ Gunakan titik akhir VPC antarmuka untuk meningkatkan kontrol keamanan. Anda harus membuat titik akhir VPC antarmuka untuk Secrets Manager. *Untuk informasi tentang titik akhir VPC, lihat Membuat titik akhir [VPC di Panduan Pengguna](https://docs.aws.amazon.com/secretsmanager/latest/userguide/setup-create-vpc.html).AWS Secrets Manager *
+ VPC yang digunakan tugas Anda harus menggunakan resolusi DNS.
+ Definisi tugas Anda harus menggunakan peran tugas dengan izin tambahan untuk Secrets Manager. Untuk informasi selengkapnya, lihat [Peran IAM tugas Amazon ECS](task-iam-roles.md).

## Buat rahasia Secrets Manager
<a name="secrets-app-secrets-manager-create-secret"></a>

Anda dapat menggunakan konsol Secrets Manager untuk membuat rahasia untuk data sensitif Anda. Untuk informasi tentang cara membuat rahasia, lihat [Membuat AWS Secrets Manager rahasia](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html) di *Panduan AWS Secrets Manager Pengguna*.

## Perbarui aplikasi Anda untuk mengambil rahasia Secrets Manager secara terprogram
<a name="secrets-app-secrets-manager-update-app"></a>

Anda dapat mengambil rahasia dengan panggilan ke Secrets Manager APIs langsung dari aplikasi Anda. Untuk selengkapnya, lihat [Mengambil rahasia dari AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/retrieving-secrets.html) *Panduan AWS Secrets Manager Pengguna*.

Untuk mengambil data sensitif yang disimpan di dalam AWS Secrets Manager, lihat [Contoh kode untuk AWS Secrets Manager digunakan AWS SDKs di Pustaka](https://docs.aws.amazon.com/code-library/latest/ug/secrets-manager_code_examples.html) *Kode Contoh Kode AWS SDK*.

# Pass Systems Manager Parameter Simpan rahasia secara terprogram di Amazon ECS
<a name="secrets-app-ssm-paramstore"></a>

Systems Manager Parameter Store menyediakan penyimpanan dan pengelolaan rahasia yang aman. Anda dapat menyimpan data seperti password, string database, instans EC2 dan IDs AMI IDs, dan kode lisensi sebagai nilai parameter, bukan hardcoding informasi ini dalam aplikasi Anda. Anda dapat menyimpan nilai sebagai teks biasa atau data terenkripsi.

Kami merekomendasikan metode ini untuk mengambil data sensitif karena jika parameter Systems Manager Parameter Store kemudian diperbarui, aplikasi secara otomatis mengambil versi terbaru.

Tinjau pertimbangan berikut sebelum mengamankan data sensitif di Systems Manager Parameter Store.
+ Hanya rahasia yang menyimpan data teks yang didukung. Rahasia yang menyimpan data biner tidak didukung.
+ Gunakan titik akhir VPC antarmuka untuk meningkatkan kontrol keamanan.
+ VPC yang digunakan tugas Anda harus menggunakan resolusi DNS.
+ Untuk tugas yang menggunakan EC2, Anda harus menggunakan variabel konfigurasi agen Amazon ECS `ECS_ENABLE_AWSLOGS_EXECUTIONROLE_OVERRIDE=true` untuk menggunakan fitur ini. Anda dapat menambahkannya ke file `/etc/ecs/ecs.config` selama pembuatan instans kontainer atau Anda dapat menambahkannya ke instans yang ada, lalu memulai ulang agen ECS. Untuk informasi selengkapnya, lihat [Konfigurasi agen kontainer Amazon ECS](ecs-agent-config.md).
+ Definisi tugas Anda harus menggunakan peran tugas dengan izin tambahan untuk Systems Manager Parameter Store. Untuk informasi selengkapnya, lihat [Peran IAM tugas Amazon ECS](task-iam-roles.md).

## Buat parameter
<a name="secrets-app-ssm-paramstore-create-secret"></a>

Anda dapat menggunakan konsol Systems Manager untuk membuat parameter Systems Manager Parameter Store untuk data sensitif Anda. Untuk informasi selengkapnya, lihat [Membuat parameter Systems Manager (konsol)](https://docs.aws.amazon.com/systems-manager/latest/userguide/parameter-create-console.html) atau [Membuat parameter Systems Manager (AWS CLI)](https://docs.aws.amazon.com/systems-manager/latest/userguide/param-create-cli.html) di *Panduan AWS Systems Manager Pengguna*.

## Perbarui aplikasi Anda untuk mengambil rahasia Systems Manager Parameter Store secara terprogram
<a name="secrets-app-ssm-paramstore-update-app"></a>

Untuk mengambil data sensitif yang disimpan dalam parameter Systems Manager Parameter Store, lihat [Contoh kode untuk Systems Manager yang digunakan AWS SDKs](https://docs.aws.amazon.com/code-library/latest/ug/ssm_code_examples.html) di *AWS SDK Code Examples Code Library*.

# Lulus rahasia Secrets Manager melalui variabel lingkungan Amazon ECS
<a name="secrets-envvar-secrets-manager"></a>

Ketika Anda menyuntikkan rahasia sebagai variabel lingkungan, Anda dapat menentukan isi lengkap rahasia, kunci JSON tertentu dalam rahasia. Hal ini membantu Anda mengontrol data sensitif yang diekspos ke kontainer Anda. Untuk informasi selengkapnya tentang pembuatan versi rahasia, lihat [Apa yang ada di rahasia Secrets Manager?](https://docs.aws.amazon.com/secretsmanager/latest/userguide/whats-in-a-secret.html#term_version) dalam *AWS Secrets Manager User Guide*.

Berikut ini harus dipertimbangkan saat menggunakan variabel lingkungan untuk menyuntikkan rahasia Secrets Manager ke dalam wadah.
+ Data sensitif disuntikkan ke dalam kontainer Anda ketika kontainer awalnya dimulai. Jika rahasia kemudian diperbarui atau diputar, kontainer tidak akan menerima nilai yang diperbarui secara otomatis. Anda harus menjalankan tugas baru atau jika tugas Anda adalah bagian dari layanan Anda dapat memperbarui layanan dan menggunakan **Memaksa deployment baru** untuk memaksa layanan untuk meluncurkan tugas baru.
+ Aplikasi yang berjalan pada container dan container log dan debugging tools memiliki akses ke variabel lingkungan.
+ Untuk tugas Amazon ECS aktif AWS Fargate, pertimbangkan hal berikut:
  + Untuk menyuntikkan konten penuh rahasia sebagai variabel lingkungan atau dalam konfigurasi log, Anda harus menggunakan versi `1.3.0` platform atau yang lebih baru. Untuk informasi, lihat [Versi platform Fargate untuk Amazon ECS](platform-fargate.md).
  + Untuk menyuntikkan kunci JSON tertentu atau versi rahasia sebagai variabel lingkungan atau dalam konfigurasi log, Anda harus menggunakan versi platform `1.4.0` atau yang lebih baru (Linux) atau `1.0.0` (Windows). Untuk informasi, lihat [Versi platform Fargate untuk Amazon ECS](platform-fargate.md).
+ Untuk tugas Amazon ECS di EC2, hal-hal berikut harus dipertimbangkan:
  + Untuk menyuntikkan rahasia menggunakan kunci JSON atau versi rahasia tertentu, instans kontainer Anda harus memiliki versi `1.37.0` agen kontainer atau yang lebih baru. Namun, kami merekomendasikan untuk menggunakan versi agen kontainer terbaru. Untuk informasi tentang memeriksa versi agen Anda dan memperbarui ke versi terbaru, lihat [Memperbarui agen kontainer Amazon ECS](ecs-agent-update.md).

    Untuk menyuntikkan konten penuh rahasia sebagai variabel lingkungan atau untuk menyuntikkan rahasia dalam konfigurasi log, instans kontainer Anda harus memiliki versi `1.22.0` agen kontainer atau yang lebih baru.
+ Gunakan titik akhir VPC antarmuka untuk meningkatkan kontrol keamanan dan terhubung ke Secrets Manager melalui subnet pribadi. Anda harus membuat titik akhir VPC antarmuka untuk Secrets Manager. *Untuk informasi tentang titik akhir VPC, lihat Membuat titik akhir [VPC di Panduan Pengguna](https://docs.aws.amazon.com/secretsmanager/latest/userguide/setup-create-vpc.html).AWS Secrets Manager * Untuk informasi selengkapnya tentang menggunakan Secrets Manager dan Amazon VPC, lihat [Cara menyambung ke layanan Secrets Manager dalam Amazon VPC](https://aws.amazon.com/blogs//security/how-to-connect-to-aws-secrets-manager-service-within-a-virtual-private-cloud/).
+ Untuk tugas Windows yang dikonfigurasi untuk menggunakan driver pencatatan `awslogs`, Anda juga harus mengatur variabel lingkungan `ECS_ENABLE_AWSLOGS_EXECUTIONROLE_OVERRIDE` pada instans kontainer Anda. Gunakan sintaks berikut:

  ```
  <powershell>
  [Environment]::SetEnvironmentVariable("ECS_ENABLE_AWSLOGS_EXECUTIONROLE_OVERRIDE", $TRUE, "Machine")
  Initialize-ECSAgent -Cluster <cluster name> -EnableTaskIAMRole -LoggingDrivers '["json-file","awslogs"]'
  </powershell>
  ```
+ Definisi tugas Anda harus menggunakan peran eksekusi tugas dengan izin tambahan untuk Secrets Manager. Untuk informasi selengkapnya, lihat [Peran IAM pelaksanaan tugas Amazon ECS](task_execution_IAM_role.md).

## Buat AWS Secrets Manager rahasianya
<a name="secrets-envvar-secrets-manager-create-secret"></a>

Anda dapat menggunakan konsol Secrets Manager untuk membuat rahasia untuk data sensitif Anda. Untuk informasi selengkapnya, lihat [Membuat AWS Secrets Manager rahasia](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html) di *Panduan AWS Secrets Manager Pengguna*.

## Tambahkan variabel lingkungan ke definisi wadah
<a name="secrets-envvar-secrets-manager-update-container-definition"></a>

Dalam ketentuan kontainer Anda, Anda dapat menentukan hal berikut:
+ Objek `secrets` yang berisi nama variabel lingkungan untuk diatur dalam kontainer
+ Amazon Resource Name (ARN) rahasia Secrets Manager
+ Parameter tambahan yang berisi data sensitif untuk hadir ke kontainer

Contoh berikut menunjukkan sintaks lengkap yang harus ditentukan untuk rahasia Secrets Manager.

```
arn:aws:secretsmanager:region:aws_account_id:secret:secret-name:json-key:version-stage:version-id
```

Bagian berikut menjelaskan parameter tambahan. Parameter ini opsional, tetapi jika Anda tidak menggunakannya, Anda harus menyertakan titik dua `:` untuk menggunakan nilai default. Contoh disediakan di bawah ini untuk konteks yang lebih.

`json-key`  
Menentukan nama kunci dalam pasangan kunci-nilai dengan nilai yang ingin Anda tetapkan sebagai nilai variabel lingkungan. Hanya nilai dalam format JSON yang didukung. Jika Anda tidak menentukan kunci JSON, maka konten penuh dari rahasia tersebut akan digunakan.

`version-stage`  
Menentukan label pementasan versi rahasia yang ingin Anda gunakan. Jika label pementasan versi ditentukan, Anda tidak dapat menentukan ID versi. Jika tidak ada tahap versi yang ditentukan, perilaku default adalah untuk mengambil rahasia dengan label pementasan `AWSCURRENT`.  
Label tahapan digunakan untuk melacak berbagai versi rahasia saat diperbarui atau dirotasi. Setiap versi rahasia memiliki satu atau beberapa label tahapan dan satu ID.

`version-id`  
Menentukan pengenal unik dari versi rahasia yang ingin Anda gunakan. Jika ID versi ditentukan, Anda tidak dapat menentukan label pementasan versi. Jika tidak ada ID versi yang ditentukan, perilaku default adalah untuk mengambil rahasia dengan label pementasan `AWSCURRENT`.  
Versi IDs digunakan untuk melacak versi rahasia yang berbeda ketika mereka diperbarui atau diputar. Setiap versi rahasia memiliki satu ID. Untuk informasi selengkapnya, lihat [Syarat dan Konsep Utama AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/terms-concepts.html#term_secret) di *Panduan AWS Secrets Manager Pengguna*.

### Contoh ketentuan kontainer
<a name="secrets-examples"></a>

Contoh berikut menunjukkan cara Anda dapat mereferensikan rahasia Secrets Manager dalam definisi container Anda.

**Example mereferensikan rahasia penuh**  
Berikut ini adalah cuplikan ketentuan tugas yang menunjukkan format ketika mereferensikan teks lengkap dari rahasia Secrets Manager.  

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:secret_name-AbCdEf"
    }]
  }]
}
```
Untuk mengakses nilai rahasia ini dari dalam wadah, Anda perlu memanggil file`$environment_variable_name`.

**Example mereferensikan rahasia lengkap**  
Berikut ini adalah cuplikan definisi tugas yang menunjukkan format saat mereferensikan teks lengkap dari beberapa rahasia Secrets Manager.  

```
{
  "containerDefinitions": [{
     "secrets": [
      {
        "name": "environment_variable_name1",
         "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:secret_name-AbCdEf"
      },
      {
        "name": "environment_variable_name2",
         "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:secret_name-abcdef"
      },
      {
        "name": "environment_variable_name3",
        "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:secret_name-ABCDEF"
      }
    ]
  }]
}
```
Untuk mengakses nilai rahasia ini dari dalam wadah, Anda perlu memanggil`$environment_variable_name1`,`$environment_variable_name2`, dan`$environment_variable_name3`.

**Example mereferensikan kunci tertentu dalam sebuah rahasia**  
Berikut ini menunjukkan contoh output dari [get-secret-value](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/get-secret-value.html)perintah yang menampilkan isi rahasia bersama dengan label pementasan versi dan ID versi yang terkait dengannya.  

```
{
    "ARN": "arn:aws:secretsmanager:region:aws_account_id:secret:appauthexample-AbCdEf",
    "Name": "appauthexample",
    "VersionId": "871d9eca-18aa-46a9-8785-981ddEXAMPLE",
    "SecretString": "{\"username1\":\"password1\",\"username2\":\"password2\",\"username3\":\"password3\"}",
    "VersionStages": [
        "AWSCURRENT"
    ],
    "CreatedDate": 1581968848.921
}
```
Referensikan kunci tertentu dari output sebelumnya dalam ketentuan kontainer dengan menentukan nama kunci di akhir ARN.  

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:appauthexample-AbCdEf:username1::"
    }]
  }]
}
```

**Example mereferensikan versi rahasia tertentu**  
Berikut ini menunjukkan contoh output dari perintah [describe-secret](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/describe-secret.html) yang menampilkan konten rahasia yang tidak terenkripsi bersama dengan metadata untuk semua versi rahasia.  

```
{
    "ARN": "arn:aws:secretsmanager:region:aws_account_id:secret:appauthexample-AbCdEf",
    "Name": "appauthexample",
    "Description": "Example of a secret containing application authorization data.",
    "RotationEnabled": false,
    "LastChangedDate": 1581968848.926,
    "LastAccessedDate": 1581897600.0,
    "Tags": [],
    "VersionIdsToStages": {
        "871d9eca-18aa-46a9-8785-981ddEXAMPLE": [
            "AWSCURRENT"
        ],
        "9d4cb84b-ad69-40c0-a0ab-cead3EXAMPLE": [
            "AWSPREVIOUS"
        ]
    }
}
```
Referensikan label tahapan versi tertentu dari output sebelumnya dalam ketentuan kontainer dengan menentukan nama kunci di akhir ARN.  

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:appauthexample-AbCdEf::AWSPREVIOUS:"
    }]
  }]
}
```
Referensikan ID versi tertentu dari output sebelumnya dalam ketentuan kontainer dengan menentukan nama kunci di akhir ARN.  

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:appauthexample-AbCdEf:::9d4cb84b-ad69-40c0-a0ab-cead3EXAMPLE"
    }]
  }]
}
```

**Example mereferensikan kunci dan label tahapan versi tertentu dari suatu rahasia**  
Bagian berikut menunjukkan cara mereferensikan kunci tertentu dalam rahasia dan label tahapan versi tertentu.  

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:appauthexample-AbCdEf:username1:AWSPREVIOUS:"
    }]
  }]
}
```
Untuk menentukan kunci dan versi ID tertentu, gunakan sintaks berikut.  

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:appauthexample-AbCdEf:username1::9d4cb84b-ad69-40c0-a0ab-cead3EXAMPLE"
    }]
  }]
}
```

Untuk informasi tentang cara membuat definisi tugas dengan rahasia yang ditentukan dalam variabel lingkungan, lihat[Membuat definisi tugas Amazon ECS menggunakan konsol](create-task-definition.md). 

# Lulus parameter Systems Manager melalui variabel lingkungan Amazon ECS
<a name="secrets-envvar-ssm-paramstore"></a>

Amazon ECS memungkinkan Anda untuk menyuntikkan data sensitif ke dalam container Anda dengan menyimpan data sensitif Anda dalam AWS Systems Manager parameter Parameter Store dan kemudian mereferensikannya dalam definisi container Anda.

Pertimbangkan hal berikut saat menggunakan variabel lingkungan untuk menyuntikkan rahasia Systems Manager ke dalam wadah.
+ Data sensitif disuntikkan ke dalam kontainer Anda ketika kontainer awalnya dimulai. Jika rahasia kemudian diperbarui atau diputar, kontainer tidak akan menerima nilai yang diperbarui secara otomatis. Anda harus menjalankan tugas baru atau jika tugas Anda adalah bagian dari layanan Anda dapat memperbarui layanan dan menggunakan **Memaksa deployment baru** untuk memaksa layanan untuk meluncurkan tugas baru.
+ Untuk tugas Amazon ECS aktif AWS Fargate, hal-hal berikut harus dipertimbangkan:
  + Untuk menyuntikkan konten penuh rahasia sebagai variabel lingkungan atau dalam konfigurasi log, Anda harus menggunakan versi `1.3.0` platform atau yang lebih baru. Untuk informasi, lihat [Versi platform Fargate untuk Amazon ECS](platform-fargate.md).
  + Untuk menyuntikkan kunci JSON tertentu atau versi rahasia sebagai variabel lingkungan atau dalam konfigurasi log, Anda harus menggunakan versi platform `1.4.0` atau yang lebih baru (Linux) atau `1.0.0` (Windows). Untuk informasi, lihat [Versi platform Fargate untuk Amazon ECS](platform-fargate.md).
+ Untuk tugas Amazon ECS di EC2, hal-hal berikut harus dipertimbangkan:
  + Untuk menyuntikkan rahasia menggunakan kunci JSON atau versi rahasia tertentu, instans kontainer Anda harus memiliki versi `1.37.0` agen kontainer atau yang lebih baru. Namun, kami merekomendasikan untuk menggunakan versi agen kontainer terbaru. Untuk informasi tentang memeriksa versi agen Anda dan memperbarui ke versi terbaru, lihat [Memperbarui agen kontainer Amazon ECS](ecs-agent-update.md).

    Untuk menyuntikkan konten penuh rahasia sebagai variabel lingkungan atau untuk menyuntikkan rahasia dalam konfigurasi log, instans kontainer Anda harus memiliki versi `1.22.0` agen kontainer atau yang lebih baru.
+ Gunakan titik akhir VPC antarmuka untuk meningkatkan kontrol keamanan. Anda harus membuat titik akhir VPC antarmuka untuk Systems Manager. *Untuk informasi tentang titik akhir VPC, lihat [Meningkatkan keamanan instans EC2 dengan menggunakan titik akhir VPC untuk Systems](https://docs.aws.amazon.com/systems-manager/latest/userguide/setup-create-vpc.html) Manager di Panduan Pengguna.AWS Systems Manager *
+ Definisi tugas Anda harus menggunakan peran eksekusi tugas dengan izin tambahan untuk Systems Manager Parameter Store. Untuk informasi selengkapnya, lihat [Peran IAM pelaksanaan tugas Amazon ECS](task_execution_IAM_role.md).
+ Untuk tugas Windows yang dikonfigurasi untuk menggunakan driver pencatatan `awslogs`, Anda juga harus mengatur variabel lingkungan `ECS_ENABLE_AWSLOGS_EXECUTIONROLE_OVERRIDE` pada instans kontainer Anda. Gunakan sintaks berikut:

  ```
  <powershell>
  [Environment]::SetEnvironmentVariable("ECS_ENABLE_AWSLOGS_EXECUTIONROLE_OVERRIDE", $TRUE, "Machine")
  Initialize-ECSAgent -Cluster <cluster name> -EnableTaskIAMRole -LoggingDrivers '["json-file","awslogs"]'
  </powershell>
  ```

## Buat parameter Systems Manager
<a name="secrets-envvar-ssm-paramstore-create-parameter"></a>

Anda dapat menggunakan konsol Systems Manager untuk membuat parameter Systems Manager Parameter Store untuk data sensitif Anda. Untuk informasi selengkapnya, lihat [Membuat parameter Systems Manager (konsol)](https://docs.aws.amazon.com/systems-manager/latest/userguide/parameter-create-console.html) atau [Membuat parameter Systems Manager (AWS CLI)](https://docs.aws.amazon.com/systems-manager/latest/userguide/param-create-cli.html) di *Panduan AWS Systems Manager Pengguna*.

## Tambahkan variabel lingkungan ke definisi wadah
<a name="secrets-ssm-paramstore-update-container-definition"></a>

Dalam definisi kontainer Anda dalam definisi tugas, tentukan `secrets` dengan nama variabel lingkungan yang akan disetel dalam wadah dan ARN lengkap dari parameter Systems Manager Parameter Store yang berisi data sensitif yang akan ditampilkan ke wadah. Untuk informasi selengkapnya, lihat [secrets](task_definition_parameters.md#ContainerDefinition-secrets).

Berikut ini adalah cuplikan definisi tugas yang menunjukkan format saat mereferensikan parameter Systems Manager Parameter Store. Jika parameter Systems Manager Parameter Store ada di Region yang sama dengan tugas yang Anda luncurkan, maka Anda dapat menggunakan ARN lengkap atau nama parameter. Jika parameter ada di Wilayah yang berbeda, maka tentukan ARN lengkap.

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:ssm:region:aws_account_id:parameter/parameter_name"
    }]
  }]
}
```

Untuk informasi tentang cara membuat definisi tugas dengan rahasia yang ditentukan dalam variabel lingkungan, lihat[Membuat definisi tugas Amazon ECS menggunakan konsol](create-task-definition.md).

## Perbarui aplikasi Anda untuk mengambil rahasia Systems Manager Parameter Store secara terprogram
<a name="secrets-ssm-paramstore-update-app"></a>

Untuk mengambil data sensitif yang disimpan dalam parameter Systems Manager Parameter Store, lihat [Contoh kode untuk Systems Manager yang digunakan AWS SDKs](https://docs.aws.amazon.com/code-library/latest/ug/ssm_code_examples.html) di *AWS SDK Code Examples Code Library*.

# Lulus rahasia untuk konfigurasi logging Amazon ECS
<a name="secrets-logconfig"></a>

Anda dapat menggunakan `secretOptions` parameter `logConfiguration` untuk meneruskan data sensitif yang digunakan untuk logging.

Anda dapat menyimpan rahasia di Secrets Manager atau Systems Manager.

## Gunakan Secrets Manager
<a name="secrets-logconfig-secrets-manager"></a>

Dalam definisi kontainer Anda, saat menentukan a, `logConfiguration` Anda dapat menentukan `secretOptions` dengan nama opsi driver log untuk disetel dalam wadah dan ARN lengkap dari rahasia Secrets Manager yang berisi data sensitif untuk disajikan ke wadah. Untuk informasi selengkapnya tentang membuat rahasia, lihat [Membuat AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html).

Berikut ini adalah cuplikan definisi tugas yang menunjukkan format saat mereferensikan rahasia Secrets Manager.

```
{
  "containerDefinitions": [{
    "logConfiguration": [{
      "logDriver": "splunk",
      "options": {
        "splunk-url": "https://your_splunk_instance:8088"
      },
      "secretOptions": [{
        "name": "splunk-token",
        "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:secret_name-AbCdEf"
      }]
    }]
  }]
}
```

## Tambahkan variabel lingkungan ke definisi wadah
<a name="secrets-envvar-ssm-paramstore-update-container-definition"></a>

Dalam ketentuan kontainer Anda, tentukan `secrets` dengan nama variabel lingkungan yang akan ditetapkan dalam kontainer dan ARN lengkap parameter Systems Manager Parameter Store yang berisi data sensitif untuk diberikan ke kontainer. Untuk informasi selengkapnya, lihat [secrets](task_definition_parameters.md#ContainerDefinition-secrets).

Berikut ini adalah cuplikan definisi tugas yang menunjukkan format saat mereferensikan parameter Systems Manager Parameter Store. Jika parameter Systems Manager Parameter Store ada di Region yang sama dengan tugas yang Anda luncurkan, maka Anda dapat menggunakan ARN lengkap atau nama parameter. Jika parameter ada di Wilayah yang berbeda, maka tentukan ARN lengkap.

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:ssm:region:aws_account_id:parameter/parameter_name"
    }]
  }]
}
```

Untuk informasi tentang cara membuat definisi tugas dengan rahasia yang ditentukan dalam variabel lingkungan, lihat[Membuat definisi tugas Amazon ECS menggunakan konsol](create-task-definition.md).

## Gunakan Systems Manager
<a name="secrets-logconfig-ssm-paramstore"></a>

Anda dapat menyuntikkan data sensitif dalam konfigurasi log. Dalam ketentuan kontainer Anda, ketika menentukan `logConfiguration`, Anda dapat menentukan `secretOptions` dengan nama opsi driver log yang kan ditetapkan dalam kontainer dan ARN lengkap parameter Systems Manager Parameter Store yang berisi data sensitif untuk diberikan ke kontainer.

**penting**  
Jika parameter Systems Manager Parameter Store ada di Region yang sama dengan tugas yang Anda luncurkan, maka Anda dapat menggunakan ARN lengkap atau nama parameter. Jika parameter ada di Wilayah yang berbeda, maka tentukan ARN lengkap.

Berikut ini adalah cuplikan definisi tugas yang menunjukkan format saat mereferensikan parameter Systems Manager Parameter Store.

```
{
  "containerDefinitions": [{
    "logConfiguration": [{
      "logDriver": "fluentd",
      "options": {
        "tag": "fluentd demo"
      },
      "secretOptions": [{
        "name": "fluentd-address",
        "valueFrom": "arn:aws:ssm:region:aws_account_id:parameter:/parameter_name"
      }]
    }]
  }]
}
```

# Menentukan data sensitif menggunakan rahasia Secrets Manager di Amazon ECS
<a name="specifying-sensitive-data-tutorial"></a>

Amazon ECS memungkinkan Anda untuk menyuntikkan data sensitif ke dalam container Anda dengan menyimpan data sensitif Anda dalam AWS Secrets Manager rahasia dan kemudian mereferensikannya dalam definisi container Anda. Untuk informasi selengkapnya, lihat [Meneruskan data sensitif ke wadah Amazon ECS](specifying-sensitive-data.md).

Pelajari cara membuat rahasia Secrets Manager, mereferensikan rahasia dalam definisi tugas Amazon ECS, lalu verifikasi itu berhasil dengan menanyakan variabel lingkungan di dalam wadah yang menunjukkan konten rahasia.

## Prasyarat
<a name="specifying-sensitive-data-tutorial-prereqs"></a>

Jika mengikuti tutorial ini, berarti prasyarat berikut telah selesai:
+ Langkah-langkah di [Siapkan untuk menggunakan Amazon ECS](get-set-up-for-amazon-ecs.md) telah selesai.
+ Pengguna Anda memiliki izin IAM yang diperlukan untuk membuat Secrets Manager dan sumber daya Amazon ECS.

## Langkah 1: Buat rahasia Secrets Manager
<a name="specifying-sensitive-data-tutorial-create-secret"></a>

Anda dapat menggunakan konsol Secrets Manager untuk membuat rahasia untuk data sensitif Anda. Dalam tutorial ini kita akan menciptakan rahasia dasar untuk menyimpan nama pengguna dan kata sandi untuk mereferensi nanti dalam sebuah kontainer. Untuk informasi selengkapnya, lihat [Membuat AWS Secrets Manager rahasia](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html) di *Panduan AWS Secrets Manager Pengguna*.

** key/value Pasangan yang akan disimpan dalam rahasia ini** adalah nilai variabel lingkungan dalam wadah Anda di akhir tutorial.

Simpan **ARN Rahasia** untuk referensi dalam kebijakan IAM eksekusi tugas Anda dan definisi tugas di langkah selanjutnya.

## Langkah 2: Tambahkan izin rahasia ke peran eksekusi tugas
<a name="specifying-sensitive-data-tutorial-update-iam"></a>

Agar Amazon ECS dapat mengambil data sensitif dari rahasia Secrets Manager Anda, Anda harus memiliki izin rahasia untuk peran eksekusi tugas. Untuk informasi selengkapnya, lihat [Izin Secrets Manager atau Systems Manager](task_execution_IAM_role.md#task-execution-secrets).

## Langkah 3: Membuat sebuah penetapan tugas
<a name="specifying-sensitive-data-tutorial-create-taskdef"></a>

Anda dapat menggunakan konsol Amazon ECS untuk membuat definisi tugas yang mereferensikan rahasia Secrets Manager.

**Untuk membuat ketentuan tugas yang menetapkan rahasia**

Gunakan konsol IAM untuk memperbarui peran eksekusi tugas Anda dengan izin yang diperlukan.

1. Buka konsol di [https://console.aws.amazon.com/ecs/v2](https://console.aws.amazon.com/ecs/v2).

1. Di panel navigasi, pilih **Definisi tugas**.

1. Pilih **Buat definisi tugas baru**, **Buat definisi tugas baru dengan JSON**.

1. Di kotak editor JSON, masukkan teks JSON definisi tugas berikut, pastikan Anda menentukan ARN lengkap rahasia Secrets Manager yang Anda buat di langkah 1 dan peran eksekusi tugas yang Anda perbarui di langkah 2. Pilih **Simpan**.

1. 

   ```
   {
       "executionRoleArn": "arn:aws:iam::aws_account_id:role/ecsTaskExecutionRole",
       "containerDefinitions": [
           {
               "entryPoint": [
                   "sh",
                   "-c"
               ],
               "portMappings": [
                   {
                       "hostPort": 80,
                       "protocol": "tcp",
                       "containerPort": 80
                   }
               ],
               "command": [
                   "/bin/sh -c \"echo '<html> <head> <title>Amazon ECS Sample App</title> <style>body {margin-top: 40px; background-color: #333;} </style> </head><body> <div style=color:white;text-align:center> <h1>Amazon ECS Sample App</h1> <h2>Congratulations!</h2> <p>Your application is now running on a container in Amazon ECS.</p> </div></body></html>' >  /usr/local/apache2/htdocs/index.html && httpd-foreground\""
               ],
               "cpu": 10,
               "secrets": [
                   {
                       "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:username_value",
                       "name": "username_value"
                   }
               ],
               "memory": 300,
               "image": "public.ecr.aws/docker/library/httpd:2.4",
               "essential": true,
               "name": "ecs-secrets-container"
           }
       ],
       "family": "ecs-secrets-tutorial"
   }
   ```

1. Pilih **Buat**.

## Langkah 4: Buat cluster
<a name="specifying-sensitive-data-tutorial-create-cluster"></a>

Anda dapat menggunakan konsol Amazon ECS untuk membuat klaster yang berisi instance container untuk menjalankan tugas. Jika Anda memiliki klaster yang ada dengan setidaknya satu instans kontainer yang terdaftar untuk itu dengan sumber daya yang tersedia untuk menjalankan satu instans dari ketentuan tugas yang dibuat untuk tutorial ini Anda dapat melompat ke langkah berikutnya.

Untuk tutorial ini kita akan membuat cluster dengan satu instance `t2.micro` container menggunakan Amazon ECS Amazon Linux 2 AMI yang dioptimalkan Amazon ECS.

Untuk informasi tentang cara membuat cluster untuk EC2, lihat[Membuat cluster Amazon ECS untuk beban kerja Amazon EC2](create-ec2-cluster-console-v2.md).

## Langkah 5: Jalankan tugas
<a name="specifying-sensitive-data-tutorial-run-task"></a>

Anda dapat menggunakan konsol Amazon ECS untuk menjalankan tugas menggunakan definisi tugas yang Anda buat. Untuk tutorial ini kita akan menjalankan tugas menggunakan EC2, menggunakan cluster yang kita buat pada langkah sebelumnya. 

Untuk informasi tentang cara menjalankan tugas, lihat[Menjalankan aplikasi sebagai tugas Amazon ECS](standalone-task-create.md).

## Langkah 6: Verifikasi
<a name="specifying-sensitive-data-tutorial-verify"></a>

Anda dapat memverifikasi bahwa semua langkah berhasil diselesaikan dan variabel lingkungan dibuat dengan benar dalam kontainer Anda menggunakan langkah-langkah berikut.

**Untuk memverifikasi bahwa variabel lingkungan telah dibuat**

1. Cari IP publik atau alamat DNS untuk instans kontainer Anda.

   1. Buka konsol di [https://console.aws.amazon.com/ecs/v2](https://console.aws.amazon.com/ecs/v2).

   1. Di panel navigasi, pilih **Cluster**, lalu pilih cluster yang Anda buat.

   1. Pilih **Infrastruktur**, lalu pilih instance container.

   1. Rekam **IP Publik** atau **DNS Publik** untuk instans Anda.

1. Jika Anda menggunakan komputer macOS atau Linux, sambungkan ke instans Anda dengan perintah berikut, ganti jalur ke kunci pribadi dan alamat publik untuk instans Anda:

   ```
   $ ssh -i /path/to/my-key-pair.pem ec2-user@ec2-198-51-100-1.compute-1.amazonaws.com
   ```

   Untuk informasi selengkapnya tentang menggunakan komputer Windows, lihat [Connect ke instans Linux menggunakan PuTTY](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connect-linux-inst-from-windows.html) di Panduan Pengguna *Amazon EC2*.
**penting**  
Untuk informasi selengkapnya tentang masalah apa pun saat menyambung ke instans, lihat [Memecahkan Masalah Menyambung ke Instans Anda](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/TroubleshootingInstancesConnecting.html) di Panduan Pengguna *Amazon EC2*.

1. Cantumkan kontainer yang berjalan pada instans. Catat ID kontainer untuk kontainer `ecs-secrets-tutorial`.

   ```
   docker ps
   ```

1. Terhubung ke kontainer `ecs-secrets-tutorial` menggunakan ID kontainer dari output dari langkah sebelumnya.

   ```
   docker exec -it container_ID /bin/bash
   ```

1. Gunakan perintah `echo` untuk mencetak nilai variabel lingkungan.

   ```
   echo $username_value
   ```

   Jika tutorial berhasil, Anda akan melihat output sebagai berikut:

   ```
   password_value
   ```
**catatan**  
Atau, Anda dapat mencantumkan semua variabel lingkungan dalam wadah Anda menggunakan perintah `env` (atau `printenv`).

## Langkah 7: Bersihkan
<a name="specifying-sensitive-data-tutorial-cleanup"></a>

Setelah selesai dengan tutorial ini, Anda harus membersihkan sumber daya yang terkait untuk menghindari timbulnya biaya untuk sumber daya yang tidak terpakai.

**Untuk membersihkan sumber daya**

1. Buka konsol di [https://console.aws.amazon.com/ecs/v2](https://console.aws.amazon.com/ecs/v2).

1. Pada panel navigasi, silakan pilih **Klaster**.

1. Pada halaman **Clusters**, pilih cluster.

1. Pilih **Hapus klaster**. 

1. Di kotak konfirmasi, masukkan **hapus *cluster name***, lalu pilih **Hapus**.

1. Buka konsol IAM di [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Di panel navigasi, pilih **Peran**. 

1. Cari daftar peran untuk `ecsTaskExecutionRole` dan pilih peran itu.

1. Pilih **Izin**, lalu pilih **X** di sebelah **ECSSecretsTutorial**. Pilih **Hapus**.

1. Buka konsol Secrets Manager di [https://console.aws.amazon.com/secretsmanager/](https://console.aws.amazon.com/secretsmanager/).

1. Pilih rahasia **username\$1value** yang Anda buat dan pilih **Tindakan**, **Hapus rahasia**.