Fluentd : Agrégation de logs unifiée

Fluentd est un collecteur de données open source unifié, projet CNCF Graduated, qui centralise et route les logs vers de multiples destinations. Là où Fluent Bit collecte en périphérie, Fluentd joue le rôle d'agrégateur central, avec un écosystème de plus de 500 plugins.

Ce guide s'adresse aux profils intermédiaires et avancés. Vous allez installer Fluentd (version 1.19), comprendre son pipeline (source, filter, match), écrire une configuration, gérer le buffering et router les logs par tags.

Ce que vous allez apprendre

• Comprendre le pipeline Fluentd : source, filter, match (buffer).
• Installer Fluentd proprement (Docker épinglé, gem, fluent-package).
• Configurer collecte, filtres et sorties multiples.
• Router les événements avec le système de tags.
• Fiabiliser avec un buffer fichier persistant.

Pourquoi Fluentd ?

Fluentd est le standard de facto pour l'agrégation de logs dans les environnements cloud-native, avec plus de 500 plugins disponibles.

Caractéristique	Description
Licence	Apache 2.0
Maturité	CNCF Graduated
Langage	Ruby + C
Plugins	500+
Communauté	Très active

Glissez pour voir

Fluentd vs Fluent Bit

Fluentd est conçu pour l'agrégation (serveur central). Fluent Bit est conçu pour la collecte (agent léger sur chaque node).

En production Kubernetes, on utilise souvent les deux ensemble.

Architecture

Fluentd utilise une architecture en pipeline avec des plugins d'entrée, de filtrage et de sortie.

┌─────────────────────────────────────────────────────────────────┐
│                          Fluentd                                 │
│  ┌──────────────┐  ┌───────────────┐  ┌───────────────────────┐ │
│  │    Input     │──│    Filter     │──│       Output          │ │
│  │   plugins    │  │   plugins     │  │       plugins         │ │
│  └──────────────┘  └───────────────┘  └───────────────────────┘ │
│                                                                  │
│  - tail             - parser          - elasticsearch           │
│  - forward          - record_modifier - loki                    │
│  - http             - grep            - kafka                   │
│  - syslog           - geoip           - s3                      │
│  - tcp              - throttle        - forward                 │
└─────────────────────────────────────────────────────────────────┘
                              │
                              ▼
                      ┌───────────────┐
                      │    Buffer     │
                      │ (file/memory) │
                      └───────────────┘

Installation

RubyGems

Le paquet historique td-agent est en fin de vie. Son successeur est fluent-package (Fluentd v5), à installer depuis le dépôt signé officiel pour un service système. Pour une installation simple et multiplateforme, Fluentd s'installe aussi comme gem Ruby :

# Fluentd via RubyGems (nécessite Ruby)
gem install fluentd

fluentd --version

td-agent est déprécié

Si vous suivez de vieux tutoriels, ils installent souvent td-agent via un script curl | sh. C'est déprécié depuis fin 2023 : utilisez fluent-package (dépôt signé) ou la gem ci-dessus.

Docker

docker run -d \
  --name fluentd \
  -p 24224:24224 \
  -p 24224:24224/udp \
  -v $(pwd)/fluent.conf:/fluentd/etc/fluent.conf \
  fluent/fluentd:v1.19-debian-1

Kubernetes (Helm)

helm repo add fluent https://fluent.github.io/helm-charts
helm repo update

helm install fluentd fluent/fluentd \
  --namespace logging \
  --create-namespace

Configuration

La configuration Fluentd utilise des directives <source>, <filter> et <match>.

Configuration minimale

fluent.conf

<source>
  @type tail
  path /var/log/app/*.log
  pos_file /var/log/fluentd/app.log.pos
  tag app.logs
  <parse>
    @type json
  </parse>
</source>

<match app.logs>
  @type stdout
</match>

Exemple complet : logs vers Elasticsearch

fluent.conf

# Collecter les logs applicatifs
<source>
  @type tail
  path /var/log/app/*.log
  pos_file /var/log/fluentd/app.pos
  tag app.logs
  <parse>
    @type json
    time_key timestamp
    time_format %Y-%m-%dT%H:%M:%S.%L%z
  </parse>
</source>

# Collecter syslog
<source>
  @type syslog
  port 5140
  bind 0.0.0.0
  tag syslog
</source>

# Ajouter des métadonnées
<filter app.**>
  @type record_transformer
  <record>
    hostname "#{Socket.gethostname}"
    environment production
  </record>
</filter>

# Parser les logs multi-format
<filter app.**>
  @type parser
  key_name message
  reserve_data true
  <parse>
    @type multi_format
    <pattern>
      format json
    </pattern>
    <pattern>
      format regexp
      expression /^(?<time>[^ ]+) (?<level>[^ ]+) (?<message>.*)$/
    </pattern>
  </parse>
</filter>

# Sortie vers Elasticsearch avec buffer
<match **>
  @type elasticsearch
  host elasticsearch
  port 9200
  index_name fluentd-${tag}-%Y.%m.%d

  <buffer tag, time>
    @type file
    path /var/log/fluentd/buffer
    flush_mode interval
    flush_interval 5s
    chunk_limit_size 5MB
    queue_limit_length 512
    retry_max_interval 30
    retry_forever true
  </buffer>
</match>

Plugins essentiels

Input plugins

Plugin	Usage	Configuration
tail	Lire des fichiers	path, pos_file
forward	Recevoir d'autres Fluentd	port 24224
http	API HTTP	port 9880
syslog	Recevoir syslog	port 5140
tcp	Socket TCP	port 5170

Glissez pour voir

Filter plugins

Plugin	Usage	Exemple
record_transformer	Ajouter/modifier des champs	Ajouter hostname
parser	Parser le message	JSON, regex
grep	Filtrer par pattern	Include/exclude
geoip	Enrichir avec GeoIP	IP → localisation

Glissez pour voir

Output plugins

Plugin	Destination
elasticsearch	Elasticsearch / OpenSearch
loki	Grafana Loki
kafka	Apache Kafka
s3	Amazon S3
forward	Autre Fluentd
prometheus	Métriques Prometheus

Glissez pour voir

Installer des plugins

# Via gem
fluent-gem install fluent-plugin-elasticsearch

# Dans Docker
FROM fluent/fluentd:v1.19-debian-1
RUN gem install fluent-plugin-elasticsearch

Buffering et fiabilité

Le buffer est crucial pour la fiabilité. Fluentd supporte deux types.

Memory buffer (défaut)

Rapide mais perte de données en cas de crash.

<buffer>
  @type memory
  flush_interval 5s
</buffer>

File buffer (recommandé)

Persistant sur disque, survit aux redémarrages.

<buffer>
  @type file
  path /var/log/fluentd/buffer
  chunk_limit_size 8MB
  total_limit_size 2GB
  flush_mode interval
  flush_interval 5s
  flush_thread_count 2
  retry_forever true
  retry_max_interval 30
</buffer>

Tags et routing

Les tags déterminent le routage des événements.

# Source avec tag
<source>
  @type tail
  path /var/log/nginx/access.log
  tag nginx.access
</source>

# Match exact
<match nginx.access>
  @type elasticsearch
</match>

# Match avec wildcard
<match nginx.**>
  @type loki
</match>

# Match multiple tags
<match {nginx.access,app.logs}>
  @type s3
</match>

# Match tout
<match **>
  @type stdout
</match>

Déploiement Kubernetes

Architecture recommandée

┌─────────────────────────────────────────────────────────────────┐
│                     Kubernetes Cluster                           │
│                                                                   │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐                        │
│  │ Fluent   │  │ Fluent   │  │ Fluent   │  ← DaemonSet           │
│  │ Bit      │  │ Bit      │  │ Bit      │    (chaque node)       │
│  └────┬─────┘  └────┬─────┘  └────┬─────┘                        │
│       │             │             │                               │
│       └─────────────┼─────────────┘                               │
│                     ▼                                             │
│           ┌─────────────────┐                                     │
│           │    Fluentd      │  ← Deployment                       │
│           │  (agrégateur)   │    (replicas: 2)                    │
│           └────────┬────────┘                                     │
│                    │                                              │
└────────────────────┼──────────────────────────────────────────────┘
                     ▼
         ┌──────────────────────┐
         │   Elasticsearch /   │
         │   Loki / S3         │
         └──────────────────────┘

Configuration DaemonSet (Fluent Bit → Fluentd)

values-forwarder.yaml

config:
  inputs: |
    [INPUT]
        Name              tail
        Path              /var/log/containers/*.log
        Tag               kube.*

  outputs: |
    [OUTPUT]
        Name          forward
        Match         *
        Host          fluentd-aggregator
        Port          24224

Configuration Aggregator (Fluentd)

fluentd-aggregator.conf

<source>
  @type forward
  port 24224
  bind 0.0.0.0
</source>

<filter kube.**>
  @type kubernetes_metadata
</filter>

<match kube.**>
  @type elasticsearch
  host elasticsearch
  port 9200
  index_name kubernetes-%Y.%m.%d

  <buffer>
    @type file
    path /var/log/fluentd/buffer
  </buffer>
</match>

Monitoring

Métriques internes

Activez le plugin monitor_agent :

<source>
  @type monitor_agent
  bind 0.0.0.0
  port 24220
</source>

Accédez à http://localhost:24220/api/plugins.json.

Exposition Prometheus

<source>
  @type prometheus
  bind 0.0.0.0
  port 24231
  metrics_path /metrics
</source>

<source>
  @type prometheus_output_monitor
</source>

Bonnes pratiques

1. Utilisez des buffers fichier en production
2. Limitez la taille des chunks pour éviter l'OOM
3. Activez retry_forever pour ne pas perdre de logs
4. Séparez collecte et agrégation (Fluent Bit + Fluentd)
5. Monitorez les buffers pour détecter les backlogs

Dépannage

Symptôme	Cause probable	Solution
Buffer plein	Destination lente/down	Augmenter queue_limit
Logs perdus	Memory buffer + crash	Passer en file buffer
Haute mémoire	Chunks trop gros	Réduire chunk_limit_size
Parsing échoue	Format non reconnu	Vérifier le pattern

Glissez pour voir

# Vérifier la config
fluentd --dry-run -c /etc/fluent/fluent.conf

# Mode debug
fluentd -c /etc/fluent/fluent.conf -vvv

FAQ : questions fréquentes

Qu'est-ce que Fluentd ?

Fluentd est un collecteur de données open source unifié, projet CNCF Graduated. Il collecte, filtre et route des logs (et d'autres données) vers de multiples destinations via un pipeline source, filter, match, avec un écosystème de plus de 500 plugins.

Fluentd ou Fluent Bit, lequel choisir ?

Fluent Bit est un agent léger (écrit en C) pour la collecte en périphérie sur chaque nœud. Fluentd est plus lourd (Ruby) mais plus flexible, adapté au rôle d'agrégateur central. En production Kubernetes, on combine souvent les deux : Fluent Bit collecte et transmet à Fluentd qui agrège et route.

Comment fonctionne le routing par tags dans Fluentd ?

Chaque événement porte un tag défini par sa source. Les directives match dirigent les événements vers une sortie selon leur tag : match exact (nginx.access), wildcard (nginx.**), plusieurs tags ou match ** pour tout capter. C'est le tag qui décide de la destination.

Faut-il un buffer fichier avec Fluentd ?

Oui, en production. Le buffer mémoire (par défaut) est rapide mais perd les données en cas de crash. Le buffer fichier persiste sur disque et survit aux redémarrages, avec retry_forever pour ne pas perdre de logs si la destination est indisponible.

À retenir

• CNCF Graduated : standard de l'industrie
• 500+ plugins : intégration avec tout
• Buffer fichier : obligatoire en production
• Tags : système de routage flexible
• Fluent Bit en collecte : Fluentd en agrégation

Prochaines étapes

Fluent Bit L'agent léger de collecte en périphérie, en amont de Fluentd.

Grafana Loki Un backend de logs vers lequel router avec l'output loki.

Grafana Alloy Le collecteur unifié logs/métriques/traces, alternative moderne.

Ressources

• Documentation officielle
• Plugin Registry
• GitHub

×

📖 Voir la documentation →