Déploiement de Fluent Bit sur des conteneurs Windows Amazon ECS

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, Splunk et les serveurs HTTP personnalisés. Pour plus d'informations sur Fluent Bit, consultez le site web Fluent Bit .

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 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 (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 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 fluentd-buffer-limit cette option. Pour plus d'informations, consultez fluentd-buffer-limitle site Web de documentation 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 withcontainer_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

Prérequis

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 Installing the AWS Command Line Interface (Installation de).

• 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.

• 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 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.

É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é « ecsInstanceRole ». Pour plus d'informations, consultez Rôle IAM d'instance de conteneur Amazon ECS.

2. Créez un rôle IAM pour la tâche Fluent Bit intitulée fluentTaskRole. Pour plus d’informations, consultez Rôle IAM de la tâche Amazon ECS.

   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.

   {
       "Version": "2012-10-17",
       "Statement": [
       {
           "Effect": "Allow",
           "Action": [
               "logs:CreateLogStream",
               "logs:CreateLogGroup",
               "logs:DescribeLogStreams",
               "logs:PutLogEvents"
           ],
           "Resource": "*"
       }
       ]
   }

3. Attachez la stratégie au rôle.

   1. Enregistrez le contenu ci-dessus dans un fichier nommé fluent-bit-policy.json.

   2. 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 Extraction des métadonnées d'AMI optimisée pour Amazon ECS.

2. Utilisez la console Amazon EC2 pour lancer l'instance.

   1. Ouvrez la console Amazon EC2 à l'adresse https://console.aws.amazon.com/ec2/.

   2. Dans la barre de navigation, sélectionnez la région à utiliser.

   3. Sur le tableau de bord EC2, sélectionnez Launch instance (Lancer une instance).

   4. Pour Name (Nom), saisissez un nom unique.

   5. 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.

   6. Concernant l'option Instance type (Type d'instance), choisissez t3.xlarge.

   7. Pour Key pair (login) (Paire de clés (connexion)), choisissez une paire de clés.

   8. 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.

   9. Sous Network settings (Paramètres réseau), pour Auto-assign Public IP (Attribuer automatiquement l'adresse IP publique), sélectionnez Enable (Activer).

   10. Sous Détails avancés, pour le profil d'instance IAM, sélectionnez ecsInstanceRole.

   11. Configurez votre instance de conteneur Amazon ECS avec les données utilisateur suivantes. Sous Advanced Details (Détails avancés), collez le script suivant dans le champ User data (Données utilisateur), en remplaçant cluster_name par le nom de votre cluster.

       <powershell>
       Import-Module ECSTools
       Initialize-ECSAgent -Cluster cluster-name -EnableTaskENI -EnableTaskIAMRole -LoggingDrivers '["awslogs","fluentd"]'
       </powershell>

   12. Lorsque vous êtes prêt, cochez la case de confirmation, puis sélectionnez Launch Instances (Lancer des instances).

   13. 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, qui est basé sur le plug-in Fluent Bit pour Amazon figurant 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 (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 :

• région 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 (É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 l'étiquette de l'enregistrement du journal par le format de sortie. 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 (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-roleavec le nom de ressource Amazon (ARN) de votre tâche (rôle IAM)

   • region par la région dans laquelle votre tâche s'exécute

   {
     "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"
   }

2. 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 par la région dans laquelle votre service fonctionne

   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

2. Exécutez la commande suivante pour répertorier vos tâches.

   Remplacez les variables suivantes :

   • region par la région dans laquelle les tâches de votre service fonctionnent

   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"
   }

2. Utilisez la commande suivante pour enregistrer la définition de tâche.

   Remplacez les variables suivantes :

   • region par la région dans laquelle votre tâche s'exécute

   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 par la région dans laquelle votre tâche s'exécute

   aws ecs run-task --cluster FluentBit-cluster --task-definition windows-app-task:1 --count 2 --region region

2. 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/.

2. 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 plus d’informations, consultez Arrêt d'une tâche Amazon ECS.

2. 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 delete-log-group, voir la AWS Command Line Interface référence.

   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

3. Exécutez la commande suivante pour mettre fin à l'instance.

   aws ec2 terminate-instances --instance-ids instance-id

4. 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

5. Exécutez la commande suivante pour supprimer le cluster Amazon ECS.

   aws ecs delete-cluster --cluster FluentBit-cluster