Installation et configuration de l'Elastic Stack sur CentOS 8

Vue d’ensemble

L’Elastic Stack (anciennement ELK) se compose principalement de trois éléments : Elasticsearch (moteur de recherche et stockage), Logstash (pipeline de traitement des logs) et Kibana (interface de visualisation). Les Beats (par ex. Filebeat) servent d’agents légers pour expédier les logs vers Logstash ou Elasticsearch.

Définitions rapides

• Elasticsearch : moteur de recherche distribué basé sur Lucene. Stocke les documents JSON et expose une API HTTP.
• Logstash : collecteur et transformateur de logs. Gère inputs, filtres et outputs.
• Kibana : interface web pour explorer et visualiser les données Elasticsearch.
• Filebeat : agent léger pour lire des fichiers de logs et les envoyer à Logstash/Elasticsearch.

Important : les logs peuvent contenir des données personnelles. Voir la section Protection des données plus bas.

Pré-requis

• Un serveur CentOS 8 (elk-master) : 64 bits, recommandé 4 Gio RAM.
• Un serveur CentOS 8 client (client01) : 64 bits, 1 Gio RAM.
• Un serveur Ubuntu 18.04 client (client02) : 64 bits, 1 Gio RAM.
• Accès root ou sudo sur toutes les machines.
• Accès réseau entre clients et serveur (ports TCP 5044, 9200, 5601, 80).

Fichier des ports clés

• Elasticsearch : 9200 (HTTP), 9300 (node-to-node)
• Kibana : 5601 (HTTP)
• Logstash Beats input : 5044
• Nginx (reverse proxy) : 80/443

Ce que nous allons faire

• Ajouter le dépôt Elastic sur CentOS 8
• Installer et configurer Elasticsearch
• Installer et configurer Kibana
• Mettre Nginx en reverse proxy et activer une authentification basique
• Installer et configurer Logstash (pipeline Beats, filtres syslog)
• Installer et configurer Filebeat sur CentOS et Ubuntu
• Tester la chaîne complète et valider les données dans Kibana

Étape 1 - Ajouter le dépôt Elastic

Nous ajoutons la clé GPG d’Elastic et le dépôt RPM pour pouvoir installer Elasticsearch, Logstash, Kibana et les Beats.

Exécutez :

rpm --import https://artifacts.elastic.co/GPG-KEY-elasticsearch

Puis créez le fichier de dépôt :

cd /etc/yum.repos.d/
vim elasticsearch.repo

Collez :

[elasticsearch-7.x]
name=Elasticsearch repository for 7.x packages
baseurl=https://artifacts.elastic.co/packages/7.x/yum
gpgcheck=1
gpgkey=https://artifacts.elastic.co/GPG-KEY-elasticsearch
enabled=1
autorefresh=1
type=rpm-md

Vérifiez les dépôts :

dnf repolist

Note : si vous travaillez derrière un proxy, configurez le proxy pour dnf avant d’ajouter le dépôt.

Étape 2 - Installer et configurer Elasticsearch

Installez le paquet :

sudo dnf install elasticsearch -y

Éditez la configuration principale :

cd /etc/elasticsearch/
vim elasticsearch.yml

Modifiez ou décommentez :

network.host: 127.0.0.1
http.port: 9200

Conseil d’exploitation : pour un cluster production, définissez network.host sur l’IP privée et configurez discovery.seed_hosts et cluster.initial_master_nodes.

Réglage de la JVM (optionnel) :

vim jvm.options

Ajustez la heap selon la mémoire disponible, par exemple :

-Xms512m
-Xmx512m

Rechargez systemd puis activez et lancez le service :

sudo systemctl daemon-reload
sudo systemctl enable elasticsearch
sudo systemctl start elasticsearch

Test rapide de l’API :

curl -XGET 'http://127.0.0.1:9200/?pretty'

Important : en environnement de production, protégez l’API HTTP avec TLS et authentification. Ne laissez pas Elasticsearch exposé sans protection.

Étape 3 - Installer et configurer Kibana

Installez Kibana :

sudo dnf install kibana

Éditez :

cd /etc/kibana/
vim kibana.yml

Décommentez et adaptez :

server.port: 5601
server.host: "127.0.0.1"
elasticsearch.url: "http://127.0.0.1:9200"

Activez et démarrez :

sudo systemctl enable kibana
sudo systemctl start kibana

Vérifiez le statut et les ports :

systemctl status kibana
netstat -plntu

Kibana écoute par défaut sur 127.0.0.1:5601. Nous exposerons l’interface via Nginx en reverse proxy dans la suite.

Étape 4 - Configurer Nginx en reverse proxy pour Kibana

Installer Nginx et l’utilitaire htpasswd :

sudo dnf install nginx httpd-tools

Créez la conf Nginx :

cd /etc/nginx/conf.d/
vim kibana.conf

Contenu :

server {
    listen 80;

    server_name elk.hakase-labs.io;

    auth_basic "Restricted Access";
    auth_basic_user_file /etc/nginx/.kibana-user;

    location / {
        proxy_pass http://127.0.0.1:5601;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }
}

Créez l’utilisateur d’authentification basique (changez “hakase”) :

sudo htpasswd -c /etc/nginx/.kibana-user hakase
TYPE YOUR PASSWORD

Testez la configuration et démarrez Nginx :

nginx -t
systemctl enable nginx
systemctl start nginx

Conseil : pour la production, utilisez TLS (port 443) et un certificat valide. Terminez TLS sur Nginx ou via un load balancer.

Étape 5 - Installer et configurer Logstash

Logstash reçoit les événements Beats, filtre les messages syslog et envoie vers Elasticsearch.

Installez :

sudo dnf install logstash

Ajustez la JVM :

cd /etc/logstash/
vim jvm.options

# Exemple
-Xms512m
-Xmx512m

Créez une entrée pour Beats :

cd /etc/logstash/conf.d/
vim input-beat.conf

input {
  beats {
    port => 5044
  }
}

Filtre syslog avec grok :

vim syslog-filter.conf

filter {
  if [type] == "syslog" {
    grok {
      match => { "message" => "%{SYSLOGTIMESTAMP:syslog_timestamp} %{SYSLOGHOST:syslog_hostname} %{DATA:syslog_program}(?:\[%{POSINT:syslog_pid}\])?: %{GREEDYDATA:syslog_message}" }
      add_field => [ "received_at", "%{@timestamp}" ]
      add_field => [ "received_from", "%{host}" ]
    }
    date {
      match => [ "syslog_timestamp", "MMM  d HH:mm:ss", "MMM dd HH:mm:ss" ]
    }
  }
}

Configurez la sortie vers Elasticsearch :

vim output-elasticsearch.conf

output {
  elasticsearch { hosts => ["127.0.0.1:9200"]
    hosts => "127.0.0.1:9200"
    manage_template => false
    index => "%{[@metadata][beat]}-%{+YYYY.MM.dd}"
    document_type => "%{[@metadata][type]}"
  }
}

Activez et démarrez Logstash :

systemctl enable logstash
systemctl start logstash

Vérifiez le statut et les ports :

systemctl status logstash
netstat -plntu

Bonnes pratiques :

• Validez la configuration Logstash (/usr/share/logstash/bin/logstash -t -f /etc/logstash/conf.d) avant le redémarrage.
• Évitez les configurations dupliquées qui créent des boucles.

Étape 6 - Installer Filebeat sur les clients

Filebeat lit les fichiers de log et les envoie à Logstash.

Installation sur CentOS 8

Ajoutez la clé et le dépôt (comme à l’étape 1), puis :

sudo dnf install filebeat

Installation sur Ubuntu 18.04

Installez apt-transport-https et ajoutez le dépôt :

sudo apt install apt-transport-https
wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo apt-key add -
echo "deb https://artifacts.elastic.co/packages/7.x/apt stable main" | sudo tee -a /etc/apt/sources.list.d/elastic-7.x.list
sudo apt update
sudo apt install filebeat

Configuration de Filebeat

Fichier principal : /etc/filebeat/filebeat.yml

Désactivez l’output Elasticsearch et activez Logstash :

#output.elasticsearch:
  # Array of hosts to connect to.
  #  hosts: ["127.0.0.1:9200"]

output.logstash:
  # The Logstash hosts
  hosts: ["10.5.5.25:5044"]

Activez le module system :

filebeat modules list
filebeat modules enable system

Éditez le module system :

cd /etc/filebeat/
vim modules.d/system.yml

Pour CentOS (chemins) :

  # Syslog
  syslog:
    enabled: true
    var.paths: ["/var/log/messages"]

  # Authorization logs
  auth:
    enabled: true
    var.paths: ["/var/log/secure"]

Pour Ubuntu :

  # Syslog
  syslog:
    enabled: true
    var.paths: ["/var/log/syslog"]

  # Authorization logs
  auth:
    enabled: true
    var.paths: ["/var/log/auth.log"]

Activez et démarrez Filebeat :

systemctl enable filebeat
systemctl start filebeat
systemctl status filebeat

Vérifiez que Filebeat se connecte au port 5044 sur le serveur Elastic. En environnement sécurisé, chiffrez la connexion entre Filebeat et Logstash (TLS).

Étape 7 - Test et validation

Ouvrez votre navigateur sur l’URL publique (ici via Nginx) :

http://elk.hakase-labs.io/

Connectez-vous avec l’utilisateur que vous avez créé.

Dans Kibana, créez le pattern d’index filebeat-* et choisissez @timestamp comme champ temporel.

Accédez à Discover pour voir les événements :

Exemples de logs remontés :

Si vous voyez des événements récents, la chaîne Filebeat -> Logstash -> Elasticsearch -> Kibana fonctionne.

Vérification, dépannage et cas d’échec courants

1. Filebeat ne se connecte pas à Logstash
   • Vérifiez le firewall et assurez-vous que le port 5044 est ouvert.
   • Contrôlez filebeat logs pour les erreurs TLS ou d’authentification.
2. Logstash n’ingère pas les événements
   • Tester la configuration : /usr/share/logstash/bin/logstash -t -f /etc/logstash/conf.d.
   • Regarder /var/log/logstash/logstash-plain.log pour les erreurs grok.
3. Elasticsearch manque de mémoire
   • Vérifiez la heap JVM et les ressources système. Réduisez les indices répliqués si nécessaire.
4. Kibana affiche une page blanche
   • Vérifiez que Kibana peut joindre Elasticsearch (config elasticsearch.url).
   • Consultez journalctl -u kibana.

Conseil : utilisez curl -u user:pass http://127.0.0.1:9200/_cat/indices?v pour lister les indices et vérifier les écritures.

Playbook d’installation (SOP résumé)

1. Préparer l’OS (mise à jour, firewall, swap off si besoin).
2. Ajouter la clé GPG et le dépôt Elastic.
3. Installer Elasticsearch, configurer network.host, JVM, puis activer et démarrer.
4. Installer Kibana, configurer, activer, démarrer.
5. Installer Nginx, configurer le reverse proxy et l’auth basique, activer TLS en prod.
6. Installer Logstash, créer input-beat, filtres grok et output vers Elasticsearch.
7. Installer Filebeat sur clients, activer module system, configurer output.logstash.
8. Contrôles de validation : connectivité, indices créés, vues Discover dans Kibana.

Checklist par rôle

Admin Système

• Configurer le dépôt Elastic
• Installer et démarrer Elasticsearch, Logstash, Kibana
• Ouvrir les ports nécessaires et configurer SELinux/firewalld
• Mettre en place sauvegardes et scripts d’alerting

Opérateur Sécurité

• Activer TLS entre composants
• Configurer authentification pour Kibana et API Elasticsearch
• Auditer les règles de rétention des logs

Développeur / Observabilité

• Valider que les events attendus apparaissent dans Discover
• Créer dashboards et alertes sur conditions critiques

Bonnes pratiques et durcissement

• Chiffrez les communications (TLS) entre Filebeat, Logstash et Elasticsearch.
• N’exposez jamais Elasticsearch sans authentification.
• Limitez l’accès Kibana via reverse proxy, RBAC et ACL réseau.
• Mettez en place des snapshots réguliers d’Elasticsearch pour la récupération.
• Définissez une politique de cycle de vie des indices (ILM) pour gérer l’espace disque.

Protection des données et conformité

Les fichiers de logs peuvent contenir des données personnelles. Avant de centraliser les logs :

• Anonymisez ou supprimez les informations sensibles au niveau du filtre Logstash (ex : grok + mutate).
• Documentez la durée de conservation et les finalités.
• Si vous traitez des données de citoyens de l’UE, évitez de conserver des éléments non nécessaires pour la durée plus longue que nécessaire.

Critères d’acceptation

• Elasticsearch répond sur 127.0.0.1:9200 et retourne l’état du cluster.
• Kibana est accessible via Nginx et protège l’accès par mot de passe.
• Logstash écoute sur le port 5044 et accepte les connexions Beats.
• Filebeat envoie des logs et les indices filebeat-* apparaissent dans Elasticsearch.
• Les dashboards ou vues Discover affichent des événements récents datés correctement.

Mini-méthodologie pour le déploiement en production

1. Déployer dans un environnement staging avec données synthétiques.
2. Valider la montée en charge (simuler plusieurs Filebeat clients).
3. Activer TLS et testez la latence de transmission.
4. Mettre en place ILM et alerting pour l’espace disque.
5. Planifier la reprise après incident (snapshots, procédures de rollback).

Glossaire rapide

• Index : équivalent d’une base de données/collection pour Elasticsearch.
• Document : unité JSON stockée dans un index.
• Shard : fragment d’un index pour distribution.
• Replica : copie d’un shard pour haute disponibilité.

Foire aux problèmes et solutions rapides

• Problème : Filebeat redémarre en boucle
  • Solution : vérifier la configuration YAML (filebeat test config) et les droits sur les fichiers.
• Problème : Grok ne matche pas
  • Solution : tester la regex avec l’outil Grok Debugger dans Kibana ou https://grokdebug.herokuapp.com.
• Problème : Indices trop volumineux
  • Solution : activer ILM, compresser les anciens indices et réviser la rétention.

Résumé final

Ce guide vous a montré comment installer et configurer l’Elastic Stack (Elasticsearch, Logstash, Kibana) sur CentOS 8, sécuriser Kibana par Nginx, et déployer Filebeat sur clients CentOS/Ubuntu. Il inclut des procédures pour tester la chaîne, des conseils de sécurité, une checklist par rôle et des critères d’acceptation. En production, ajoutez TLS, authentification et politiques de rétention adaptées.

Merci de consulter la documentation officielle pour les versions et détails avancés : https://www.elastic.co/guide/index.html