Graylog : Centralisation et Analyse des Logs pour l'Infrastructure IT

Dans un environnement IT moderne, la gestion des logs est devenue un enjeu critique. Avec des infrastructures distribuées composées de dizaines voire de centaines de services, la capacité à centraliser, analyser et corréler les logs en temps réel est essentielle pour garantir la disponibilité, la sécurité et la performance de vos systèmes.

Graylog s'est imposé comme l'une des solutions open source les plus puissantes et flexibles pour répondre à ces défis. Ce guide complet vous accompagnera dans la maîtrise de Graylog, de l'architecture fondamentale jusqu'aux configurations avancées.

Pourquoi Graylog

Solution Open Source Mature

Graylog (fondé en 2009) est une plateforme de gestion de logs open source qui rivalise avec les solutions commerciales comme Splunk ou Elastic Stack. Avec plus de 50 000 déploiements dans le monde, c'est une solution éprouvée pour les environnements de production exigeants.

Centralisation Unifiée

Plutôt que de consulter les logs sur chaque serveur individuellement, Graylog centralise tous vos logs dans une interface unique. Serveurs Linux, applications Java, conteneurs Docker, équipements réseau : tout converge vers un point central pour une analyse simplifiée.

Recherche Ultra-Rapide

Grâce à Elasticsearch/OpenSearch en backend, Graylog offre des recherches full-text en millisecondes sur des téraoctets de logs. Filtrez par host, application, niveau de sévérité, ou n'importe quel champ personnalisé.

Alerting en Temps Réel

Détectez les anomalies avant qu'elles n'impactent vos utilisateurs. Graylog permet de créer des alertes sur des patterns de logs, des seuils, ou des agrégations complexes avec notification Slack, email, PagerDuty.

Architecture et Composants

Vue d'Ensemble

Graylog repose sur une architecture à trois composants principaux, chacun jouant un rôle essentiel dans le traitement des logs.

MongoDB - Le Catalogue

MongoDB stocke les métadonnées de Graylog : configuration des inputs, streams, dashboards, utilisateurs, alertes. C'est une base légère qui ne contient PAS les logs eux-mêmes.

Caractéristiques :

Volume faible (quelques Go max)
Réplication recommandée en production
Backup simple via mongodump

Elasticsearch/OpenSearch - Le Stockage

Elasticsearch (ou son fork OpenSearch) est le moteur de stockage et recherche des logs. C'est lui qui indexe les messages et permet les recherches ultra-rapides.

Caractéristiques :

Stockage principal des logs (volume important)
Sharding et réplication pour la scalabilité
Index rotatifs par jour/semaine/mois
Rétention configurable (ex: 30 jours)

Graylog Server - Le Cerveau

Le serveur Graylog est le cœur du système. Il reçoit les logs via les inputs, les traite via les pipelines, les indexe dans Elasticsearch, et expose l'interface web.

Caractéristiques :

API REST complète
Interface web React moderne
Processing multi-threadé
Clustering pour haute disponibilité

Installation Docker Compose

Prérequis

Avant de déployer Graylog, assurez-vous d'avoir :

Docker 20.10+ et Docker Compose v2
8 Go RAM minimum (16 Go recommandé)
100 Go de stockage SSD

Configuration Complète

version: '3.8'

services:
  mongodb:
    image: mongo:6.0
    container_name: graylog-mongodb
    volumes:
      - mongodb_data:/data/db
    networks:
      - graylog
    restart: unless-stopped

  opensearch:
    image: opensearchproject/opensearch:2.11.0
    container_name: graylog-opensearch
    environment:
      - cluster.name=graylog-cluster
      - node.name=opensearch-node1
      - discovery.type=single-node
      - bootstrap.memory_lock=true
      - OPENSEARCH_JAVA_OPTS=-Xms4g -Xmx4g
      - plugins.security.disabled=true
    ulimits:
      memlock:
        soft: -1
        hard: -1
      nofile:
        soft: 65536
        hard: 65536
    volumes:
      - opensearch_data:/usr/share/opensearch/data
    networks:
      - graylog
    restart: unless-stopped

  graylog:
    image: graylog/graylog:5.2
    container_name: graylog-server
    environment:
      - GRAYLOG_PASSWORD_SECRET=somepasswordpepper_minimum16chars
      - GRAYLOG_ROOT_PASSWORD_SHA2=8c6976e5b5410415bde908bd4dee15dfb167a9c873fc4bb8a81f6f2ab448a918
      - GRAYLOG_HTTP_BIND_ADDRESS=0.0.0.0:9000
      - GRAYLOG_HTTP_EXTERNAL_URI=http://localhost:9000/
      - GRAYLOG_ELASTICSEARCH_HOSTS=http://opensearch:9200
      - GRAYLOG_MONGODB_URI=mongodb://mongodb:27017/graylog
    entrypoint: /usr/bin/tini -- wait-for-it opensearch:9200 -- /docker-entrypoint.sh
    volumes:
      - graylog_data:/usr/share/graylog/data
    networks:
      - graylog
    ports:
      - 9000:9000
      - 1514:1514
      - 1514:1514/udp
      - 12201:12201
      - 12201:12201/udp
      - 5044:5044
    depends_on:
      - mongodb
      - opensearch
    restart: unless-stopped

networks:
  graylog:
    driver: bridge

volumes:
  mongodb_data:
  opensearch_data:
  graylog_data:

Démarrage et Vérification

docker compose up -d
docker compose logs -f graylog

Accédez ensuite à http://localhost:9000 avec les identifiants admin / admin.

Installation Kubernetes avec Helm

Déploiement Production

Pour un déploiement Kubernetes scalable, utilisez le chart Helm officiel.

helm repo add graylog https://charts.graylog.org
helm repo update
kubectl create namespace graylog
helm install graylog graylog/graylog --namespace graylog -f graylog-values.yaml

Configuration Helm

graylog:
  replicas: 2
  resources:
    requests:
      cpu: 1
      memory: 2Gi
    limits:
      cpu: 2
      memory: 4Gi
  persistence:
    enabled: true
    size: 50Gi
    storageClassName: fast-ssd
  input:
    tcp:
      service:
        type: LoadBalancer
      ports:
        - name: gelf-tcp
          port: 12201
        - name: syslog-tcp
          port: 1514

opensearch:
  replicas: 3
  resources:
    requests:
      cpu: 2
      memory: 8Gi
    limits:
      cpu: 4
      memory: 16Gi
  persistence:
    enabled: true
    size: 500Gi

mongodb:
  architecture: replicaset
  replicaCount: 3
  persistence:
    enabled: true
    size: 20Gi

Configuration des Inputs

Types d'Inputs Disponibles

Graylog supporte de nombreux protocoles pour recevoir les logs. Voici les plus utilisés.

Input Syslog

Le protocole Syslog est le standard pour les équipements réseau et les systèmes Linux.

Configuration dans Graylog :

System → Inputs
Select input: Syslog UDP
Launch new input
Title: Syslog Network Devices
Port: 1514
Save

Configuration rsyslog (Linux) :

*.* @graylog.example.com:1514;RSYSLOG_SyslogProtocol23Format

Input GELF (Graylog Extended Log Format)

GELF est le format natif de Graylog, offrant des logs structurés avec champs personnalisés.

Avantages GELF :

Messages JSON structurés
Champs personnalisés illimités
Compression native
Pas de limite de taille (contrairement à Syslog 1024 bytes)

Configuration Docker :

services:
  webapp:
    image: myapp:latest
    logging:
      driver: gelf
      options:
        gelf-address: udp://graylog.example.com:12201
        tag: webapp-{{.Name}}

Configuration Node.js :

const winston = require('winston');
const { Graylog } = require('winston-graylog2');

const logger = winston.createLogger({
  transports: [
    new Graylog({
      name: 'Graylog',
      level: 'info',
      graylog: {
        servers: [{ host: 'graylog.example.com', port: 12201 }],
        hostname: 'webapp-prod',
        facility: 'webapp',
      },
      staticMeta: {
        environment: process.env.NODE_ENV,
        version: process.env.APP_VERSION,
      },
    }),
  ],
});

logger.info('User logged in', {
  user_id: '12345',
  ip_address: '192.168.1.100',
  duration_ms: 234,
});

Input Beats

Configuration Filebeat :

filebeat.inputs:
  - type: log
    enabled: true
    paths:
      - /var/log/nginx/access.log
      - /var/log/nginx/error.log
    fields:
      application: nginx
      environment: production
    fields_under_root: true

output.logstash:
  hosts: [graylog.example.com:5044]

Pipelines et Traitement

Concept des Pipelines

Les pipelines Graylog permettent de transformer, enrichir et router les logs en temps réel.

Règle d'extraction Nginx

rule "parse_nginx_access_log"
when
  has_field("message") AND contains(to_string($message.message), "nginx")
then
  let pattern = "%{IPORHOST:client_ip} - %{USER:ident} [%{HTTPDATE:timestamp}] \"%{WORD:method} %{URIPATH:request} HTTP/%{NUMBER:http_version}\" %{NUMBER:status_code} %{NUMBER:bytes}";
  let matches = grok(pattern, to_string($message.message));
  set_fields(matches);
  set_field("status_code", to_long($message.status_code));
  
  if (to_long($message.status_code) >= 500) {
    set_field("log_level", "error");
    set_field("alert", true);
  } else if (to_long($message.status_code) >= 400) {
    set_field("log_level", "warning");
  } else {
    set_field("log_level", "info");
  }
end

Enrichissement GeoIP

rule "add_geoip"
when
  has_field("client_ip")
then
  let geo = geoip_lookup(to_string($message.client_ip));
  set_field("geo_country", geo.country.iso_code);
  set_field("geo_city", geo.city.name);
  set_field("geo_location", geo.location);
end

Anonymisation PII

rule "anonymize_pii"
when
  has_field("message")
then
  let msg = regex_replace(
    "[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}",
    to_string($message.message),
    "[EMAIL_REDACTED]"
  );
  set_field("message", msg);
end

Streams et Routage

Organisation par Streams

Les streams permettent de catégoriser et router les logs vers différentes destinations.

Configuration des Streams

Stream Production Errors :

Streams → Create stream
Title: Production Errors
Index set: Default
Rules:
- Field: environment, Type: match exactly, Value: production
- Field: level, Type: match exactly, Value: error

Routing vers différents index sets :

# Index Set: Application Logs
Index prefix: graylog_app
Shards: 4
Replicas: 1
Rotation strategy: Time-based (daily)
Retention strategy: Delete (30 days)

# Index Set: Audit Logs
Index prefix: graylog_audit  
Shards: 2
Replicas: 2
Rotation strategy: Time-based (monthly)
Retention strategy: Delete (365 days)

Recherche et Requêtes

Syntaxe de Recherche

Graylog utilise la syntaxe Lucene pour les recherches.

Recherches basiques :

error connection timeout
"connection refused"
source:webserver-01
host:web-*
status_code:[500 TO 599]
(error OR warning) AND source:api-gateway NOT debug

Recherches avancées :

message:/.*Exception.*/
_exists_:user_id
NOT _exists_:response_time
timestamp:[now-1h TO now]
client_ip:192.168.0.0/16

Dashboards et Visualisation

Création de Dashboards

Les dashboards Graylog offrent une vue temps réel sur vos logs avec des widgets variés.

Types de Widgets

Stacked Chart - Évolution temporelle Pie Chart - Répartition par catégorie Data Table - Top requêtes et statistiques Single Number - Métrique clé avec tendance

Dashboard Application Monitoring

Row 1 - KPIs :

Total requests (dernière heure)
Error rate (%)
Average response time
Active users

Row 2 - Tendances :

Requests over time (stacked by status)
Response time percentiles (p50, p95, p99)

Row 3 - Détails :

Top 10 slowest endpoints
Error breakdown by type
Geographic distribution

Alerting et Notifications

Configuration des Alertes

Graylog permet de créer des alertes basées sur des conditions de logs.

Types de Conditions

Field Aggregation :

Condition: Field Aggregation
Field: response_time_ms
Aggregation: MEAN
Threshold: > 2000
Time range: 5 minutes
Grace period: 2 minutes

Message Count :

Condition: Message Count
Query: level:error AND source:payment-service
Threshold: > 10
Time range: 1 minute
Grace period: 5 minutes

Notifications

Slack, PagerDuty, Email, Webhook sont supportés nativement.

Intégration avec l'Écosystème

Prometheus + Graylog

Exportez les métriques Graylog vers Prometheus :

scrape_configs:
  - job_name: 'graylog'
    static_configs:
      - targets: ['graylog:9000']
    metrics_path: '/api/plugins/org.graylog.plugins.metrics.prometheus/metrics'
    basic_auth:
      username: 'admin'
      password: 'admin'

Métriques disponibles :

graylog_journal_entries
graylog_journal_size_bytes
graylog_throughput_input
graylog_throughput_output
graylog_buffer_usage

Kubernetes Logging Stack

Déployez Fluent Bit en DaemonSet pour collecter les logs Kubernetes vers Graylog.

Sécurité et Authentification

LDAP/Active Directory

Intégrez Graylog avec votre annuaire d'entreprise via System → Authentication → LDAP.

RBAC

Créez des rôles personnalisés avec des permissions granulaires par stream, dashboard et fonctionnalité.

TLS/SSL

Sécurisez les communications avec TLS sur l'interface web et les inputs.

Performance et Optimisation

Tuning Elasticsearch

Configuration JVM :

-Xms8g
-Xmx8g

Ne jamais dépasser 50% de la RAM totale et 31g maximum.

Tuning Graylog Server

processbuffer_processors = 5
outputbuffer_processors = 3
processor_wait_strategy = blocking
ring_size = 65536
message_journal_max_size = 5gb
message_journal_max_age = 12h

Métriques à Surveiller

Métrique	Warning	Critical
Journal size	> 1 GB	> 4 GB
Processing time	> 100ms	> 500ms
Buffer usage	> 70%	> 90%
ES indexing lag	> 1000 msg	> 10000 msg
Heap usage	> 75%	> 90%

Haute Disponibilité

Architecture HA

Pour une haute disponibilité, déployez plusieurs instances de chaque composant.

Configuration Cluster

# Node 1
is_leader = true
node_id_file = /etc/graylog/server/node-id
http_publish_uri = http://graylog-1.example.com:9000/

# Node 2
is_leader = false
node_id_file = /etc/graylog/server/node-id
http_publish_uri = http://graylog-2.example.com:9000/

Load Balancing

Utilisez nginx en mode stream pour le load balancing UDP/TCP des inputs.

Troubleshooting

Problèmes Courants

Journal utilization is too high :

curl -u admin:admin http://localhost:9000/api/system/journal

Solutions : augmenter outputbuffer_processors, optimiser Elasticsearch.

Elasticsearch cluster unhealthy :

curl http://localhost:9200/_cluster/healthpretty
curl http://localhost:9200/_cat/shardsv

Commandes de Diagnostic

curl -u admin:admin http://localhost:9000/api/system
curl -u admin:admin http://localhost:9000/api/system/throughput
curl -u admin:admin http://localhost:9000/api/system/inputs
docker logs graylog-server --tail 100 -f
curl http://localhost:9200/_cat/indicesv

Bonnes Pratiques

Checklist Production

Infrastructure :

Cluster Elasticsearch (3+ nodes)
MongoDB ReplicaSet (3 nodes)
Graylog cluster (2+ nodes)
Load balancer
Stockage SSD
Monitoring

Sécurité :

TLS partout
LDAP/OIDC
RBAC par équipe
Secrets dans vault
Audit logging

Performance :

Index sets séparés
Rotation quotidienne
Rétention adaptée
Alertes monitoring

Opérations :

Backup MongoDB quotidien
Snapshot ES quotidien
DR testée
Runbooks documentés

Conventions de Nommage

Streams: [ENV]-[APP]-[TYPE]
Index Sets: graylog_[env]_[category]
Dashboards: [Team] - [Application] - [View]
Alerts: [Severity]-[App]-[Condition]

Conclusion

Graylog est une solution de centralisation de logs puissante et mature. Sa combinaison de performance, flexibilité et facilité d'utilisation en fait un choix excellent pour les équipes DevOps et SRE.

Pour démarrer :

Déployez avec Docker Compose
Configurez vos premiers inputs
Créez des streams
Ajoutez des pipelines
Construisez vos dashboards et alertes

**Besoin d'aide pour déployer Graylog en production ** Contactez-nous pour un accompagnement personnalisé.

Graylog : Centralisation et Analyse des Logs pour l'Infrastructure IT

Pourquoi Graylog

Solution Open Source Mature

Centralisation Unifiée

Recherche Ultra-Rapide

Alerting en Temps Réel

Architecture et Composants

Vue d'Ensemble

MongoDB - Le Catalogue

Elasticsearch/OpenSearch - Le Stockage

Graylog Server - Le Cerveau

Installation Docker Compose

Prérequis

Configuration Complète

Démarrage et Vérification

Installation Kubernetes avec Helm

Déploiement Production

Configuration Helm

Configuration des Inputs

Types d'Inputs Disponibles

Input Syslog

Input GELF (Graylog Extended Log Format)

Input Beats

Pipelines et Traitement

Concept des Pipelines

Règle d'extraction Nginx

Enrichissement GeoIP

Anonymisation PII

Streams et Routage

Organisation par Streams

Configuration des Streams

Recherche et Requêtes

Syntaxe de Recherche

Dashboards et Visualisation

Création de Dashboards

Types de Widgets

Dashboard Application Monitoring

Alerting et Notifications

Configuration des Alertes

Types de Conditions

Notifications

Intégration avec l'Écosystème

Prometheus + Graylog

Kubernetes Logging Stack

Sécurité et Authentification

LDAP/Active Directory

RBAC

TLS/SSL

Performance et Optimisation

Tuning Elasticsearch

Tuning Graylog Server

Métriques à Surveiller

Haute Disponibilité

Architecture HA

Configuration Cluster

Load Balancing

Troubleshooting

Problèmes Courants

Commandes de Diagnostic

Bonnes Pratiques

Checklist Production

Conventions de Nommage

Conclusion

Articles similaires

Partager cet article

Articles populaires

Monitoring avec Grafana : Guide Complet pour Superviser Votre Infrastructure IT

Proxmox VE vs VMware : comprendre les vraies différences au-delà des idées reçues

WAZUH SIEM/XDR - Guide de Déploiement Complet en PME

Histoire et évolution de VMware et Proxmox

Étude comparative fonction par fonction : VMware vs Proxmox