Journalisation Fargate

Pour configurer le routeur de journaux

Dans les étapes suivantes, remplacez chaque example value par vos propres valeurs.

1. Créez un espace de noms Kubernetes dédié nommé aws-observability.

   1. Enregistrez le contenu suivant dans un fichier nommé aws-observability-namespace.yaml sur votre ordinateur. La valeur pour name doit être aws-observability et le label aws-observability: enabled est obligatoire.

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

   2. Créez l'espace de noms.

      kubectl apply -f aws-observability-namespace.yaml
      

2. Créez un ConfigMap avec une valeur de données Fluent Conf pour envoyer les journaux des conteneurs vers une destination. Fluent Conf est Fluent Bit, qui est un langage de configuration de processeur de journaux rapide et léger, utilisé pour acheminer les journaux des conteneurs vers une destination de journalisation de votre choix. Pour plus d'informations, consultez Fichier de configuration dans la documentation Fluent Bit.

   Important

   Dans une Fluent Conf type, les principales sections incluses sont Service, Input, Filter et Output. Le routeur de journaux Fargate n'accepte cependant que :

   • Les sections Filter et Output.

   • Une section Parser.

   Si vous fournissez d'autres sections, elles seront rejetées.

   Le routeur de journal Fargate gère les sections Service et Input. Il possède la section Input suivante, qui ne peut pas être modifiée et n'est pas nécessaire dans votre ConfigMap. Cependant, vous pouvez en tirer des informations, telles que la limite de la mémoire tampon et la balise appliquée pour les journaux.

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

   Lors de la création du ConfigMap, prenez en compte les règles suivantes que Fargate utilise pour valider les champs :

   • [FILTER], [OUTPUT] et [PARSER] sont censés être spécifiés sous chaque clé correspondante. Par exemple, [FILTER] doit être inférieur à filters.conf. Vous pouvez avoir un ou plusieurs [FILTER] sous filters.conf. [OUTPUT] et [PARSER] doivent également être sous leurs clés correspondantes. En spécifiant plusieurs sections [OUTPUT], vous pouvez acheminer vos journaux vers différentes destinations en même temps.

   • Fargate valide les clés requises de chaque section. Name et match sont nécessaires pour chaque [FILTER] et [OUTPUT]. Name et format sont nécessaires pour chaque [PARSER]. Ces noms sont sensibles à la casse.

   • Les variables d'environnement telles que ${ENV_VAR} ne sont pas autorisées dans le ConfigMap.

   • L'indentation doit être la même pour la directive ou la paire clé-valeur dans chaque filters.conf, output.conf et parsers.conf. Les paires clé-valeur doivent être indentées plus que les directives.

   • Fargate valide par rapport aux filtres pris en charge suivants : grep, parser, record_modifier, rewrite_tag, throttle, nest, modify et kubernetes.

   • Fargate valide par rapport à la sortie prise en charge suivante : es, firehose, kinesis_firehose, cloudwatch, cloudwatch_logs et kinesis.

   • Au moins un plugin Output doit être fourni dans le ConfigMap pour activer la journalisation. Filter et Parser ne sont pas nécessaires pour activer la journalisation.

   Vous pouvez également exécuter Fluent Bit sur Amazon EC2 en utilisant la configuration souhaitée pour résoudre les problèmes qui surviennent lors de la validation. Créez votre ConfigMap en utilisant l'un des exemples suivants.

   Important

   La journalisation Amazon EKS Fargate ne prend pas en charge la configuration dynamique de ConfigMaps. Les modifications apportées à ConfigMaps sont appliquées uniquement aux nouveaux Pods. Les modifications ne sont pas appliquées aux Pods existants.

   Créez un ConfigMap en utilisant l'exemple pour votre destination de journal désirée.

   Note

   Vous pouvez également utiliser Amazon Kinesis Data Streams comme destination du journal. Si vous utilisez Kinesis Data Streams, assurez-vous que l'autorisation kinesis:PutRecords a été accordée au rôle d'exécution du pod. Pour plus d'informations, consultez Permissions d'Amazon Kinesis Data Streams dans le Manuel officiel Fluent Bit.

   CloudWatch

   Pour créer une ConfigMap pour CloudWatch

   Deux options de sortie s'offrent à vous lorsque vous utilisez CloudWatch :

   • Un plugin de sortie écrit en C

   • Un plugin de sortie écrit en Golang

   L'exemple suivant montre comment utiliser le cloudwatch_logs plugin pour envoyer des journaux à CloudWatch.

   1. Enregistrez le contenu suivant dans un fichier nommé aws-logging-cloudwatch-configmap.yaml. region-codeRemplacez-le par Région AWS celui dans lequel se trouve votre cluster. Les paramètres sous [OUTPUT] sont requises.

      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

   2. Appliquez le manifeste à votre cluster.

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

   3. Téléchargez la politique CloudWatch IAM sur votre ordinateur. Vous pouvez également consulter la politique sur GitHub.

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

   Amazon OpenSearch Service

   Pour créer un OpenSearch service ConfigMap pour Amazon

   Si vous souhaitez envoyer des journaux à Amazon OpenSearch Service, vous pouvez utiliser es output, qui est un plugin écrit enC. L'exemple suivant montre comment utiliser le plugin pour envoyer des journaux à OpenSearch.

   1. Enregistrez le contenu suivant dans un fichier nommé aws-logging-opensearch-configmap.yaml. Remplacez chaque example value par vos propres valeurs.

      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

   2. Appliquez le manifeste à votre cluster.

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

   3. Téléchargez la politique OpenSearch IAM sur votre ordinateur. Vous pouvez également consulter la politique sur GitHub.

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

      Assurez-vous que le contrôle d'accès OpenSearch des tableaux de bord est correctement configuré. all_access roleDans les OpenSearch tableaux de bord, le rôle d'exécution Pod Fargate et le rôle IAM doivent être mappés. Le même mappage doit être fait pour le rôle security_manager. Vous pouvez ajouter les mappages précédents en sélectionnant Menu, Security et Roles, puis sélectionner les rôles correspondants. Pour plus d'informations, consultez Comment résoudre les problèmes liés aux CloudWatch journaux afin qu'ils soient diffusés sur mon domaine Amazon ES ? .

   Firehose

   Pour créer un ConfigMap pour Firehose

   Deux options de sortie s'offrent à vous lorsque vous envoyez des logs à Firehose :

   • kinesis_firehose : un plugin de sortie écrit en C.

   • firehose : un plugin de sortie écrit en Golang.

   L'exemple suivant vous montre comment utiliser le kinesis_firehose plugin pour envoyer des logs à Firehose.

   1. Enregistrez le contenu suivant dans un fichier nommé aws-logging-firehose-configmap.yaml. region-codeRemplacez-le par Région AWS celui dans lequel se trouve votre cluster.

      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

   2. Appliquez le manifeste à votre cluster.

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

   3. Téléchargez la politique IAM de Firehose sur votre ordinateur. Vous pouvez également consulter la politique sur GitHub.

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

3. Créez une politique IAM depuis le fichier de politique que vous avez téléchargé à l'étape précédente.

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

4. Attachez la politique IAM au rôle d'exécution de pod spécifié pour votre profil Fargate avec la commande suivante. Remplacez 111122223333 par votre ID de compte. Remplacez AmazonEKSFargatePodExecutionRole par le rôle d'exécution de votre Pod (pour plus d'informations, veuillez consulter la rubrique Création d'un rôle d'exécution de Pod Fargate).

   aws iam attach-role-policy \
     --policy-arn arn:aws:iam::111122223333:policy/eks-fargate-logging-policy \
     --role-name AmazonEKSFargatePodExecutionRole
   

1. Localisez le groupe de CloudWatch journaux créé automatiquement pour les journaux de Fluent Bit processus de votre cluster Amazon EKS après avoir activé la journalisation Fargate. Il utilise le format {cluster_name}-fluent-bit-logs.

2. Supprimez les flux de CloudWatch journaux existants créés pour chaque CloudWatch journal de Pod's processus du groupe de journaux.

3. Modifiez la ConfigMap et définissez flb_log_cw: "false".

4. Redémarrez tous les Pods existants du cluster.

1. Déployez un exemple de Pod.

   1. Enregistrez le contenu suivant dans un fichier nommé sample-app.yaml sur votre ordinateur.

      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

   2. Appliquez le fichier manifeste à votre cluster.

      kubectl apply -f sample-app.yaml
      

2. Affichez les journaux NGINX en utilisant les destinations que vous avez configurées dans le fichier ConfigMap.