**Bantu meningkatkan 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 GitHub ** tautan ** Edit halaman ini di 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 AWS Logging Fargate untuk cluster Anda
<a name="fargate-logging"></a>

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

Setelah Anda membuatnya`ConfigMap`, Amazon EKS di Fargate secara otomatis mendeteksinya 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 untuk Fluent Bit ](https://github.com/aws/aws-for-fluent-bit) on GitHub.

Router log memungkinkan Anda menggunakan berbagai layanan di AWS untuk analitik dan penyimpanan log. Anda dapat melakukan streaming log dari Fargate langsung ke Amazon CloudWatch dan Amazon OpenSearch Service. Anda juga dapat melakukan streaming log ke tujuan seperti [ Amazon S3](https://aws.amazon.com/s3/), [ Amazon Kinesis Data Streams](https://aws.amazon.com/kinesis/data-streams/), dan alat mitra melalui [ Amazon Data Fire ](https://aws.amazon.com/kinesis/data-firehose/) hose.
+ Profil Fargate yang ada yang menentukan namespace Kubernetes yang sudah ada tempat Anda menerapkan 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 cluster Anda masuk ke tujuan log. Ini terutama menyangkut pengguna yang menyesuaikan aturan keluar untuk VPC mereka. Untuk contoh penggunaan 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 Log. *

Dalam langkah-langkah berikut, ganti setiap {{example value}} dengan nilai Anda sendiri.

1. Buat namespace khusus Kubernetes 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 `Input` bagian `Service` dan. 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 `${ENV_VAR}` seperti tidak diizinkan di`ConfigMap`.
   + Indentasi harus sama untuk pasangan direktif atau kunci-nilai dalam masing-masing`filters.conf`,, `output.conf` dan. `parsers.conf` Key-value pasangan harus diberi indentasi 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 `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 yang timbul dari validasi. Buat Anda `ConfigMap` menggunakan salah satu contoh berikut.
**penting**  
Amazon EKS Fargate logging tidak mendukung konfigurasi dinamis a`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 peran eksekusi pod telah diberikan `kinesis:PutRecords` izin. Untuk informasi selengkapnya, lihat Izin Aliran Data Amazon [ Kinesis ](https://docs.fluentbit.io/manual/pipeline/outputs/kinesis#permissions) di * Fluent Bit: Manual * Resmi.  
**Example**  

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

   Anda memiliki dua opsi keluaran saat menggunakan CloudWatch:
   +  [Plugin keluaran ditulis dalam C ](https://docs.fluentbit.io/manual/v/1.5/pipeline/outputs/cloudwatch) 
   +  [Plugin keluaran 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]` ini 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 semua {{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\_firehose ](https://docs.fluentbit.io/manual/pipeline/outputs/firehose) - Plugin keluaran 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 Dasbor dikonfigurasi dengan benar. OpenSearch Das `all_access role` bor dalam harus memiliki peran eksekusi Pod Fargate dan peran IAM yang dipetakan. Pemetaan yang sama harus dilakukan untuk `security_manager` peran tersebut. Anda dapat menambahkan pemetaan sebelumnya dengan memilih`Menu`, lalu, lalu `Security``Roles`, dan kemudian pilih peran masing-masing. Untuk informasi selengkapnya, lihat [ Bagaimana cara memecahkan masalah CloudWatch Log agar dapat dialirkan ke domain Amazon ES saya? ](https://aws.amazon.com/tr/premiumsupport/knowledge-center/es-troubleshoot-cloudwatch-logs/).

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

      Unduh kebijakan IAM Firehose 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) dalam 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 {{300}}s
```

**penting**  
 `Kube_URL`,`Kube_CA_File`,`Kube_Token_Command`, dan `Kube_Token_File` merupakan parameter konfigurasi milik 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 CloudWatch memerlukan biaya penyerapan 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 Wilayah yang sama AWS 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 Fluent Bit 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 yang 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 CloudWatch memerlukan biaya penyerapan 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 cluster 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 Pod yang ada di cluster.

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

1. Menyebarkan Pod sampel.

   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 alasan tertentu, seperti tidak valid`ConfigMap`, dan mengapa fitur ini tidak valid, periksa peristiwa Pod Anda dengan`kubectl describe pod {{pod-name}} `. Output mungkin termasuk peristiwa Pod yang mengklarifikasi apakah logging diaktifkan atau tidak, seperti contoh output 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, ada informasi tentang apakah fitur logging diaktifkan atau dinonaktifkan dan alasannya.