

 **Unterstützung für die Verbesserung dieser Seite beitragen** 

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Um zu diesem Benutzerhandbuch beizutragen, wählen Sie den GitHub Link **Diese Seite bearbeiten auf**, der sich im rechten Bereich jeder Seite befindet.

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# AWS-Fargate-Protokollierung für Ihren Cluster starten
<a name="fargate-logging"></a>

Amazon EKS auf Fargate bietet einen integrierten Log-Router basierend auf Fluent Bit. Dies bedeutet, dass Sie einen Fluent-Bit-Container nicht explizit als Sidecar ausführen, sondern Amazon für Sie ausführen. Alles, was Sie tun müssen, ist den Log-Router zu konfigurieren. Die Konfiguration erfolgt über ein dediziertes `ConfigMap`, das die folgenden Kriterien erfüllen muss:
+ Benannte `aws-logging` 
+ Erstellt in einem dedizierten Namespace namens `aws-observability` 
+ Mehr als 5 300 Zeichen sind nicht zulässig.

Sobald Sie die `ConfigMap` erstellt haben, erkennt Amazon EKS in Fargate sie automatisch und konfiguriert den Protokollrouter damit. Fargate verwendet eine Version von AWS für Fluent Bit, eine Upstream-kompatible Distribution von Fluent Bit, die von AWS verwaltet wird. Weitere Informationen finden Sie unter [AWS für Fluent Bit auf](https://github.com/aws/aws-for-fluent-bit) GitHub.

Mit dem Log-Router können Sie die Bandbreite der Services von AWS für Protokoll-Analysen und -Speicherung nutzen. Sie können Protokolle von Fargate direkt an Amazon CloudWatch, Amazon OpenSearch Service streamen. Außerdem können Sie Protokolle über [Amazon Kinesis Data Firehose](https://aws.amazon.com/kinesis/data-firehose/) an Ziele wie [Amazon S3](https://aws.amazon.com/s3/), [Amazon Kinesis Data Streams](https://aws.amazon.com/kinesis/data-streams/) und Partner-Tools streamen.
+ Ein vorhandenes Fargate-Profil, das einen vorhandenen Kubernetes-Namespace angibt, in dem Sie Fargate-Pods bereitstellen. Weitere Informationen finden Sie unter [Schritt 3: Fargate Profil für Ihren Cluster erstellen](fargate-getting-started.md#fargate-gs-create-profile).
+ Eine vorhandene Fargate-Pod-Ausführungsrolle. Weitere Informationen finden Sie unter [Schritt 2: Fargate-Pod-Ausführungsrolle erstellen](fargate-getting-started.md#fargate-sg-pod-execution-role).

## Router-Konfiguration protokollieren
<a name="fargate-logging-log-router-configuration"></a>

**Wichtig**  
Damit Protokolle erfolgreich veröffentlicht werden können, muss von der VPC, in der sich Ihr Cluster befindet, Netzwerkzugriff auf das Protokollziel bestehen. Dies betrifft vor allem Benutzer, die Ausgangsregeln für ihre VPC anpassen. Ein Beispiel für die Verwendung von CloudWatch finden Sie unter [Verwendung von CloudWatch-Protokollen mit Schnittstellen-VPC-Endpunkten](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/cloudwatch-logs-and-interface-VPC.html) im *Benutzerhandbuch zu Amazon CloudWatch Logs*.

Ersetzen Sie in den folgenden Schritten jedes *Beispielwert* durch Ihre eigenen Werte.

1. Erstellen Sie einen dedizierten Kubernetes-Namespace namens `aws-observability`.

   1. Speichern Sie den folgenden Inhalt in einer Datei mit dem Namen `aws-observability-namespace.yaml` auf Ihrem Computer. Der Wert für `name` muss `aws-observability` sein und das Label `aws-observability: enabled` ist erforderlich.

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

   1. Erstellen Sie den Namespace.

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

1. Erstellen Sie ein `ConfigMap` mit einem `Fluent Conf`-Datenwert, um Container-Logs an ein Ziel zu versenden. Fluent Conf ist Fluent Bit, eine schnelle und leichte Konfigurationssprache für den Protokollprozessor, die verwendet wird, um Container-Protokolle an ein Protokollziel Ihrer Wahl weiterzuleiten. Weitere Informationen finden Sie unter [Konfigurationsdatei](https://docs.fluentbit.io/manual/administration/configuring-fluent-bit/classic-mode/configuration-file) in der Fluent-Bit-Dokumentation.
**Wichtig**  
In einer typischen `Fluent Conf` sind die Hauptabschnitte `Service`, `Input`, `Filter` und `Output` enthalten. Der Fargate-Protokoll-Router akzeptiert jedoch nur:  
Die Abschnitte `Filter` und `Output`.
Ein `Parser`-Abschnitt.
Wenn Sie andere Abschnitte angeben, werden diese abgelehnt.

   Der Fargate-Protokollrouter verwaltet die Abschnitte `Service` und `Input`. Es verfügt über den folgenden Abschnitt `Input`, der nicht geändert werden kann und in Ihrem `ConfigMap` nicht benötigt wird. Sie können daraus jedoch Erkenntnisse gewinnen, z. B. die Speicherpuffergrenze und das für Protokolle angewendete Tag.

   ```
   [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.*
   ```

   Berücksichtigen Sie beim Erstellen des `ConfigMap`, die folgenden Regeln, die Fargate verwendet, um Felder zu validieren:
   +  `[FILTER]`, `[OUTPUT]`, und `[PARSER]` sollen unter jedem entsprechenden Schlüssel angegeben werden. `[FILTER]` muss beispielsweise unter `filters.conf` liegen. Sie können ein oder mehrere `[FILTER]` in der `filters.conf` haben. Die Abschnitte `[OUTPUT]` und `[PARSER]` sollten sich auch unter den entsprechenden Schlüssel befinden. Durch die Angabe mehrerer `[OUTPUT]`-Abschnitte können Sie Ihre Protokolle gleichzeitig an verschiedene Ziele weiterleiten.
   + Fargate validiert die erforderlichen Schlüssel für jeden Abschnitt. `Name` und `match`sind für jedes `[FILTER]` und `[OUTPUT]` erforderlich. `Name` und `format` werden jeweils für jeden `[PARSER]` benötigt. Bei den Schlüssel wird nicht zwischen Groß- und Kleinschreibung unterschieden.
   + Umgebungsvariablen wie `${ENV_VAR}` sind im `ConfigMap` nicht erlaubt.
   + Die Einrückung muss für die Direktive oder das Schlüssel-Wert-Paar innerhalb von `filters.conf`, `output.conf` und `parsers.conf` gleich sein. Schlüssel-Wert-Paare müssen stärker eingerückt werden als Direktiven.
   + Fargate validiert gegen die folgenden unterstützten Filter: `grep`, `parser`, `record_modifier`, `rewrite_tag`, `throttle`, `nest`, `modify`, und `kubernetes`.
   + Fargate validiert mit der folgenden unterstützten Ausgabe: `es`, `firehose`, `kinesis_firehose`, `cloudwatch`, `cloudwatch_logs`, und `kinesis`.
   + Mindestens ein unterstütztes `Output`-Plugin muss im `ConfigMap` bereitgestellt werden, um die Protokollierung zu ermöglichen. `Filter` und `Parser` sind nicht erforderlich, um die Protokollierung zu aktivieren.

     Sie können Fluent Bit auch auf Amazon EC2 mit der gewünschten Konfiguration ausführen, um alle Probleme zu beheben, die sich aus der Validierung ergeben. Erstellen Sie Ihr `ConfigMap` mit einem der folgenden Beispiele.
**Wichtig**  
Die Amazon-EKS-Fargate-Protokollierung unterstützt keine dynamische Konfiguration einer `ConfigMap`. Alle Änderungen an eine `ConfigMap` werden nur auf neue Pods angewendet. Änderungen werden nicht auf vorhandene Pods angewendet.

     Erstellen Sie anhand des Beispiels ein `ConfigMap` für Ihr gewünschtes Protokollziel.
**Anmerkung**  
Sie können auch Amazon Kinesis Data Streams als Protokollziel verwenden. Stellen Sie bei der Nutzung von Kinesis Data Streams sicher, dass der Pod-Ausführungsrolle die Berechtigung `kinesis:PutRecords` erteilt wurde. Weitere Informationen finden Sie unter [Berechtigungen](https://docs.fluentbit.io/manual/pipeline/outputs/kinesis#permissions) für Amazon Kinesis Data Streams im offiziellen *Handbuch zu Fluent Bit*.  
**Example**  

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

   Bei der Verwendung von CloudWatch haben Sie zwei Ausgabeoptionen:
   +  [Ein Ausgabe-Plug-In in C geschrieben](https://docs.fluentbit.io/manual/v/1.5/pipeline/outputs/cloudwatch) 
   +  [Ein in Golang geschriebenes Ausgabe-Plug-In](https://github.com/aws/amazon-cloudwatch-logs-for-fluent-bit) 

   Das folgende Beispiel zeigt Ihnen, wie Sie das `cloudwatch_logs`-Plug-in verwenden, um Protokolle an CloudWatch zu senden.

   1. Speichern Sie den folgenden Inhalt in einer Datei namens `aws-logging-cloudwatch-configmap.yaml`. Ersetzen Sie den *region-code* durch die AWS-Region, in der sich Ihr Cluster befindet. Die Parameter unter `[OUTPUT]` sind erforderlich.

      ```
      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. Wenden Sie das Manifest auf Ihren Cluster an.

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

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

   Wenn Sie Protokolle an Amazon OpenSearch Service senden möchten, können Sie die [es](https://docs.fluentbit.io/manual/v/1.5/pipeline/outputs/elasticsearch)-Ausgabe verwenden, ein in C geschriebenes Plug-In. Das folgende Beispiel zeigt, wie Sie mit dem Plug-In Protokolle an OpenSearch senden können.

   1. Speichern Sie den folgenden Inhalt in einer Datei mit dem Namen `aws-logging-opensearch-configmap.yaml`. Ersetzen Sie jeden *Beispielwert* durch Ihre eigenen Werte.

      ```
      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. Wenden Sie das Manifest auf Ihren Cluster an.

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

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

   Beim Senden von Protokollen an Firehose haben Sie zwei Ausgabeoptionen:
   +  [kinesis\$1firehose](https://docs.fluentbit.io/manual/pipeline/outputs/firehose) – Ein in C geschriebenes Ausgabe-Plugin.
   +  [firehose](https://github.com/aws/amazon-kinesis-firehose-for-fluent-bit) – Ein in Golang geschriebenes Ausgabe-Plugin.

     Das folgende Beispiel zeigt Ihnen, wie Sie das `kinesis_firehose`-Plugin verwenden, um Protokolle an Firehose zu senden.

     1. Speichern Sie den folgenden Inhalt in einer Datei mit dem Namen `aws-logging-firehose-configmap.yaml`. Ersetzen Sie den *region-code* durch die AWS-Region, in der sich Ihr Cluster befindet.

        ```
        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. Wenden Sie das Manifest auf Ihren Cluster an.

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

------

1. Richten Sie Berechtigungen für die Fargate-Pod-Ausführungsrolle ein, um Protokolle an Ihr Ziel zu senden.

   1. Laden Sie die IAM-Richtlinie für Ihr Ziel auf Ihren Computer herunter.  
**Example**  

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

      Laden Sie die CloudWatch IAM-Richtlinie auf Ihren Computer herunter. Sie können die [Richtlinie](https://raw.githubusercontent.com/aws-samples/amazon-eks-fluent-logging-examples/mainline/examples/fargate/cloudwatchlogs/permissions.json) auch auf GitHub anzeigen.

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

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

      Laden Sie die OpenSearch-IAM-Richtlinie auf Ihren Computer herunter. Sie können die [Richtlinie](https://raw.githubusercontent.com/aws-samples/amazon-eks-fluent-logging-examples/mainline/examples/fargate/amazon-elasticsearch/permissions.json) auch auf GitHub anzeigen.

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

      Stellen Sie sicher, dass die Zugriffssteuerung von OpenSearch Dashboards richtig konfiguriert ist. Dem `all_access role` in OpenSearch-Dashboards muss die Fargate-Pod-Ausführungsrolle und die IAM-Rolle zugeordnet sein. Das gleiche Mapping muss für die `security_manager`-Rolle durchgeführt werden. Sie können die vorherigen Zuordnungen hinzufügen, indem Sie `Menu`, dann `Security`, dann `Roles` und dann die entsprechenden Rollen auswählen. Weitere Informationen finden Sie unter [Wie behebe ich Probleme mit CloudWatch Logs, damit es an meine Amazon-ES-Domain gestreamt wird?](https://aws.amazon.com/tr/premiumsupport/knowledge-center/es-troubleshoot-cloudwatch-logs/).

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

      Laden Sie die Firehose-IAM-Richtlinie auf Ihren Computer herunter. Sie können die [Richtlinie](https://raw.githubusercontent.com/aws-samples/amazon-eks-fluent-logging-examples/mainline/examples/fargate/kinesis-firehose/permissions.json) auch auf GitHub anzeigen.

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

------

   1. Erstellen Sie eine IAM-Richtlinie aus der heruntergeladenen Richtliniendatei.

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

   1. Hängen Sie die IAM-Richtlinie an die Pod-Ausführungsrolle an, die für Ihr Fargate-Profil angegeben ist, mit dem folgenden Befehl. Ersetzen Sie *111122223333* durch Ihre Konto-ID. Ersetzen Sie *AmazonEKSFargatePodExecutionRole* durch Ihre Pod-Ausführungsrolle (weitere Informationen finden Sie unter [Schritt 2: Fargate-Pod-Ausführungsrolle erstellen](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
      ```

### Support von Kubernetes-Filtern
<a name="fargate-logging-kubernetes-filter"></a>

Mit dem Fluent-Bit-Kubernetes-Filter können Sie Kubernetes-Metadaten zu Ihren Protokolldateien hinzufügen. Weitere Informationen über den Filter finden Sie unter [Kubernetes](https://docs.fluentbit.io/manual/pipeline/filters/kubernetes) in der Fluent-Bit-Dokumentation. Sie können einen Filter unter Verwendung des Endpunkts des API-Servers anwenden.

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

**Wichtig**  
 `Kube_URL`,`Kube_CA_File`,`Kube_Token_Command`, und `Kube_Token_File` sind Konfigurationsparameter im Servicebesitz und dürfen nicht angegeben werden. Amazon-EKS-Fargate füllt diese Werte aus.
 `Kube_Meta_Cache_TTL` ist die Zeit, in der Fluent Bit wartet, bis es mit dem API-Server für die neuesten Metadaten kommuniziert. Wenn `Kube_Meta_Cache_TTL` nicht angegeben wird, dann hängt Amazon EKS Fargate einen Standardwert von 30 Minuten an, um die Belastung des API-Servers zu verringern.

### So übermitteln Sie Fluent-Bit-Prozessprotokolle an Ihr Konto
<a name="ship-fluent-bit-process-logs"></a>

Sie können Fluent-Bit-Prozessprotokolle optional mit den folgenden `ConfigMap` an Amazon CloudWatch senden. Für den Versand von Fluent Bit-Prozessprotokollen an CloudWatch fallen zusätzliche Kosten für die Protokollaufnahme und Speicherung an. Ersetzen Sie den *region-code* durch die AWS-Region, in der sich Ihr Cluster befindet.

```
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
```

Die Protokolle befinden sich in CloudWatch in derselben AWS-Region wie der Cluster. Der Name der Protokollgruppe lautet ` my-cluster-fluent-bit-logs` und der Name des Fluent-Bit-Logstreams lautet `fluent-bit-podname-pod-namespace `.

**Anmerkung**  
Die Prozessprotokolle werden nur ausgeliefert, wenn der Fluent-Bit-Prozess erfolgreich gestartet wird. Wenn beim Starten von Fluent Bit ein Fehler auftritt, werden die Prozessprotokolle verpasst. Sie können nur Prozessprotokolle an CloudWatch senden.
Um Versandprozessprotokolle auf Ihr Konto zu debuggen, können Sie die vorherigen `ConfigMap` anwenden, um die Prozessprotokolle zu erhalten. Dass Fluent Bit nicht gestartet werden kann, liegt normalerweise daran, dass Ihr `ConfigMap` beim Starten nicht von Fluent Bit analysiert oder akzeptiert wird.

### So beenden Sie die Übermittlung von Fluent-Bit-Prozessprotokollen
<a name="stop-fluent-bit-process-logs"></a>

Für den Versand von Fluent Bit-Prozessprotokollen an CloudWatch fallen zusätzliche Kosten für die Protokollaufnahme und Speicherung an. Gehen Sie wie folgt vor, um Prozessprotokolle in einem vorhandenen `ConfigMap`-Setup auszuschließen.

1. Suchen Sie die CloudWatch-Protokollgruppe, die automatisch für die Fluent-Bit-Prozessprotokolle Ihres Amazon-EKS-Clusters erstellt wurde, nachdem Sie die Fargate-Protokollierung aktiviert haben. Es folgt dem Format ` my-cluster-fluent-bit-logs`.

1. Löschen Sie die vorhandenen CloudWatch-Protokollstreams, die für die Prozessprotokolle der einzelnen Pods in der CloudWatch-Protokollgruppe erstellt wurden.

1. Bearbeiten Sie die `ConfigMap` und stellen Sie `flb_log_cw: "false"` ein.

1. Starten Sie alle vorhandenen Pods im Cluster neu.

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

1. Stellen Sie einen Beispiel-Pod bereit.

   1. Speichern Sie den folgenden Inhalt in einer Datei mit dem Namen `sample-app.yaml` auf Ihrem Computer.

      ```
      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. Wenden Sie das Manifest auf den Cluster an.

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

1. Zeigen Sie die NGINX-Protokolle mit den Zielen an, die Sie im `ConfigMap`.

## Größenüberlegungen
<a name="fargate-logging-size-considerations"></a>

Wir empfehlen Ihnen, für den Protokoll-Router bis zu 50 MB Speicher einzuplanen. Wenn Sie erwarten, dass Ihre Anwendung Protokolle mit sehr hohem Durchsatz generiert, sollten Sie bis zu 100 MB einplanen.

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

Um zu überprüfen, ob das Protokollierungs-Feature aus irgendeinem Grund aktiviert oder deaktiviert ist, z. B. ein ungültiges `ConfigMap`, und warum es ungültig ist, überprüfen Sie Ihre Pod-Ereignisse mit `kubectl describe pod pod-name `. Die Ausgabe kann Pod-Ereignisse enthalten, die klarstellen, ob die Protokollierung aktiviert ist oder nicht, wie die folgende Beispielausgabe.

```
[...]
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
```

Die Pod-Ereignisse sind kurzlebig mit einem Zeitraum, der von den Einstellungen abhängt. Sie können die Annotationen eines Pods auch mit `kubectl describe pod pod-name ` anzeigen. In der Pod-Annotation finden Sie Informationen darüber, ob die Protokollierungs-Feature aktiviert oder deaktiviert ist, und den Grund.