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.
# Bereitstellen von Fluent Bit in Amazon-ECS-Windows-Containers
Fluent Bit ist ein schneller und flexibler Protokollprozessor und Router, der von verschiedenen Betriebssystemen unterstützt wird. Es kann verwendet werden, um Protokolle an verschiedene AWS Ziele wie Amazon CloudWatch Logs, Firehose Amazon S3 und Amazon OpenSearch Service weiterzuleiten. Fluent Bit unterstützt gängige Partnerlösungen wie [Datadog](https://www.datadoghq.com/), [Splunk](https://www.splunk.com/) und benutzerdefinierte HTTP-Server. Weitere Informationen zu Fluent Bit finden Sie auf der [https://fluentbit.io/](https://fluentbit.io/)-Website.
Das **AWS -for-Fluent-Bit**-Image ist in Amazon ECR sowohl in der Amazon ECR Public Gallery als auch in einem Amazon-ECR-Repository in den meisten Regionen für hohe Verfügbarkeit verfügbar. Weitere Informationen finden Sie [https://github.com/aws/aws-for-fluent-bit](https://github.com/aws/aws-for-fluent-bit)auf der GitHub Website.
In diesem Tutorial erfahren Sie, wie Sie Fluent Bit-Container auf ihren Windows-Instances bereitstellen, die in Amazon ECS ausgeführt werden, um von den Windows-Aufgaben generierte Protokolle CloudWatch zur zentralen Protokollierung an Amazon zu streamen.
Dieses Tutorial verwendet den folgenden Ansatz:
+ Fluent Bit wird als Service mit der Daemon-Planungstrategie ausgeführt. Diese Strategie stellt sicher, dass eine einzelne Instance von Fluent Bit immer auf den Container-Instances im Cluster ausgeführt wird.
+ Überwacht Port 24224 mithilfe des Weiterleitungs-Eingabe-Plugins.
+ Stellen Sie Port 24224 für den Host bereit, damit die Docker-Laufzeit über diesen bereitgestellten Port Protokolle an Fluent Bit senden kann.
+ Verfügt über eine Konfiguration, die es Fluent Bit ermöglicht, die Protokolldatensätze an bestimmte Ziele zu senden.
+ Starten Sie alle anderen Amazon-ECS-Aufgaben-Container mit dem Fluentd-Protokollierungstreiber. Weitere Informationen finden Sie unter [Fluentd-Protokollierungstreiber](https://docs.docker.com/engine/logging/drivers/fluentd/) auf der Website der Docker-Dokumentation.
+ Docker stellt eine Verbindung zum TCP-Socket 24224 auf localhost innerhalb des Host-Namespace her.
+ Der Amazon-ECS-Agent fügt den Containern Labels hinzu, die den Cluster-Namen, den Familiennamen der Aufgabendefinition, die Revisionsnummer der Aufgabendefinition, den ARN der Aufgabe und den Containernamen enthalten. Die gleichen Informationen werden dem Protokolldatensatz mithilfe der Labels-Option des Fluentd-Docker-Protokollierungstreibers hinzugefügt. Weitere Informationen finden Sie unter [labels, labels-regex, env und env-regex](https://docs.docker.com/config/containers/logging/fluentd/#labels-labels-regex-env-and-env-regex) auf der Website der Docker-Dokumentation.
+ Da die `async`-Option des Fluentd-Protokollierungstreibers auf `true` festgelegt ist, puffert Docker beim Neustart des Fluent-Bit-Containers die Protokolle, bis der Fluent-Bit-Container neu gestartet wird. Sie können das Pufferlimit erhöhen, indem Sie die fluentd-buffer-limit Option festlegen. Weitere Informationen finden Sie [fluentd-buffer-limit](https://docs.docker.com/config/containers/logging/fluentd/#fluentd-buffer-limit)auf der Docker-Dokumentationswebsite.
Der Arbeitsablauf ist wie folgt:
+ Der Fluent-Bit-Container startet und überwacht auf Port 24224, der für den Host bereitgestellt ist.
+ Fluent Bit verwendet die in der Aufgabendefinition angegebenen IAM-Rollen-Anmeldeinformationen.
+ Andere Aufgaben, die auf derselben Instance gestartet werden, verwenden den Fluentd-Docker-Protokollierungstreiber, um eine Verbindung zum Fluent-Bit-Container auf Port 24224 herzustellen.
+ Wenn die Anwendungscontainer Protokolle generieren, markiert die Docker-Laufzeit diese Datensätze, fügt zusätzliche in Labels angegebene Metadaten hinzu und leitet sie dann an Port 24224 im Host-Namespace weiter.
+ Fluent Bit empfängt den Protokolldatensatz auf Port 24224, da dieser für den Host-Namespace bereitgestellt ist.
+ Fluent Bit führt seine interne Verarbeitung durch und leitet die Protokolle wie angegeben weiter.
In diesem Tutorial wird die CloudWatch Fluent Bit-Standardkonfiguration verwendet, die Folgendes bewirkt:
+ Erstellt eine neue Protokollgruppe für jeden Cluster und jede Aufgabendefinitionsfamilie.
+ Erstellt einen neuen Protokollstream für jeden Aufgaben-Container in der oben generierten Protokollgruppe, wenn eine neue Aufgabe gestartet wird. Jeder Stream wird mit der Aufgaben-ID gekennzeichnet, zu der der Container gehört.
+ Fügt zusätzliche Metadaten hinzu, einschließlich Cluster-Name, Aufgaben-ARN, Aufgaben-Containername, Aufgabendefinitionsfamilie und Revisionsnummer der Aufgabendefinition in jedem Protokolleintrag.
Wenn Sie beispielsweise with `container_1` and `container_2` und t `task_1` `ask_2` with haben`container_3`, dann sind die CloudWatch Log-Streams im Folgenden aufgeführt:
+ `/aws/ecs/windows.ecs_task_1`
`task-out.TASK_ID.container_1`
`task-out.TASK_ID.container_2`
+ `/aws/ecs/windows.ecs_task_2`
`task-out.TASK_ID.container_3`
**Anmerkung**
Sie können Dual-Stack-Service-Endpunkte verwenden, um mit Amazon ECS über die AWS CLI SDKs, und die Amazon ECS-API sowohl über als auch IPv4 zu interagieren. IPv6 Weitere Informationen finden Sie unter [Verwenden von Dual-Stack-Endpunkten in Amazon ECS](dual-stack-endpoint.md).
**Topics**
+ [Voraussetzungen](#tutorial-deploy-fluentbit-on-windows-prereqs)
+ [Schritt 1: Erstellen der IAM-Zugriffsrollen](#tutorial-deploy-fluentbit-on-windows-iam-access-role)
+ [Schritt 2: Erstellen der Amazon-ECS-Windows-Container-Instance](#tutorial-deploy-fluentbit-on-windows-instance)
+ [Schritt 3: Konfigurieren von Fluent Bit](#tutorial-deploy-fluentbit-on-windows-configure-fluentbit)
+ [Schritt 4: Registrieren Sie eine Windows Fluent Bit-Aufgabendefinition, an die die Protokolle weitergeleitet werden CloudWatch](#tutorial-deploy-fluentbit-on-windows-register-task-definition)
+ [Schritt 5: Ausführen der `ecs-windows-fluent-bit`-Aufgabendefinition als Amazon-ECS-Service mithilfe der Daemon-Planungsstrategie](#tutorial-deploy-fluentbit-on-windows-run-task)
+ [Schritt 6: Registrieren einer Windows-Aufgabendefinition, die die Protokolle generiert](#tutorial-deploy-fluentbit-on-windows-register-task-def-logs)
+ [Schritt 7: Ausführen der `windows-app-task`-Aufgabendefinition](#tutorial-deploy-fluentbit-on-windows-run-task-fluentbit)
+ [Schritt 8: Überprüfen Sie die Anmeldung CloudWatch](#tutorial-deploy-fluentbit-on-windows-verify)
+ [Schritt 9: Bereinigen](#tutorial-deploy-fluentbit-on-windows-cleanup)
## Voraussetzungen
In diesem Tutorial wird davon ausgegangen, dass die folgenden Voraussetzungen erfüllt wurden:
+ Die neueste Version von AWS CLI ist installiert und konfiguriert. Weitere Informationen finden Sie unter [Installieren oder Aktualisierung auf die neueste Version der AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ Das `aws-for-fluent-bit`-Container-Image ist für die folgenden Windows-Betriebssysteme verfügbar:
+ Windows Server 2019 Core
+ Windows Server 2019 Full
+ Windows Server 2022 Kern
+ Windows Server 2022 Voll
+ Die Schritte in [Einrichtung für die Verwendung von Amazon ECS](get-set-up-for-amazon-ecs.md) wurden ausgeführt.
+ Sie verfügen über einen Cluster. In diesem Tutorial lautet der Clustername **FluentBit-cluster**.
+ Sie verfügen über eine VPC mit einem öffentlichen Subnetz, in dem die EC2-Instance gestartet werden soll. Sie können Ihre Standard-VPC verwenden. Sie können auch ein privates Subnetz verwenden, das es CloudWatch Amazon-Endpunkten ermöglicht, das Subnetz zu erreichen. Weitere Informationen zu CloudWatch Amazon-Endpunkten finden Sie unter [ CloudWatch Amazon-Endpunkte und Kontingente](https://docs.aws.amazon.com/general/latest/gr/cw_region.html) in der. *Allgemeine AWS-Referenz* Informationen zur Verwendung des Amazon-VPC-Assistenten zum Erstellen einer VPC finden Sie unter [Erstellen einer Virtual Private Cloud](get-set-up-for-amazon-ecs.md#create-a-vpc).
## Schritt 1: Erstellen der IAM-Zugriffsrollen
Erstellen Sie die Amazon-IAM-Rollen.
1. Erstellen Sie die Amazon ECS-Container-Instance-Rolle mit dem Namen "ecsInstanceRole“. Weitere Informationen finden Sie unter [IAM-Rolle der Amazon-ECS-Container-Instance](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/instance_IAM_role.html).
1. Erstellen Sie eine IAM-Rolle für die Fluent-Bit-Aufgabe mit dem Namen `fluentTaskRole`. Weitere Informationen finden Sie unter [Aufgaben-IAM-Rolle für Amazon ECS](task-iam-roles.md).
Die in dieser IAM-Rolle gewährten IAM-Berechtigungen werden von den Aufgaben-Containern übernommen. Damit Fluent Bit Protokolle an senden kann CloudWatch, müssen Sie der Task-IAM-Rolle die folgenden Berechtigungen zuordnen.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogStream",
"logs:CreateLogGroup",
"logs:DescribeLogStreams",
"logs:PutLogEvents"
],
"Resource": "*"
}
]
}
```
------
1. Fügen Sie der Rolle die -Richtlinie an.
1. Speichern Sie den obigen Inhalt in einer Datei mit dem Namen `fluent-bit-policy.json`.
1. Führen Sie den folgenden Befehl aus, um die Inline-Richtlinie der `fluentTaskRole`-IAM-Rolle anzufügen.
```
aws iam put-role-policy --role-name fluentTaskRole --policy-name fluentTaskPolicy --policy-document file://fluent-bit-policy.json
```
## Schritt 2: Erstellen der Amazon-ECS-Windows-Container-Instance
Erstellen Sie eine Windows-Container-Instance für Amazon ECS.
**So erstellen Sie eine Amazon-ECS-Instance**
1. Verwenden Sie den `aws ssm get-parameters`-Befehl, um die AMI-ID für die Region abzurufen, in der Ihre VPC gehostet wird. Weitere Informationen finden Sie unter [Abrufen von Amazon-ECS-optimierten AMI-Metadaten](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/retrieve-ecs-optimized_windows_AMI.html).
1. Verwenden Sie die Amazon-EC2-Konsole, um die Instance zu starten.
1. Öffnen Sie die Amazon-EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Wählen Sie die zu verwendende Region in der Navigationsleiste aus.
1. Wählen Sie im **EC2-Dashboard** **Launch Instance (Instance starten)** aus.
1. Geben Sie für **Name** einen eindeutigen Namen ein.
1. Wählen Sie für **Application and OS Images (Amazon Machine Image)** (Anwendungs- und Betriebssystem-Images (Amazon-Computer-Image)) das AMI aus, das Sie im ersten Schritt abgerufen haben.
1. Wählen Sie für **Instance type** die Option `t3.xlarge` aus.
1. Wählen Sie für **Key pair (login)** (Schlüsselpaar (Anmeldung)) ein Schlüsselpaar aus.
1. Wählen Sie unter **Network settings** (Netzwerkeinstellungen) für **Security group** (Sicherheitsgruppe) eine vorhandene Sicherheitsgruppe aus oder erstellen Sie eine neue.
1. Wählen Sie unter **Network settings** (Netzwerkeinstellungen), für **Auto-assign Public IP** (Öffentliche IP automatisch zuweisen), die Option **Enable** (Aktivieren) aus.
1. Wählen Sie unter **Erweiterte Details** für das **IAM-Instanzprofil** die Option. **ecsInstanceRole**
1. Konfigurieren Sie Ihre Amazon-ECS-Container-Instance mit den folgenden Benutzerdaten. Fügen Sie unter **Erweiterte Details** das folgende Skript in das Feld **Benutzerdaten** ein und *cluster\$1name* ersetzen Sie es durch den Namen Ihres Clusters.
```
Import-Module ECSTools
Initialize-ECSAgent -Cluster cluster-name -EnableTaskENI -EnableTaskIAMRole -LoggingDrivers '["awslogs","fluentd"]'
```
1. Wenn Sie bereit sind, wählen Sie das Bestätigungsfeld und danach **Launch Instances** aus.
1. Auf einer Bestätigungsseite wird Ihnen mitgeteilt, dass die Instance gestartet wird. Wählen Sie **View Instances** aus, um die Bestätigungsseite zu schließen und zur Konsole zurückzukehren.
## Schritt 3: Konfigurieren von Fluent Bit
Sie können die folgende Standardkonfiguration von verwenden AWS , um schnell loszulegen:
+ [Amazon CloudWatch](https://github.com/aws/aws-for-fluent-bit/blob/mainline/ecs_windows_forward_daemon/cloudwatch.conf), das auf dem Fluent Bit-Plug-In für [ CloudWatchAmazon](https://docs.fluentbit.io/manual/v/1.9-pre/pipeline/outputs/cloudwatch) im *offiziellen Fluent Bit-Handbuch* basiert.
Alternativ können Sie andere Standardkonfigurationen verwenden, die von bereitgestellt werden. AWS Weitere Informationen finden Sie unter [Überschreiben des Einstiegspunkts für das Windows-Image](https://github.com/aws/aws-for-fluent-bit/tree/mainline/ecs_windows_forward_daemon#overriding-the-entrypoint-for-the-windows-image) auf der `aws-for-fluent-bit`-Github-Website.
Die Standardkonfiguration von Amazon CloudWatch Fluent Bit ist unten dargestellt.
Ersetzen Sie die folgenden Variablen:
+ *region*mit der Region, in die Sie die CloudWatch Amazon-Protokolle senden möchten.
```
[SERVICE]
Flush 5
Log_Level info
Daemon off
[INPUT]
Name forward
Listen 0.0.0.0
Port 24224
Buffer_Chunk_Size 1M
Buffer_Max_Size 6M
Tag_Prefix ecs.
# Amazon ECS agent adds the following log keys as labels to the docker container.
# We would use fluentd logging driver to add these to log record while sending it to Fluent Bit.
[FILTER]
Name modify
Match ecs.*
Rename com.amazonaws.ecs.cluster ecs_cluster
Rename com.amazonaws.ecs.container-name ecs_container_name
Rename com.amazonaws.ecs.task-arn ecs_task_arn
Rename com.amazonaws.ecs.task-definition-family ecs_task_definition_family
Rename com.amazonaws.ecs.task-definition-version ecs_task_definition_version
[FILTER]
Name rewrite_tag
Match ecs.*
Rule $ecs_task_arn ^([a-z-:0-9]+)/([a-zA-Z0-9-_]+)/([a-z0-9]+)$ out.$3.$ecs_container_name false
Emitter_Name re_emitted
[OUTPUT]
Name cloudwatch_logs
Match out.*
region region
log_group_name fallback-group
log_group_template /aws/ecs/$ecs_cluster.$ecs_task_definition_family
log_stream_prefix task-
auto_create_group On
```
Jedes Protokoll, das in Fluent Bit eingeht, verfügt über ein Tag, das Sie angeben, oder wird automatisch generiert, wenn Sie keins angeben. Die Tags können verwendet werden, um verschiedene Protokolle an verschiedene Ziele weiterzuleiten. Weitere Informationen finden Sie unter [Tag](https://docs.fluentbit.io/manual/concepts/key-concepts#tag) im *offiziellen Fluent-Bit-Handbuch*.
Die oben beschriebene Fluent-Bit-Konfiguration hat die folgenden Eigenschaften:
+ Das Weiterleitungs-Eingabe-Plugin überwacht auf eingehendem Datenverkehr auf TCP-Port 24224.
+ Jeder an diesem Port empfangene Protokolleintrag verfügt über ein Tag, das das Weiterleitungs-Eingabe-Plugin ändert, um dem Datensatz eine `ecs.`-Zeichenfolge voranzustellen.
+ Die interne Fluent-Bit-Pipeline leitet den Protokolleintrag weiter, um den Filter mithilfe des regulären Ausdrucks „Match“ zu ändern. Dieser Filter ersetzt die Schlüssel im JSON-Protokolldatensatz durch das Format, das Fluent Bit verarbeiten kann.
+ Der geänderte Protokolleintrag wird dann vom rewrite\$1tag-Filter verarbeitet. Dieser Filter ändert das Tag des Protokolldatensatzes auf das Ausgangsformat. *TASK\$1ID*. *CONTAINER\$1NAME*.
+ Das neue Tag wird an das Output-Plug-In cloudwatch\$1logs weitergeleitet, das die Protokollgruppen und Streams wie zuvor beschrieben mithilfe der `log_stream_prefix` Optionen `log_group_template` und des Ausgabe-Plug-ins erstellt. CloudWatch Weitere Informationen finden Sie unter [Konfigurationsparameter](https://docs.fluentbit.io/manual/v/1.9-pre/pipeline/outputs/cloudwatch#configuration-parameters) im *offiziellen Fluent-Bit-Handbuch*.
## Schritt 4: Registrieren Sie eine Windows Fluent Bit-Aufgabendefinition, an die die Protokolle weitergeleitet werden CloudWatch
Registrieren Sie eine Windows Fluent Bit-Aufgabendefinition, an die die Protokolle weitergeleitet werden. CloudWatch
**Anmerkung**
Diese Aufgabendefinition stellt den Fluent Bit-Container-Port 24224 für den Host-Port 24224 bereit. Stellen Sie sicher, dass dieser Port nicht in Ihrer EC2-Instance-Sicherheitsgruppe geöffnet ist, um externen Zugriff zu verhindern.
**So registrieren Sie eine Aufgabendefinition**
1. Erstellen Sie eine Datei mit dem Namen `fluent-bit.json` und dem folgenden Inhalt.
Ersetzen Sie die folgenden Variablen:
+ *task-iam-role*mit dem Amazon-Ressourcennamen (ARN) Ihrer Task-IAM-Rolle
+ *region*mit der Region, in der Ihre Aufgabe ausgeführt wird
```
{
"family": "ecs-windows-fluent-bit",
"taskRoleArn": "task-iam-role",
"containerDefinitions": [
{
"name": "fluent-bit",
"image": "public.ecr.aws/aws-observability/aws-for-fluent-bit:windowsservercore-latest",
"cpu": 512,
"portMappings": [
{
"hostPort": 24224,
"containerPort": 24224,
"protocol": "tcp"
}
],
"entryPoint": [
"Powershell",
"-Command"
],
"command": [
"C:\\entrypoint.ps1 -ConfigFile C:\\ecs_windows_forward_daemon\\cloudwatch.conf"
],
"environment": [
{
"name": "AWS_REGION",
"value": "region"
}
],
"memory": 512,
"essential": true,
"logConfiguration": {
"logDriver": "awslogs",
"options": {
"awslogs-group": "/ecs/fluent-bit-logs",
"awslogs-region": "region",
"awslogs-stream-prefix": "flb",
"awslogs-create-group": "true"
}
}
}
],
"memory": "512",
"cpu": "512"
}
```
1. Führen Sie den folgenden Befehl aus, um die Aufgabendefinition zu registrieren.
```
aws ecs register-task-definition --cli-input-json file://fluent-bit.json --region region
```
Sie können die Aufgabendefinitionen für Ihr Konto auflisten, indem Sie den `list-task-definitions`-Befehl ausführen. Die Ausgabe zeigt die Familien- und Revisionswerte an, die Sie zusammen mit `run-task` oder `start-task` verwenden können.
## Schritt 5: Ausführen der `ecs-windows-fluent-bit`-Aufgabendefinition als Amazon-ECS-Service mithilfe der Daemon-Planungsstrategie
Nachdem Sie eine Aufgabendefinition für Ihr Konto registriert haben, können Sie eine Aufgabe im Cluster ausführen. Für dieses Tutorial führen Sie eine Instance der `ecs-windows-fluent-bit:1`-Aufgabendefinition in Ihrem `FluentBit-cluster`-Cluster aus. Führen Sie die Aufgabe in einem Service aus, der die Daemon-Planungsstrategie verwendet, die sicherstellt, dass auf jeder Ihrer Container-Instances immer eine einzige Instance von Fluent Bit ausgeführt wird.
**Ausführen einer Aufgabe**
1. Führen Sie den folgenden Befehl aus, um die `ecs-windows-fluent-bit:1`-Aufgabendefinition (im vorherigen Schritt registriert) als Service zu starten.
**Anmerkung**
Diese Aufgabendefinition verwendet den `awslogs`-Protokollierungstreiber. Ihre Container Instance muss über die erforderlichen Berechtigungen verfügen.
Ersetzen Sie die folgenden Variablen:
+ *region*mit der Region, in der Ihr Dienst ausgeführt wird
```
aws ecs create-service \
--cluster FluentBit-cluster \
--service-name FluentBitForwardDaemonService \
--task-definition ecs-windows-fluent-bit:1 \
--launch-type EC2 \
--scheduling-strategy DAEMON \
--region region
```
1. Führen Sie den folgenden Befehl aus, um Ihre Aufgaben aufzulisten.
Ersetzen Sie die folgenden Variablen:
+ *region*mit der Region, in der Ihre Serviceaufgaben ausgeführt werden
```
aws ecs list-tasks --cluster FluentBit-cluster --region region
```
## Schritt 6: Registrieren einer Windows-Aufgabendefinition, die die Protokolle generiert
Registrieren Sie eine Aufgabendefinition, die die Protokolle generiert. Diese Aufgabendefinition stellt ein Windows-Container-Image bereit, das jede Sekunde eine inkrementelle Zahl in `stdout` schreibt.
Die Aufgabendefinition verwendet den Fluentd-Protokollierungstreiber, der eine Verbindung zu Port 24224 herstellt, den das Fluent-Bit-Plugin überwacht. Der Amazon-ECS-Agent kennzeichnet jeden Amazon-ECS-Container mit Tags, einschließlich Cluster-Name, Aufgaben-ARN, Familienname der Aufgabendefinition, Revisionsnummer der Aufgabendefinition und Name des Aufgaben-Containers. Diese Schlüsselwert-Labels werden an Fluent Bit übermittelt.
**Anmerkung**
Diese Aufgabe verwendet den `default`-Netzwerkmodus. Sie können jedoch auch den `awsvpc`-Netzwerkmodus mit der Aufgabe verwenden.
**So registrieren Sie eine Aufgabendefinition**
1. Erstellen Sie eine Datei mit dem Namen `windows-app-task.json` und dem folgenden Inhalt.
```
{
"family": "windows-app-task",
"containerDefinitions": [
{
"name": "sample-container",
"image": "mcr.microsoft.com/windows/servercore:ltsc2019",
"cpu": 512,
"memory": 512,
"essential": true,
"entryPoint": [
"Powershell",
"-Command"
],
"command": [
"$count=1;while(1) { Write-Host $count; sleep 1; $count=$count+1;}"
],
"logConfiguration": {
"logDriver": "fluentd",
"options": {
"fluentd-address": "localhost:24224",
"tag": "{{ index .ContainerLabels \"com.amazonaws.ecs.task-definition-family\" }}",
"fluentd-async": "true",
"labels": "com.amazonaws.ecs.cluster,com.amazonaws.ecs.container-name,com.amazonaws.ecs.task-arn,com.amazonaws.ecs.task-definition-family,com.amazonaws.ecs.task-definition-version"
}
}
}
],
"memory": "512",
"cpu": "512"
}
```
1. Führen Sie den folgenden Befehl aus, um die Aufgabendefinition zu registrieren.
Ersetzen Sie die folgenden Variablen:
+ *region*mit der Region, in der Ihre Aufgabe ausgeführt wird
```
aws ecs register-task-definition --cli-input-json file://windows-app-task.json --region region
```
Sie können die Aufgabendefinitionen für Ihr Konto auflisten, indem Sie den `list-task-definitions`-Befehl ausführen. Die Ausgabe zeigt die Familien- und Revisionswerte an, die Sie zusammen mit `run-task` oder `start-task` verwenden können.
## Schritt 7: Ausführen der `windows-app-task`-Aufgabendefinition
Nachdem Sie die `windows-app-task`-Aufgabendefinition registriert haben, führen Sie sie in Ihrem `FluentBit-cluster`-Cluster aus.
**Ausführen einer Aufgabe**
1. Führen Sie die `windows-app-task:1`-Aufgabendefinition aus, die Sie im vorherigen Schritt registriert haben.
Ersetzen Sie die folgenden Variablen:
+ *region*mit der Region, in der Ihre Aufgabe ausgeführt wird
```
aws ecs run-task --cluster FluentBit-cluster --task-definition windows-app-task:1 --count 2 --region region
```
1. Führen Sie den folgenden Befehl aus, um Ihre Aufgaben aufzulisten.
```
aws ecs list-tasks --cluster FluentBit-cluster
```
## Schritt 8: Überprüfen Sie die Anmeldung CloudWatch
Um Ihr Fluent Bit-Setup zu überprüfen, suchen Sie in der CloudWatch Konsole nach den folgenden Protokollgruppen:
+ `/ecs/fluent-bit-logs` – Dies ist die Protokollgruppe, die dem Fluent-Bit-Daemon-Container entspricht, der auf der Container-Instance ausgeführt wird.
+ `/aws/ecs/FluentBit-cluster.windows-app-task` – Dies ist die Protokollgruppe, die allen Aufgaben entspricht, die für die `windows-app-task`-Aufgabendefinitionsfamilie innerhalb des `FluentBit-cluster`-Clusters gestartet wurden.
`task-out.FIRST_TASK_ID.sample-container` – Dieser Protokollstream enthält alle Protokolle, die von der ersten Instance der Aufgabe im Beispielcontainer bzw. Aufgaben-Container generiert wurden.
`task-out.SECOND_TASK_ID.sample-container` – Dieser Protokollstream enthält alle Protokolle, die von der zweiten Instance der Aufgabe im Beispielcontainer bzw. Aufgaben-Container generiert wurden.
Der `task-out.TASK_ID.sample-container`-Protokollstream hat Felder, die den folgenden ähneln:
```
{
"source": "stdout",
"ecs_task_arn": "arn:aws:ecs:region:0123456789012:task/FluentBit-cluster/13EXAMPLE",
"container_name": "/ecs-windows-app-task-1-sample-container-cEXAMPLE",
"ecs_cluster": "FluentBit-cluster",
"ecs_container_name": "sample-container",
"ecs_task_definition_version": "1",
"container_id": "61f5e6EXAMPLE",
"log": "10",
"ecs_task_definition_family": "windows-app-task"
}
```
**So überprüfen Sie die Fluent-Bit-Einrichtung**
1. Öffnen Sie die CloudWatch Konsole unter. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)
1. Wählen Sie im Navigationsbereich **Protokollgruppen** aus. Stellen Sie sicher, dass Sie sich in der Region befinden, in der Sie Fluent Bit für Ihre Container bereitgestellt haben.
In der Liste der Protokollgruppen in der AWS-Region sollten Sie Folgendes sehen:
+ `/ecs/fluent-bit-logs`
+ `/aws/ecs/FluentBit-cluster.windows-app-task`
Wenn Sie diese Protokollgruppen sehen, wurde die Fluent-Bit-Einrichtung verifiziert.
## Schritt 9: Bereinigen
Wenn Sie dieses Tutorial abgeschlossen haben, sollten Sie die damit verknüpften Ressourcen bereinigen, um zu vermeiden, dass für nicht verwendete Ressourcen Kosten entstehen.
**So bereinigen Sie die Tutorial-Ressourcen**
1. Halten Sie die `windows-simple-task`-Aufgabe und die `ecs-fluent-bit`-Aufgabe an. Weitere Informationen finden Sie unter [Beenden einer Amazon-ECS-Aufgabe](standalone-task-stop.md).
1. Verwenden Sie den folgenden Befehl, um die `/ecs/fluent-bit-logs`-Protokollgruppe zu löschen. Weitere Informationen zum Löschen von Protokollgruppen finden Sie [delete-log-group](https://docs.aws.amazon.com/cli/latest/reference/logs/delete-log-group.html)in der *AWS Command Line Interface Referenz*.
```
aws logs delete-log-group --log-group-name /ecs/fluent-bit-logs
aws logs delete-log-group --log-group-name /aws/ecs/FluentBit-cluster.windows-app-task
```
1. Führen Sie den folgenden Befehl aus, um die Instance zu beenden.
```
aws ec2 terminate-instances --instance-ids instance-id
```
1. Führen Sie den folgenden Befehl aus, um die IAM-Rollen zu löschen.
```
aws iam delete-role --role-name ecsInstanceRole
aws iam delete-role --role-name fluentTaskRole
```
1. Führen Sie den folgenden Befehl aus, um den Amazon-ECS-Cluster zu löschen.
```
aws ecs delete-cluster --cluster FluentBit-cluster
```