Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Kirim log Amazon ECS ke AWS layanan atau AWS Partner
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
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
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)
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
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`
`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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
Default: /aws/service/aws-for-fluent-bit/windowsservercore-stable
```
# Contoh definisi tugas Amazon ECS: Rute log ke FireLens
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
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