Graylog : Centralisation et Analyse des Logs pour l'Infrastructure IT
Maîtrisez Graylog pour centraliser, analyser et visualiser vos logs. Architecture, installation Docker/Kubernetes, pipelines de traitement, alerting et bonnes pratiques pour une observabilité optimale.
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é.