Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Déploiement de Fluent Bit sur Amazon ECS pour des conteneurs Windows
Fluent Bit est un processeur et un routeur de journaux rapides et flexibles pris en charge par différents systèmes d'exploitation. Il peut être utilisé pour acheminer les journaux vers diverses AWS destinations telles qu'Amazon CloudWatch Logs, Firehose, Amazon S3 et Amazon OpenSearch Service. Fluent Bit prend en charge des solutions partenaires courantes, comme [Datadog](https://www.datadoghq.com/), [Splunk](https://www.splunk.com/) et les serveurs HTTP personnalisés. Pour plus d'informations sur Fluent Bit, consultez le site web [https://fluentbit.io/](https://fluentbit.io/).
L'image **AWS pour Fluent Bit** est disponible sur Amazon ECR à la fois sur la galerie publique Amazon ECR et dans un référentiel Amazon ECR dans la plupart des Régions pour une haute disponibilité. Pour plus d'informations, consultez [https://github.com/aws/aws-for-fluent-bit](https://github.com/aws/aws-for-fluent-bit)le GitHub site Web.
Ce didacticiel explique comment déployer des conteneurs Fluent Bit sur leurs instances Windows exécutées dans Amazon ECS afin de diffuser les journaux générés par les tâches Windows vers Amazon CloudWatch pour une journalisation centralisée.
Ce didacticiel utilise l'approche suivante :
+ Fluent Bit fonctionne comme un service avec la stratégie de planification du démon. Cette stratégie garantit qu'une seule instance de Fluent Bit s'exécute toujours sur les instances de conteneur du cluster.
+ Écoute sur le port 24224 à l'aide du plug-in d'entrée directe.
+ Expose le port 24224 à l'hôte afin que le moteur d'exécution du docker puisse envoyer des journaux à Fluent Bit en utilisant ce port exposé.
+ Dispose d'une configuration qui permet à Fluent Bit d'envoyer les enregistrements des journaux vers des destinations spécifiées.
+ Lancement de tous les autres conteneurs de tâches Amazon ECS à l'aide du pilote de journalisation Fluentd. Pour plus d'informations, consultez [Fluentd logging drive](https://docs.docker.com/engine/logging/drivers/fluentd/) (Pilote de journalisation Fluentd) sur le site Web de la documentation de Docker.
+ Docker se connecte au socket TCP 24224 sur localhost dans l'espace de noms de l'hôte.
+ L'agent Amazon ECS ajoute des étiquettes aux conteneurs, notamment le nom du cluster, le nom de famille de la définition de la tâche, le numéro de révision de la définition de la tâche, l'ARN de la tâche et le nom du conteneur. Les mêmes informations sont ajoutées à l'enregistrement du journal à l'aide de l'option labels du pilote de journalisation fluentd de Docker. Pour de plus amples informations, veuillez consulter [labels, labels-regex, env, and env-regex](https://docs.docker.com/config/containers/logging/fluentd/#labels-labels-regex-env-and-env-regex) sur le site web de la documentation de Docker.
+ Comme l'option `async` du pilote de journalisation Fluentd est définie sur `true`, lorsque le conteneur Fluent Bit est redémarré, Docker met les journaux en mémoire tampon jusqu'à ce que le conteneur Fluent Bit soit redémarré. Vous pouvez augmenter la limite de mémoire tampon en définissant l'option fluentd-buffer-limit. Pour plus d'informations, consultez [fluentd-buffer-limit](https://docs.docker.com/config/containers/logging/fluentd/#fluentd-buffer-limit) sur le site Web de la documentation de Docker.
Le flux de travail est le suivant :
+ Le conteneur Fluent Bit démarre et écoute sur le port 24224 qui est exposé à l'hôte.
+ Fluent Bit utilise les informations d'identification du rôle IAM de la tâche spécifiées dans sa définition de tâche.
+ Les autres tâches lancées sur la même instance utilisent le pilote de journalisation fluentd de Docker pour se connecter au conteneur Fluent Bit sur le port 24224.
+ Lorsque les conteneurs d'applications génèrent des journaux, le moteur d'exécution de Docker étiquette ces enregistrements, ajoute des métadonnées supplémentaires spécifiées dans les étiquettes, puis les transmet sur le port 24224 de l'espace de noms de l'hôte.
+ Fluent Bit reçoit l'enregistrement du journal sur le port 24224 car il est exposé à l'espace de noms de l'hôte.
+ Fluent Bit effectue son traitement interne et achemine les journaux comme spécifié.
Ce didacticiel utilise la configuration CloudWatch Fluent Bit par défaut qui effectue les opérations suivantes :
+ Crée un nouveau groupe de journaux pour chaque cluster et chaque famille de définitions de tâches.
+ Crée un nouveau flux de journaux pour chaque conteneur de tâches du groupe de journaux généré ci-dessus chaque fois qu'une nouvelle tâche est lancée. Chaque flux sera marqué avec l'identifiant de tâche à laquelle le conteneur appartient.
+ Ajoute des métadonnées supplémentaires, notamment le nom du cluster, l'ARN de la tâche, le nom du conteneur de la tâche, la famille de définitions de la tâche et le numéro de révision de la définition de la tâche dans chaque entrée du journal.
Par exemple, si vous avez `task_1` with `container_1` `container_2` et t `ask_2` with`container_3`, les flux de CloudWatch log sont les suivants :
+ `/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`
**Note**
Vous pouvez utiliser des points de terminaison de service à double pile pour interagir avec Amazon ECS à partir des AWS CLI SDK et de l'API Amazon ECS sur IPv4 et IPv6. Pour de plus amples informations, veuillez consulter [Utilisation des points de terminaison à double pile Amazon ECS](dual-stack-endpoint.md).
**Topics**
+ [Conditions préalables](#tutorial-deploy-fluentbit-on-windows-prereqs)
+ [Étape 1 : Créer les rôles IAM d'accès](#tutorial-deploy-fluentbit-on-windows-iam-access-role)
+ [Étape 2 : Créer une instance de conteneur Windows Amazon ECS](#tutorial-deploy-fluentbit-on-windows-instance)
+ [Étape 3 : Configurer Fluent Bit](#tutorial-deploy-fluentbit-on-windows-configure-fluentbit)
+ [Étape 4 : enregistrer une définition de tâche Windows Fluent Bit qui achemine les journaux vers CloudWatch](#tutorial-deploy-fluentbit-on-windows-register-task-definition)
+ [Étape 5 : Exécuter la définition de tâche `ecs-windows-fluent-bit` en tant que service Amazon ECS en utilisant la stratégie de planification du démon](#tutorial-deploy-fluentbit-on-windows-run-task)
+ [Étape 6 : Enregistrer une définition de tâche Windows qui génère les journaux](#tutorial-deploy-fluentbit-on-windows-register-task-def-logs)
+ [Étape 7 : Créer la définition de tâche `windows-app-task`](#tutorial-deploy-fluentbit-on-windows-run-task-fluentbit)
+ [Étape 8 : Vérifiez les connexions CloudWatch](#tutorial-deploy-fluentbit-on-windows-verify)
+ [Étape 9 : nettoyer](#tutorial-deploy-fluentbit-on-windows-cleanup)
## Conditions préalables
Le didacticiel suppose de remplir les prérequis suivants :
+ La dernière version du AWS CLI est installée et configurée. Pour plus d’informations, consultez la section [Installation ou mise à jour de la version la plus récente de l’ AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ L'image du conteneur `aws-for-fluent-bit` est disponible pour les systèmes d'exploitation Windows suivants :
+ Windows Server 2019 Core
+ Windows Server 2019 Full
+ Windows Server 2022 Core
+ Windows Server 2022 Full
+ Vous devez avoir suivi les étapes de [Configurer l'utilisation d'Amazon ECS](get-set-up-for-amazon-ecs.md).
+ Vous avez un cluster. Dans ce didacticiel, le nom du cluster est **FluentBit-cluster**.
+ Vous disposez d'un VPC doté d'un sous-réseau public sur lequel l'instance EC2 sera lancée. Vous pouvez utiliser votre VPC par défaut. Vous pouvez également utiliser un sous-réseau privé qui permet aux CloudWatch points de terminaison Amazon d'accéder au sous-réseau. Pour plus d'informations sur les CloudWatch points de terminaison Amazon, consultez la section [ CloudWatch Points de terminaison et quotas Amazon](https://docs.aws.amazon.com/general/latest/gr/cw_region.html) dans le. *Références générales AWS* Pour plus d'informations sur la manière d'utiliser l'assistant Amazon VPC pour créer un VPC, consultez [Créer un Virtual Private Cloud](get-set-up-for-amazon-ecs.md#create-a-vpc).
## Étape 1 : Créer les rôles IAM d'accès
Créez les rôles IAM Amazon ECS.
1. Créez le rôle d'instance de conteneur Amazon ECS nommé « ecs InstanceRole ». Pour plus d'informations, consultez [Rôle IAM d'instance de conteneur Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/instance_IAM_role.html).
1. Créez un rôle IAM pour la tâche Fluent Bit intitulée `fluentTaskRole`. Pour de plus amples informations, veuillez consulter [rôle IAM de tâche Amazon ECS](task-iam-roles.md).
Les autorisations IAM accordées dans ce rôle IAM sont prises en charge par les conteneurs de tâches. Pour autoriser Fluent Bit à envoyer des journaux CloudWatch, vous devez associer les autorisations suivantes au rôle IAM de la tâche.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogStream",
"logs:CreateLogGroup",
"logs:DescribeLogStreams",
"logs:PutLogEvents"
],
"Resource": "*"
}
]
}
```
------
1. Attachez la stratégie au rôle.
1. Enregistrez le contenu ci-dessus dans un fichier nommé `fluent-bit-policy.json`.
1. Exécutez la commande suivante pour associer la politique en ligne au rôle IAM `fluentTaskRole`.
```
aws iam put-role-policy --role-name fluentTaskRole --policy-name fluentTaskPolicy --policy-document file://fluent-bit-policy.json
```
## Étape 2 : Créer une instance de conteneur Windows Amazon ECS
Créez une instance de conteneur Windows Amazon ECS.
**Pour créer une instance Amazon ECS**
1. Utilisez la commande `aws ssm get-parameters` pour récupérer l'ID AMI de la région qui héberge votre VPC. Pour plus d'informations, consultez la section [Extraction des métadonnées Amazon ECS-Optimized AMI](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/retrieve-ecs-optimized_windows_AMI.html).
1. Utilisez la console Amazon EC2 pour lancer l'instance.
1. Ouvrez la console Amazon EC2 à l’adresse [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Dans la barre de navigation, sélectionnez la région à utiliser.
1. Sur le **tableau de bord EC2**, sélectionnez **Launch instance (Lancer une instance)**.
1. Pour **Name (Nom)**, saisissez un nom unique.
1. Pour **Application and OS Images (Amazon Machine Image)** (Images de l'application et du SE (Amazon Machine Image)), choisissez l'AMI que vous avez récupérée lors de la première étape.
1. Concernant l'option **Instance type (Type d'instance)**, choisissez `t3.xlarge`.
1. Pour **Key pair (login)** (Paire de clés (connexion)), choisissez une paire de clés.
1. Sous **Network Settings** (Paramètres réseau), pour **Security group** (Groupe de sécurité), choisissez un groupe de sécurité existant ou créez-en un nouveau.
1. Sous **Paramètres réseau**, pour **IP Auto-assign publique**, sélectionnez **Activer**.
1. Sous **Détails avancés**, pour le **profil d'instance IAM**, sélectionnez **ecs. InstanceRole**
1. Configurez votre instance de conteneur Amazon ECS avec les données utilisateur suivantes. Sous **Détails avancés**, collez le script suivant dans le champ **Données utilisateur**, en le {{cluster\_name}} remplaçant par le nom de votre cluster.
```
Import-Module ECSTools
Initialize-ECSAgent -Cluster {{cluster-name}} -EnableTaskENI -EnableTaskIAMRole -LoggingDrivers '["awslogs","fluentd"]'
```
1. Lorsque vous êtes prêt, cochez la case de confirmation, puis sélectionnez **Launch Instances** (Lancer des instances).
1. Une page de confirmation indique que l'instance est en cours de lancement. Sélectionnez **View Instances** (Afficher les instances) pour fermer la page de confirmation et revenir à la console.
## Étape 3 : Configurer Fluent Bit
Vous pouvez utiliser la configuration par défaut suivante fournie par AWS pour démarrer rapidement :
+ [Amazon CloudWatch](https://github.com/aws/aws-for-fluent-bit/blob/mainline/ecs_windows_forward_daemon/cloudwatch.conf), qui est basé sur le plug-in Fluent Bit pour [Amazon figurant](https://docs.fluentbit.io/manual/v/1.9-pre/pipeline/outputs/cloudwatch) dans CloudWatch le *manuel officiel de Fluent Bit*.
Vous pouvez également utiliser d'autres configurations par défaut fournies par AWS. Pour plus d'informations, consultez la section [Overriding the entrypoint for the Windows image](https://github.com/aws/aws-for-fluent-bit/tree/mainline/ecs_windows_forward_daemon#overriding-the-entrypoint-for-the-windows-image) (Ignorer le point d'entrée de l'image Windows) sur le site Web `aws-for-fluent-bit` de Github.
La configuration par défaut d'Amazon CloudWatch Fluent Bit est illustrée ci-dessous.
Remplacez les variables suivantes :
+ {{region}}avec la région dans laquelle vous souhaitez envoyer les CloudWatch journaux Amazon.
```
[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
```
Chaque journal qui entre dans Fluent Bit possède une étiquette que vous spécifiez. Si vous n'en fournissez pas, elle est générée automatiquement. Les étiquettes peuvent être utilisées pour acheminer différents journaux vers différentes destinations. Pour plus d'informations, voir [Tag](https://docs.fluentbit.io/manual/concepts/key-concepts#tag) (Étiquette) dans le *manuel officiel de Fluent Bit*.
La configuration Fluent Bit décrite ci-dessus possède les propriétés suivantes :
+ Le plug-in d'entrée directe écoute le trafic entrant sur le port TCP 24224.
+ Chaque entrée de journal reçue sur ce port possède une étiquette que le plug-in d'entrée directe modifie pour préfixer l'enregistrement avec une chaîne `ecs.`.
+ Le pipeline interne de Fluent Bit achemine l'entrée du journal pour modifier le filtre à l'aide d'une correspondance d'expression régulière (regex). Ce filtre remplace les clés dans l'enregistrement de journal au format JSON par le format que Fluent Bit peut utiliser.
+ L'entrée de journal modifiée est ensuite utilisée par le filtre rewrite\_tag. Ce filtre remplace la balise de l'enregistrement du journal par le format out. {{TASK\_ID}}. {{CONTAINER\_NAME}}.
+ La nouvelle balise sera acheminée vers le plug-in de sortie cloudwatch\_logs qui crée les groupes de journaux et les flux comme décrit précédemment en utilisant les `log_stream_prefix` options `log_group_template` et du plug-in de sortie. CloudWatch Pour plus d'informations, voir [Configuration parameters](https://docs.fluentbit.io/manual/v/1.9-pre/pipeline/outputs/cloudwatch#configuration-parameters) (Paramètres de configuration) dans le *manuel officiel de Fluent Bit*.
## Étape 4 : enregistrer une définition de tâche Windows Fluent Bit qui achemine les journaux vers CloudWatch
Enregistrez une définition de tâche Windows Fluent Bit vers laquelle les journaux sont acheminés CloudWatch.
**Note**
Cette définition de tâche expose le port 24224 du conteneur Fluent Bit au port hôte 24224. Vérifiez que ce port n'est pas ouvert dans le groupe de sécurité de votre instance EC2 pour empêcher tout accès depuis l'extérieur.
**Pour enregistrer une définition de tâche**
1. Créez un fichier nommé `fluent-bit.json` avec les contenus suivants.
Remplacez les variables suivantes :
+ {{task-iam-role}}avec le nom de ressource Amazon (ARN) de votre tâche (rôle IAM)
+ {{region}}avec la région dans laquelle s'exécute votre tâche
```
{
"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. Utilisez la commande suivante pour enregistrer la définition de tâche.
```
aws ecs register-task-definition --cli-input-json {{file://fluent-bit.json}} --region {{region}}
```
Vous pouvez répertorier les définitions de tâche de votre compte en exécutant la commande `list-task-definitions`. La sortie affiche les valeurs de famille et de révision que vous pouvez utiliser conjointement avec `run-task` ou `start-task`.
## Étape 5 : Exécuter la définition de tâche `ecs-windows-fluent-bit` en tant que service Amazon ECS en utilisant la stratégie de planification du démon
Après avoir enregistré une définition de tâche pour votre compte, vous pouvez exécuter une tâche dans le cluster. Pour ce didacticiel, vous exécutez une instance de la définition de tâche `ecs-windows-fluent-bit:1` de votre cluster `FluentBit-cluster`. Exécutez la tâche dans un service qui utilise la stratégie de planification du démon, qui garantit qu'une seule instance de Fluent Bit s'exécute toujours sur chacune de vos instances de conteneur.
**Pour exécuter une tâche**
1. Exécutez la commande suivante pour démarrer la définition de la tâche `ecs-windows-fluent-bit:1` (enregistrée à l'étape précédente) en tant que service.
**Note**
Cette définition de tâche utilise le pilote de journalisation `awslogs`. Votre instance de conteneur doit disposer des autorisations nécessaires.
Remplacez les variables suivantes :
+ {{region}}avec la région où fonctionne votre service
```
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. Exécutez la commande suivante pour répertorier vos tâches.
Remplacez les variables suivantes :
+ {{region}}avec la région dans laquelle s'exécutent vos tâches de service
```
aws ecs list-tasks --cluster {{FluentBit-cluster}} --region {{region}}
```
## Étape 6 : Enregistrer une définition de tâche Windows qui génère les journaux
Enregistrez une définition de tâche qui génère les journaux. Cette définition de tâche déploie une image de conteneur Windows qui écrira un nombre incrémentiel à `stdout` toutes les secondes.
La définition de la tâche utilise le pilote de journalisation Fluentd qui se connecte au port 24224 que le plug-in Fluent Bit écoute. L'agent Amazon ECS met des étiquettes à chaque conteneur ECS qui incluent le nom du cluster, l'ARN de la tâche, le nom de famille de la définition de la tâche, le numéro de révision de la définition de la tâche et le nom du conteneur de la tâche. Ces étiquettes clé-valeur sont transmises à Fluent Bit.
**Note**
Cette tâche utilise également le mode réseau `default`. Toutefois, vous pouvez aussi utiliser le mode réseau `awsvpc` avec la tâche.
**Pour enregistrer une définition de tâche**
1. Créez un fichier nommé `windows-app-task.json` avec les contenus suivants.
```
{
"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. Utilisez la commande suivante pour enregistrer la définition de tâche.
Remplacez les variables suivantes :
+ {{region}}avec la région dans laquelle s'exécute votre tâche
```
aws ecs register-task-definition --cli-input-json {{file://windows-app-task.json}} --region {{region}}
```
Vous pouvez répertorier les définitions de tâche de votre compte en exécutant la commande `list-task-definitions`. La sortie affiche les valeurs de famille et de révision que vous pouvez utiliser conjointement avec `run-task` ou `start-task`.
## Étape 7 : Créer la définition de tâche `windows-app-task`
Après avoir enregistré la définition de tâche `windows-app-task`, exécutez-la dans votre cluster `FluentBit-cluster`.
**Pour exécuter une tâche**
1. Exécutez la définition de tâche `windows-app-task:1` que vous avez enregistrée à l'étape précédente.
Remplacez les variables suivantes :
+ {{region}}avec la région dans laquelle s'exécute votre tâche
```
aws ecs run-task --cluster FluentBit-cluster --task-definition windows-app-task:1 --count 2 --region {{region}}
```
1. Exécutez la commande suivante pour répertorier vos tâches.
```
aws ecs list-tasks --cluster {{FluentBit-cluster}}
```
## Étape 8 : Vérifiez les connexions CloudWatch
Afin de vérifier votre configuration Fluent Bit, vérifiez les groupes de journaux suivants dans la CloudWatch console :
+ `/ecs/fluent-bit-logs` : il s'agit du groupe de journaux qui correspond au conteneur de démon Fluent Bit qui s'exécute sur l'instance de conteneur.
+ `/aws/ecs/FluentBit-cluster.windows-app-task` : il s'agit du groupe de journaux qui correspond à toutes les tâches lancées pour la famille de définition de tâche `windows-app-task` au sein du cluster `FluentBit-cluster`.
`task-out.{{FIRST_TASK_ID}}.sample-container` : ce flux de journaux contient tous les journaux générés par la première instance de la tâche dans le conteneur de tâches sample-container.
`task-out.{{SECOND_TASK_ID}}.sample-container` : ce flux de journaux contient tous les journaux générés par la seconde instance de la tâche dans le conteneur de tâches sample-container.
Le flux de journaux `task-out.{{TASK_ID}}.sample-container` contient des champs similaires aux suivants :
```
{
"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"
}
```
**Pour vérifier la configuration Fluent Bit**
1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Dans le panneau de navigation, choisissez **Groupes de journaux**. Assurez-vous que vous êtes dans la région où vous avez déployé Fluent Bit sur vos conteneurs.
Dans la liste des groupes de journaux du Région AWS, vous devriez voir ce qui suit :
+ `/ecs/fluent-bit-logs`
+ `/aws/ecs/FluentBit-cluster.windows-app-task`
Si vous voyez ces groupes de journaux, la vérification de la configuration Fluent Bit est terminée.
## Étape 9 : nettoyer
Lorsque vous avez terminé ce didacticiel, nettoyez les ressources qui lui sont associées afin d'éviter la facturation de frais pour des ressources que vous n'utilisez pas.
**Pour nettoyer les ressources du didacticiel**
1. Arrêtez la tâche `windows-simple-task` et la tâche `ecs-fluent-bit`. Pour de plus amples informations, veuillez consulter [Arrêt d’une tâche Amazon ECS](standalone-task-stop.md).
1. Utilisez la commande suivante pour supprimer le groupe de journaux `/ecs/fluent-bit-logs`. Pour plus d'informations sur la suppression de groupes de journaux, voir [delete-log-group](https://docs.aws.amazon.com/cli/latest/reference/logs/delete-log-group.html) dans le *Guide de référence d'AWS Command Line Interface *.
```
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. Exécutez la commande suivante pour mettre fin à l'instance.
```
aws ec2 terminate-instances --instance-ids {{instance-id}}
```
1. Exécutez les commandes suivantes pour supprimer les rôles IAM.
```
aws iam delete-role --role-name ecsInstanceRole
aws iam delete-role --role-name fluentTaskRole
```
1. Exécutez la commande suivante pour supprimer le cluster Amazon ECS.
```
aws ecs delete-cluster --cluster {{FluentBit-cluster}}
```