Fluent Bit Dynatrace : envoyer les logs Kubernetes pas à pas

Fluent Bit Dynatrace : déployez le DaemonSet par Helm, enrichissez les logs Kubernetes, envoyez-les à l’API d’ingestion et vérifiez leur arrivée en DQL.
Fluent Bit Dynatrace : envoyer les logs Kubernetes pas à pas

Votre plateforme Kubernetes collecte déjà ses logs avec Fluent Bit, et l’équipe ne veut pas changer d’agent pour adopter Dynatrace. Bonne nouvelle : le couple Fluent Bit Dynatrace fonctionne sans greffon spécifique, avec la sortie HTTP standard et l’API d’ingestion de logs.

Encore faut-il que les logs arrivent enrichis. Une ligne sans namespace, sans pod ni cluster est presque inutile en astreinte : impossible de la relier à l’entité Kubernetes ni à la trace qui l’a produite, et le MTTR s’allonge d’autant.

Objectif de ce tutoriel : déployer Fluent Bit en DaemonSet avec Helm, renommer les métadonnées Kubernetes dans les champs attendus par Dynatrace, envoyer les logs à l’API v2 et vérifier leur arrivée en DQL. Le contenu vaut pour Dynatrace SaaS et Dynatrace Managed ; seule l’URL d’ingestion change.

Fluent Bit Dynatrace ou OneAgent : lequel choisir

Si le Dynatrace Operator tourne déjà avec la collecte de logs, il n’y a pas de raison d’ajouter Fluent Bit. Fluent Bit est pertinent quand il est déjà le standard de l’équipe, quand une partie des logs part aussi vers un autre outil, ou sur des clusters où l’on ne déploie pas le OneAgent. Pour le cadre général, voir le module sur les logs et OpenPipeline.

Prérequis

  • Un cluster Kubernetes avec un runtime containerd ou CRI-O (format de log CRI), kubectl et Helm 3.
  • Un token API Dynatrace avec le scope logs.ingest (Ingest logs), et rien de plus.
  • L’URL d’ingestion : https://<env-id>.live.dynatrace.com/api/v2/logs/ingest en SaaS, https://<domaine>/e/<env-id>/api/v2/logs/ingest en Managed (ou via un ActiveGate).
  • Un accès en lecture aux logs dans Dynatrace pour la vérification.

Étape 1 : stocker le token dans un secret

Ne mettez jamais le token en clair dans un fichier de valeurs versionné. Créez un namespace et un secret :

kubectl create namespace logging
kubectl -n logging create secret generic dynatrace-logs \
  --from-literal=DT_INGEST_TOKEN="$DT_INGEST_TOKEN" \
  --from-literal=DT_INGEST_HOST="abc12345.live.dynatrace.com"

En Managed, DT_INGEST_HOST reçoit votre domaine, et le chemin /e/<env-id> ira dans l’URI de la sortie (étape 3). Pour les erreurs 401 et 403 classiques, gardez sous la main le dépannage des tokens API.

Étape 2 : lire les logs des conteneurs et ajouter le contexte Kubernetes

Créez un fichier values-dynatrace.yaml pour le chart officiel fluent/fluent-bit. L’entrée lit les fichiers de logs des conteneurs ; le filtre kubernetes ajoute namespace, pod et conteneur ; le filtre modify renomme ces champs selon la convention k8s.*.

envFrom:
  - secretRef:
      name: dynatrace-logs
env:
  - name: K8S_CLUSTER_NAME
    value: "prod-eu-1"

podAnnotations:
  dynatrace.com/inject: "false"

config:
  inputs: |
    [INPUT]
        Name              tail
        Tag               kube.*
        Path              /var/log/containers/*.log
        multiline.parser  cri
        DB                /var/log/flb_kube.db
        Mem_Buf_Limit     20MB
        Skip_Long_Lines   On

  filters: |
    [FILTER]
        Name         kubernetes
        Match        kube.*
        Merge_Log    On
        Keep_Log     Off
        Labels       Off
        Annotations  Off

    [FILTER]
        Name           nest
        Match          kube.*
        Operation      lift
        Nested_under   kubernetes
        Add_prefix     k_

    [FILTER]
        Name     modify
        Match    kube.*
        Rename   log               content
        Rename   k_namespace_name  k8s.namespace.name
        Rename   k_pod_name        k8s.pod.name
        Rename   k_pod_id          k8s.pod.uid
        Rename   k_container_name  k8s.container.name
        Rename   k_host            k8s.node.name
        Add      k8s.cluster.name  ${K8S_CLUSTER_NAME}
        Remove_wildcard k_

Lignes critiques : multiline.parser cri recolle les lignes découpées par le runtime ; Rename log content place le message dans le champ que Dynatrace affiche comme contenu ; l’annotation dynatrace.com/inject: "false" évite que l’Operator instrumente Fluent Bit lui-même. Si vos applications écrivent du JSON, Merge_Log On remonte ses clés au premier niveau : vérifiez qu’aucune ne s’appelle déjà content.

Étape 3 : configurer la sortie HTTP vers Dynatrace

Ajoutez la sortie au même fichier :

  outputs: |
    [OUTPUT]
        Name              http
        Match             kube.*
        Host              ${DT_INGEST_HOST}
        Port              443
        URI               /api/v2/logs/ingest
        Format            json
        json_date_key     timestamp
        json_date_format  iso8601
        Header            Authorization Api-Token ${DT_INGEST_TOKEN}
        Header            Content-Type application/json; charset=utf-8
        allow_duplicated_headers false
        tls               On
        tls.verify        On
        Retry_Limit       5

Format json envoie un tableau d’enregistrements, ce qu’attend l’API ; json_date_key timestamp donne à chaque log son horodatage d’origine. En Managed, remplacez l’URI par /e/<env-id>/api/v2/logs/ingest. Retry_Limit borne les nouvelles tentatives en cas d’indisponibilité : au-delà, les lots sont abandonnés, ce qui doit se voir dans les métriques (étape de vérification).

Étape 4 : déployer avec Helm

helm repo add fluent https://fluent.github.io/helm-charts
helm repo update
helm upgrade --install fluent-bit fluent/fluent-bit \
  -n logging -f values-dynatrace.yaml
kubectl -n logging rollout status daemonset/fluent-bit

Un pod par nœud doit passer à l’état Running.

Comment vérifier que ça fonctionne

  1. Dans les logs de Fluent Bit, aucune ligne [error] liée à la sortie HTTP : kubectl -n logging logs ds/fluent-bit | grep -iE "error|http_status". Un statut 204 ou 200 signifie que le lot est accepté ; un 401 ou 403 renvoie au token.
  2. Dans Dynatrace (SaaS avec Grail), lancez :
    fetch logs, from: -15m
    | filter k8s.cluster.name == "prod-eu-1"
    | summarize lignes = count(), by: { k8s.namespace.name }
    | sort lignes desc

    Chaque namespace actif doit apparaître. En Managed, utilisez la visionneuse de logs et filtrez sur le même attribut.

  3. Exposez les métriques internes de Fluent Bit (port 2020, chemin /api/v1/metrics/prometheus) et surveillez les compteurs de nouvelles tentatives et d’abandons de la sortie : un abandon non nul signifie des logs perdus.

Bonnes pratiques

  • Filtrez au plus tôt : un filtre grep sur les namespaces bavards coûte moins cher qu’un traitement après ingestion.
  • Donnez un SLO à la chaîne de logs elle-même (part de lots acceptés) et alertez sur le silence, comme dans détecter le silence et les excès de volume.
  • Ajoutez trace_id et span_id dans les logs applicatifs pour la corrélation avec les traces (voir relier logs et traces).
  • Activez le stockage tampon sur disque (storage.type filesystem) si une coupure réseau de plusieurs minutes est plausible.
  • Faites tourner le token et limitez-le au seul scope logs.ingest.

Questions fréquentes

Faut-il un ActiveGate entre Fluent Bit et Dynatrace ?

Non en SaaS : Fluent Bit peut envoyer directement à l’environnement. Un ActiveGate d’environnement reste utile si le cluster n’a pas d’accès Internet sortant ou en Managed pour concentrer les flux ; l’URI suit alors le format de l’ActiveGate.

Pourquoi mes logs arrivent-ils sans horodatage correct ?

Vérifiez json_date_key et json_date_format : sans eux, Dynatrace utilise l’heure de réception. Un décalage de plusieurs minutes fausse les corrélations pendant un incident.

Puis-je garder Fluent Bit et le OneAgent sur le même cluster ?

Oui, mais n’activez pas la collecte des mêmes fichiers des deux côtés : vous paieriez deux fois les mêmes logs. Répartissez par namespace ou désactivez la collecte de logs de l’un des deux.

Conclusion

Avec une sortie HTTP, un secret, un renommage des champs k8s.* et une requête DQL de contrôle, Fluent Bit alimente Dynatrace sans changer d’agent. Ajoutez la surveillance de la chaîne elle-même, et vos logs Kubernetes deviennent une source fiable pour le diagnostic.

span.observer est un blog indépendant de la communauté, non affilié à Dynatrace LLC. Dynatrace est une marque de son propriétaire. Options et champs évoluent : vérifiez-les dans la documentation de Fluent Bit et dans celle de Dynatrace.

Total
0
Shares
Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Previous Post
Datadog vs Dynatrace ? Un comparatif Dynatrace vs Datadog concret pour une équipe SRE

Datadog vs Dynatrace ? Un comparatif Dynatrace vs Datadog concret pour une équipe SRE

Next Post
Istio Dynatrace : superviser le service mesh avec Dynatrace (Istio, traces et métriques)

Istio Dynatrace : superviser le service mesh avec Dynatrace (Istio, traces et métriques)

Related Posts