**Bantu tingkatkan halaman ini** 

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

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

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

# Mulai pencatatan AWS Fargate untuk klaster Anda
<a name="fargate-logging"></a>

Amazon EKS di Fargate menawarkan router log bawaan berdasarkan Fluent Bit. Ini berarti Anda tidak secara eksplisit menjalankan container Fluent Bit sebagai sespan, tetapi Amazon menjalankannya untuk Anda. Yang harus Anda lakukan adalah mengkonfigurasi router log. Konfigurasi terjadi melalui dedicated `ConfigMap` yang harus memenuhi kriteria berikut:
+ Bernama `aws-logging` 
+ Dibuat di namespace khusus yang disebut `aws-observability` 
+ Tidak dapat melebihi 5300 karakter.

Setelah Anda membuat`ConfigMap`, Amazon EKS di Fargate secara otomatis mendeteksi dan mengonfigurasi router log dengannya. Fargate menggunakan versi AWS untuk Fluent Bit, distribusi Fluent Bit yang sesuai dengan hulu yang dikelola oleh. AWS Untuk informasi lebih lanjut, lihat [AWS Fluent Bit](https://github.com/aws/aws-for-fluent-bit) on GitHub.

Router log memungkinkan Anda untuk menggunakan luasnya layanan di AWS untuk analisis log dan penyimpanan. Anda dapat melakukan streaming log dari Fargate langsung ke Amazon, CloudWatch Amazon OpenSearch Service. [Anda juga dapat melakukan streaming log ke tujuan seperti [Amazon S3](https://aws.amazon.com/s3/), [Amazon Kinesis Data Streams, dan alat mitra melalui Amazon Data](https://aws.amazon.com/kinesis/data-streams/) Firehose.](https://aws.amazon.com/kinesis/data-firehose/)
+ Profil Fargate yang sudah ada yang menentukan namespace Kubernetes yang sudah ada yang kamu gunakan untuk Pod Fargate. Untuk informasi selengkapnya, lihat [Langkah 3: Buat profil Fargate untuk cluster Anda](fargate-getting-started.md#fargate-gs-create-profile).
+ Peran eksekusi Fargate Pod yang ada. Untuk informasi selengkapnya, lihat [Langkah 2: Buat peran eksekusi Fargate Pod](fargate-getting-started.md#fargate-sg-pod-execution-role).

## Konfigurasi router log
<a name="fargate-logging-log-router-configuration"></a>

**penting**  
Agar log berhasil dipublikasikan, harus ada akses jaringan dari VPC tempat klaster Anda berada ke tujuan log. Ini terutama menyangkut pengguna yang menyesuaikan aturan jalan keluar untuk VPC mereka. Untuk contoh menggunakan CloudWatch, lihat [Menggunakan CloudWatch Log dengan titik akhir VPC antarmuka](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/cloudwatch-logs-and-interface-VPC.html) di Panduan Pengguna *Amazon CloudWatch Logs*.

Pada langkah-langkah berikut, ganti masing-masing *example value* dengan nilai Anda sendiri.

1. Buat namespace Kubernetes khusus bernama. `aws-observability`

   1. Simpan konten berikut ini ke file bernama `aws-observability-namespace.yaml` pada komputer Anda. Nilai untuk `name` harus `aws-observability` dan `aws-observability: enabled` label diperlukan.

      ```
      kind: Namespace
      apiVersion: v1
      metadata:
        name: aws-observability
        labels:
          aws-observability: enabled
      ```

   1. Buat namespace.

      ```
      kubectl apply -f aws-observability-namespace.yaml
      ```

1. Buat `ConfigMap` dengan nilai `Fluent Conf` data untuk mengirimkan log kontainer ke tujuan. Fluent Conf adalah Fluent Bit, yang merupakan bahasa konfigurasi prosesor log yang cepat dan ringan yang digunakan untuk merutekan log kontainer ke tujuan log pilihan Anda. Untuk informasi lebih lanjut, lihat [File konfigurasi](https://docs.fluentbit.io/manual/administration/configuring-fluent-bit/classic-mode/configuration-file) dalam dokumentasi Fluent Bit.
**penting**  
Bagian utama yang termasuk dalam tipikal `Fluent Conf` adalah`Service`,`Input`,`Filter`, dan`Output`. Namun, router log Fargate hanya menerima:  
`Output`Bagian `Filter` dan.
Sebuah `Parser` bagian.
Jika Anda memberikan bagian lain, mereka akan ditolak.

   Router log Fargate mengelola bagian `Service` dan`Input`. Ini memiliki `Input` bagian berikut, yang tidak dapat dimodifikasi dan tidak diperlukan di Anda`ConfigMap`. Namun, Anda bisa mendapatkan wawasan darinya, seperti batas buffer memori dan tag yang diterapkan untuk log.

   ```
   [INPUT]
       Name tail
       Buffer_Max_Size 66KB
       DB /var/log/flb_kube.db
       Mem_Buf_Limit 45MB
       Path /var/log/containers/*.log
       Read_From_Head On
       Refresh_Interval 10
       Rotate_Wait 30
       Skip_Long_Lines On
       Tag kube.*
   ```

   Saat membuat`ConfigMap`, pertimbangkan aturan berikut yang digunakan Fargate untuk memvalidasi bidang:
   +  `[FILTER]`,`[OUTPUT]`, dan seharusnya `[PARSER]` ditentukan di bawah setiap kunci yang sesuai. Contohnya, `[FILTER]` harus berada dalam `filters.conf`. Anda dapat memiliki satu atau lebih `[FILTER]` s di bawah`filters.conf`. `[PARSER]`Bagian `[OUTPUT]` dan juga harus berada di bawah kunci yang sesuai. Dengan menentukan beberapa `[OUTPUT]` bagian, Anda dapat merutekan log Anda ke tujuan yang berbeda secara bersamaan.
   + Fargate memvalidasi kunci yang diperlukan untuk setiap bagian. `Name` dan `match` diperlukan untuk setiap `[FILTER]` dan `[OUTPUT]`. `Name` dan `format` diperlukan untuk setiap `[PARSER]`. Kunci peka terhadap huruf besar dan kecil.
   + Variabel lingkungan seperti `${ENV_VAR}` tidak diizinkan di`ConfigMap`.
   + Indentasi harus sama dengan arahan atau pasangan nilai kunci dalam setiap `filters.conf`, `output.conf`, dan `parsers.conf`. Pasangan nilai kunci yang harus menjorok lebih dari arahan.
   + Fargate memvalidasi terhadap filter yang didukung berikut:`grep`,,`parser`,,`record_modifier`, `rewrite_tag` `throttle``nest`, `modify` dan. `kubernetes`
   + Fargate memvalidasi output yang didukung berikut: `es`, `firehose`, `kinesis_firehose`, `cloudwatch`, `cloudwatch_logs`, dan `kinesis`.
   + Setidaknya satu `Output` plugin yang didukung harus disediakan di `ConfigMap` untuk mengaktifkan logging. `Filter`dan `Parser` tidak diperlukan untuk mengaktifkan logging.

     Anda juga dapat menjalankan Fluent Bit di Amazon EC2 menggunakan konfigurasi yang diinginkan untuk memecahkan masalah apa pun yang timbul dari validasi. Buat Anda `ConfigMap` menggunakan salah satu contoh berikut.
**penting**  
Amazon EKS Fargate logging tidak mendukung konfigurasi dinamis file. `ConfigMap` Setiap perubahan pada a hanya `ConfigMap` diterapkan pada Pod baru. Perubahan tidak diterapkan pada Pod yang ada.

     Buat `ConfigMap` menggunakan contoh untuk tujuan log yang Anda inginkan.
**catatan**  
Anda juga dapat menggunakan Amazon Kinesis Data Streams untuk tujuan log Anda. Jika Anda menggunakan Kinesis Data Streams, pastikan bahwa peran eksekusi pod telah `kinesis:PutRecords` diberikan izin. Untuk informasi selengkapnya, lihat Izin Amazon Kinesis [Data](https://docs.fluentbit.io/manual/pipeline/outputs/kinesis#permissions) Streams *di Bit Lancar: Manual* Resmi.  
**Example**  

------
#### [ CloudWatch ]

   Anda memiliki dua opsi output saat menggunakan CloudWatch:
   +  [Plugin keluaran yang ditulis dalam C](https://docs.fluentbit.io/manual/v/1.5/pipeline/outputs/cloudwatch) 
   +  [Plugin keluaran yang ditulis dalam Golang](https://github.com/aws/amazon-cloudwatch-logs-for-fluent-bit) 

   Contoh berikut menunjukkan cara menggunakan `cloudwatch_logs` plugin untuk mengirim log ke CloudWatch.

   1. Simpan konten berikut ini ke file bernama `aws-logging-cloudwatch-configmap.yaml`. Ganti *region-code* dengan AWS Wilayah tempat cluster Anda berada. Parameter di bawah `[OUTPUT]` diperlukan.

      ```
      kind: ConfigMap
      apiVersion: v1
      metadata:
        name: aws-logging
        namespace: aws-observability
      data:
        flb_log_cw: "false"  # Set to true to ship Fluent Bit process logs to CloudWatch.
        filters.conf: |
          [FILTER]
              Name parser
              Match *
              Key_name log
              Parser crio
          [FILTER]
              Name kubernetes
              Match kube.*
              Merge_Log On
              Keep_Log Off
              Buffer_Size 0
              Kube_Meta_Cache_TTL 300s
        output.conf: |
          [OUTPUT]
              Name cloudwatch_logs
              Match   kube.*
              region region-code
              log_group_name my-logs
              log_stream_prefix from-fluent-bit-
              log_retention_days 60
              auto_create_group true
        parsers.conf: |
          [PARSER]
              Name crio
              Format Regex
              Regex ^(?<time>[^ ]+) (?<stream>stdout|stderr) (?<logtag>P|F) (?<log>.*)$
              Time_Key    time
              Time_Format %Y-%m-%dT%H:%M:%S.%L%z
      ```

   1. Menerapkan manifes ke klaster Anda.

      ```
      kubectl apply -f aws-logging-cloudwatch-configmap.yaml
      ```

------
#### [ Amazon OpenSearch Service ]

   Jika Anda ingin mengirim log ke Amazon OpenSearch Service, Anda dapat menggunakan [es](https://docs.fluentbit.io/manual/v/1.5/pipeline/outputs/elasticsearch) output, yang merupakan plugin yang ditulis dalam C. Contoh berikut menunjukkan cara menggunakan plugin untuk mengirim log ke OpenSearch.

   1. Simpan konten berikut ini ke file bernama `aws-logging-opensearch-configmap.yaml`. Ganti setiap *example value* dengan nilai-nilai Anda sendiri.

      ```
      kind: ConfigMap
      apiVersion: v1
      metadata:
        name: aws-logging
        namespace: aws-observability
      data:
        output.conf: |
          [OUTPUT]
            Name  es
            Match *
            Host  search-example-gjxdcilagiprbglqn42jsty66y.region-code.es.amazonaws.com
            Port  443
            Index example
            Type  example_type
            AWS_Auth On
            AWS_Region region-code
            tls   On
      ```

   1. Menerapkan manifes ke klaster Anda.

      ```
      kubectl apply -f aws-logging-opensearch-configmap.yaml
      ```

------
#### [ Firehose ]

   Anda memiliki dua opsi output saat mengirim log ke Firehose:
   +  [kinesis\$1firehose](https://docs.fluentbit.io/manual/pipeline/outputs/firehose) — Plugin keluaran yang ditulis dalam C.
   +  [firehose](https://github.com/aws/amazon-kinesis-firehose-for-fluent-bit) - Plugin keluaran yang ditulis dalam Golang.

     Contoh berikut menunjukkan cara menggunakan `kinesis_firehose` plugin untuk mengirim log ke Firehose.

     1. Simpan konten berikut ini ke file bernama `aws-logging-firehose-configmap.yaml`. Ganti *region-code* dengan AWS Wilayah tempat cluster Anda berada.

        ```
        kind: ConfigMap
        apiVersion: v1
        metadata:
          name: aws-logging
          namespace: aws-observability
        data:
          output.conf: |
            [OUTPUT]
             Name  kinesis_firehose
             Match *
             region region-code
             delivery_stream my-stream-firehose
        ```

     1. Menerapkan manifes ke klaster Anda.

        ```
        kubectl apply -f aws-logging-firehose-configmap.yaml
        ```

------

1. Siapkan izin untuk peran eksekusi Fargate Pod untuk mengirim log ke tujuan Anda.

   1. Unduh kebijakan IAM untuk tujuan Anda ke komputer Anda.  
**Example**  

------
#### [ CloudWatch ]

      Unduh kebijakan CloudWatch IAM ke komputer Anda. Anda juga dapat [melihat kebijakan](https://raw.githubusercontent.com/aws-samples/amazon-eks-fluent-logging-examples/mainline/examples/fargate/cloudwatchlogs/permissions.json) di GitHub.

      ```
      curl -O https://raw.githubusercontent.com/aws-samples/amazon-eks-fluent-logging-examples/mainline/examples/fargate/cloudwatchlogs/permissions.json
      ```

------
#### [ Amazon OpenSearch Service ]

      Unduh kebijakan OpenSearch IAM ke komputer Anda. Anda juga dapat [melihat kebijakan](https://raw.githubusercontent.com/aws-samples/amazon-eks-fluent-logging-examples/mainline/examples/fargate/amazon-elasticsearch/permissions.json) di GitHub.

      ```
      curl -O https://raw.githubusercontent.com/aws-samples/amazon-eks-fluent-logging-examples/mainline/examples/fargate/amazon-elasticsearch/permissions.json
      ```

      Pastikan kontrol akses OpenSearch Dashboard dikonfigurasi dengan benar. OpenSearch Dashboard `all_access role` in harus memiliki peran eksekusi Fargate Pod dan peran IAM yang dipetakan. Pemetaan yang sama harus dilakukan untuk `security_manager` peran tersebut. Anda dapat menambahkan pemetaan sebelumnya dengan memilih`Menu`, kemudian, lalu `Security``Roles`, dan kemudian memilih peran masing-masing. Untuk informasi selengkapnya, lihat [Bagaimana cara memecahkan masalah CloudWatch Log sehingga mengalir ke domain Amazon ES saya](https://aws.amazon.com/tr/premiumsupport/knowledge-center/es-troubleshoot-cloudwatch-logs/)? .

------
#### [ Firehose ]

      Unduh kebijakan Firehose IAM ke komputer Anda. Anda juga dapat [melihat kebijakan](https://raw.githubusercontent.com/aws-samples/amazon-eks-fluent-logging-examples/mainline/examples/fargate/kinesis-firehose/permissions.json) di GitHub.

      ```
      curl -O https://raw.githubusercontent.com/aws-samples/amazon-eks-fluent-logging-examples/mainline/examples/fargate/kinesis-firehose/permissions.json
      ```

------

   1. Buat kebijakan IAM dari file kebijakan yang Anda unduh.

      ```
      aws iam create-policy --policy-name eks-fargate-logging-policy --policy-document file://permissions.json
      ```

   1. Lampirkan kebijakan IAM ke peran eksekusi pod yang ditentukan untuk profil Fargate Anda dengan perintah berikut. Ganti *111122223333* dengan ID akun Anda. Ganti *AmazonEKSFargatePodExecutionRole* dengan peran eksekusi Pod Anda (untuk informasi selengkapnya, lihat[Langkah 2: Buat peran eksekusi Fargate Pod](fargate-getting-started.md#fargate-sg-pod-execution-role)).

      ```
      aws iam attach-role-policy \
        --policy-arn arn:aws: iam::111122223333:policy/eks-fargate-logging-policy \
        --role-name AmazonEKSFargatePodExecutionRole
      ```

### Dukungan filter Kubernetes
<a name="fargate-logging-kubernetes-filter"></a>

Filter Fluent Bit Kubernetes memungkinkan Anda menambahkan metadata Kubernetes ke file log Anda. Untuk informasi selengkapnya tentang filter, lihat [Kubernetes](https://docs.fluentbit.io/manual/pipeline/filters/kubernetes) di dokumentasi Fluent Bit. Anda dapat menerapkan filter menggunakan titik akhir server API.

```
filters.conf: |
    [FILTER]
        Name             kubernetes
        Match            kube.*
        Merge_Log           On
        Buffer_Size         0
        Kube_Meta_Cache_TTL 300s
```

**penting**  
 `Kube_URL`,`Kube_CA_File`,`Kube_Token_Command`, dan `Kube_Token_File` merupakan parameter konfigurasi yang dimiliki layanan dan tidak boleh ditentukan. Amazon EKS Fargate mengisi nilai-nilai ini.
 `Kube_Meta_Cache_TTL`adalah waktu Fluent Bit menunggu hingga berkomunikasi dengan server API untuk metadata terbaru. Jika `Kube_Meta_Cache_TTL` tidak ditentukan, Amazon EKS Fargate menambahkan nilai default 30 menit untuk mengurangi beban pada server API.

### Untuk mengirimkan log proses Fluent Bit ke akun Anda
<a name="ship-fluent-bit-process-logs"></a>

Anda dapat secara opsional mengirimkan log proses Fluent Bit ke Amazon CloudWatch menggunakan yang berikut ini. `ConfigMap` Pengiriman log proses Fluent Bit ke CloudWatch membutuhkan biaya konsumsi dan penyimpanan log tambahan. Ganti *region-code* dengan AWS Wilayah tempat cluster Anda berada.

```
kind: ConfigMap
apiVersion: v1
metadata:
  name: aws-logging
  namespace: aws-observability
  labels:
data:
  # Configuration files: server, input, filters and output
  # ======================================================
  flb_log_cw: "true"  # Ships Fluent Bit process logs to CloudWatch.

  output.conf: |
    [OUTPUT]
        Name cloudwatch
        Match kube.*
        region region-code
        log_group_name fluent-bit-cloudwatch
        log_stream_prefix from-fluent-bit-
        auto_create_group true
```

Log berada CloudWatch di AWS Wilayah yang sama dengan cluster. Nama grup log adalah ` my-cluster-fluent-bit-logs` dan nama logstream Fluent Bit adalah. `fluent-bit-podname-pod-namespace `

**catatan**  
Log proses dikirim hanya ketika proses Bit Lancar berhasil dimulai. Jika ada kegagalan saat memulai Fluent Bit, log proses terlewatkan. Anda hanya dapat mengirimkan log proses ke CloudWatch.
Untuk men-debug log proses pengiriman ke akun Anda, Anda dapat menerapkan sebelumnya `ConfigMap` untuk mendapatkan log proses. Fluent Bit gagal memulai biasanya karena Anda `ConfigMap` tidak diurai atau diterima oleh Fluent Bit saat memulai.

### Untuk menghentikan pengiriman log proses Fluent Bit
<a name="stop-fluent-bit-process-logs"></a>

Pengiriman log proses Fluent Bit ke CloudWatch membutuhkan biaya konsumsi dan penyimpanan log tambahan. Untuk mengecualikan log proses dalam `ConfigMap` pengaturan yang ada, lakukan langkah-langkah berikut.

1. Temukan grup CloudWatch log yang dibuat secara otomatis untuk log proses Fluent Bit klaster Amazon EKS Anda setelah mengaktifkan logging Fargate. Ini mengikuti format` my-cluster-fluent-bit-logs`.

1. Hapus aliran CloudWatch log yang ada yang dibuat untuk setiap log proses Pod di grup CloudWatch log.

1. Edit `ConfigMap` dan atur`flb_log_cw: "false"`.

1. Mulai ulang semua Pod yang ada di klaster.

## Aplikasi uji
<a name="fargate-logging-test-application"></a>

1. Menerapkan contoh Pod.

   1. Simpan konten berikut ini ke file bernama `sample-app.yaml` pada komputer Anda.

      ```
      apiVersion: apps/v1
      kind: Deployment
      metadata:
        name: sample-app
        namespace: same-namespace-as-your-fargate-profile
      spec:
        replicas: 3
        selector:
          matchLabels:
            app: nginx
        template:
          metadata:
            labels:
              app: nginx
          spec:
            containers:
              - name: nginx
                image: nginx:latest
                ports:
                  - name: http
                    containerPort: 80
      ```

   1. Menerapkan manifes ke klaster.

      ```
      kubectl apply -f sample-app.yaml
      ```

1. Lihat log NGINX menggunakan tujuan yang Anda konfigurasikan di. `ConfigMap`

## Pertimbangan ukuran
<a name="fargate-logging-size-considerations"></a>

Kami menyarankan Anda merencanakan hingga 50 MB memori untuk router log. Jika Anda mengharapkan aplikasi Anda untuk menghasilkan catatan pada throughput yang sangat tinggi, maka Anda harus menyediakan memori hingga 100 MB.

## Pemecahan Masalah
<a name="fargate-logging-troubleshooting"></a>

Untuk mengonfirmasi apakah fitur logging diaktifkan atau dinonaktifkan karena beberapa alasan, seperti tidak valid`ConfigMap`, dan mengapa fitur tersebut tidak valid, periksa peristiwa Pod Anda. `kubectl describe pod pod-name ` Outputnya mungkin mencakup peristiwa Pod yang menjelaskan apakah logging diaktifkan atau tidak, seperti contoh keluaran berikut.

```
[...]
Annotations:          CapacityProvisioned: 0.25vCPU 0.5GB
                      Logging: LoggingDisabled: LOGGING_CONFIGMAP_NOT_FOUND
[...]
Events:
  Type     Reason           Age        From                                                           Message
  ----     ------           ----       ----                                                           -------
  Warning  LoggingDisabled  <unknown>  fargate-scheduler                                              Disabled logging because aws-logging configmap was not found. configmap "aws-logging" not found
```

Peristiwa Pod bersifat sementara dengan periode waktu tergantung pada pengaturan. Anda juga dapat melihat anotasi Pod menggunakan`kubectl describe pod pod-name `. Dalam anotasi Pod, terdapat informasi tentang apakah fitur logging diaktifkan atau dinonaktifkan dan alasannya.