Installer ELK sur Ubuntu : guide complet étape par étape

1. Prérequis et préparation du système

Avant de commencer l'installation de la suite ELK, assurez-vous de disposer des éléments suivants :

Commencez par mettre à jour votre système et installer les dépendances de base :

sudo apt update && sudo apt upgrade -y
sudo apt install -y apt-transport-https curl gnupg2 software-properties-common

Ces paquets permettent de gérer les dépôts HTTPS et les clés GPG nécessaires à l'installation des composants Elastic.

2. Installer Java (OpenJDK 17)

Elasticsearch et Logstash nécessitent Java pour fonctionner. Les versions récentes d'Elasticsearch (8.x) embarquent leur propre JDK, mais il est recommandé d'installer OpenJDK 17 pour Logstash et pour assurer la compatibilité globale de la stack.

sudo apt install -y openjdk-17-jre-headless

Vérifiez que Java est correctement installé :

java -version

Vous devriez obtenir une sortie indiquant OpenJDK 17. Si ce n'est pas le cas, vérifiez que le paquet a bien été installé et que le PATH est configuré.

3. Ajouter le dépôt officiel Elastic

Les composants de la suite ELK ne sont pas disponibles dans les dépôts Ubuntu par défaut. Vous devez ajouter le dépôt officiel Elastic à votre système.

Étape 3.1 — Importer la clé GPG Elastic :

wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo gpg --dearmor -o /usr/share/keyrings/elasticsearch-keyring.gpg

Étape 3.2 — Ajouter le dépôt Elastic 8.x :

echo "deb [signed-by=/usr/share/keyrings/elasticsearch-keyring.gpg] https://artifacts.elastic.co/packages/8.x/apt stable main" | sudo tee /etc/apt/sources.list.d/elastic-8.x.list

Étape 3.3 — Mettre à jour l'index des paquets :

sudo apt update

4. Installer et configurer Elasticsearch

Elasticsearch est le cœur de la stack. Il stocke les données, les indexe et permet les recherches rapides. L'installation se fait via apt :

sudo apt install -y elasticsearch

L'installation peut prendre quelques minutes. Un mot de passe sera généré automatiquement pour l'utilisateur elastic. Notez-le précieusement.

Étape 4.1 — Configurer Elasticsearch :

Éditez le fichier de configuration principal :

sudo nano /etc/elasticsearch/elasticsearch.yml

Modifiez ou vérifiez les paramètres suivants :

# Nom du cluster (choisissez un nom descriptif)
cluster.name: elk-lenidit

# Nom du nœud
node.name: node-1

# Chemin des données et logs
path.data: /var/lib/elasticsearch
path.logs: /var/log/elasticsearch

# Adresse d'écoute (localhost par défaut, sécurisé)
network.host: 127.0.0.1

# Port HTTP
http.port: 9200

# Mode single-node (pas de cluster multi-nœuds)
discovery.type: single-node

network.host: 127.0.0.1 limite l'accès à la machine locale. Ne changez cette valeur que si vous savez ce que vous faites (voir la section sécurisation).

Étape 4.2 — Configurer la mémoire JVM :

Par défaut, Elasticsearch s'alloue 1 Go de RAM. Ajustez selon votre serveur :

sudo nano /etc/elasticsearch/jvm.options.d/heap.options

Ajoutez les lignes suivantes (exemple pour un serveur avec 8 Go de RAM) :

-Xms2g
-Xmx2g

Réglez le heap à maximum 50% de la RAM disponible. Les valeurs Xms et Xmx doivent être identiques pour éviter les pauses garbage collector.

Étape 4.3 — Démarrer Elasticsearch :

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

Étape 4.4 — Vérifier le fonctionnement :

sudo systemctl status elasticsearch

Puis testez la connexion (en HTTPS, car Elasticsearch 8.x active TLS par défaut) :

curl --cacert /etc/elasticsearch/certs/http_ca.crt -u elastic:VOTRE_MOT_DE_PASSE https://localhost:9200

Vous devriez obtenir une réponse JSON contenant le nom du cluster, la version d'Elasticsearch et le statut du nœud. Si c'est le cas, Elasticsearch fonctionne correctement.

5. Installer et configurer Kibana

Kibana est l'interface web de la stack ELK. Elle permet de visualiser les données indexées dans Elasticsearch sous forme de dashboards, graphiques et tableaux interactifs.

sudo apt install -y kibana

Étape 5.1 — Configurer Kibana :

sudo nano /etc/kibana/kibana.yml

Modifiez les paramètres suivants :

# Port d'écoute de Kibana
server.port: 5601

# Adresse d'écoute (0.0.0.0 pour accès distant, 127.0.0.1 pour local uniquement)
server.host: "127.0.0.1"

# Nom du serveur Kibana
server.name: "elk-lenidit-kibana"

# URL d'Elasticsearch
elasticsearch.hosts: ["https://localhost:9200"]

# Identifiants pour la connexion Elasticsearch
elasticsearch.username: "kibana_system"
elasticsearch.password: "VOTRE_MOT_DE_PASSE_KIBANA_SYSTEM"

# Certificat SSL Elasticsearch
elasticsearch.ssl.certificateAuthorities: ["/etc/elasticsearch/certs/http_ca.crt"]

Alternative rapide : Au lieu de configurer manuellement les identifiants, vous pouvez utiliser un enrollment token :

# Générer le token (côté Elasticsearch)
sudo /usr/share/elasticsearch/bin/elasticsearch-create-enrollment-token -s kibana

Ensuite, au premier démarrage de Kibana, collez ce token dans l'interface web.

Étape 5.2 — Démarrer Kibana :

sudo systemctl enable kibana
sudo systemctl start kibana

Étape 5.3 — Vérifier :

sudo systemctl status kibana

Kibana démarre sur le port 5601. Ouvrez http://localhost:5601 dans votre navigateur. Si vous avez configuré l'enrollment token, l'interface vous demandera de le saisir. Sinon, connectez-vous avec l'utilisateur elastic et le mot de passe généré lors de l'installation d'Elasticsearch.

Le premier démarrage de Kibana peut prendre 1 à 2 minutes. Si vous obtenez "Kibana server is not ready yet", patientez et rechargez la page.

6. Installer et configurer Logstash

Logstash est le composant de traitement de la stack. Il collecte les données depuis différentes sources, les transforme (parsing, filtrage, enrichissement) et les envoie vers Elasticsearch.

sudo apt install -y logstash

Étape 6.1 — Créer un premier pipeline :

Un pipeline Logstash se compose de trois blocs : input (source des données), filter (transformation) et output (destination). Créez un fichier de configuration :

sudo nano /etc/logstash/conf.d/01-syslog.conf

Collez le contenu suivant :

input {
  beats {
    port => 5044
  }
}

filter {
  if [fileset][module] == "system" {
    if [fileset][name] == "auth" {
      grok {
        match => { "message" => "%{SYSLOGTIMESTAMP:syslog_timestamp} %{SYSLOGHOST:syslog_hostname} %{DATA:syslog_program}(?:\[%{POSINT:syslog_pid}\])?: %{GREEDYDATA:syslog_message}" }
        add_field => [ "received_at", "%{@timestamp}" ]
      }
    }
  }
}

output {
  elasticsearch {
    hosts => ["https://localhost:9200"]
    user => "elastic"
    password => "VOTRE_MOT_DE_PASSE"
    ssl_certificate_authorities => "/etc/elasticsearch/certs/http_ca.crt"
    index => "syslog-%{+YYYY.MM.dd}"
  }
}

Ce pipeline écoute sur le port 5044 (Beats), applique un filtre Grok sur les logs système, puis les envoie à Elasticsearch dans un index journalier.

Étape 6.2 — Tester la configuration :

sudo /usr/share/logstash/bin/logstash --config.test_and_exit -f /etc/logstash/conf.d/

Si la sortie affiche "Configuration OK", votre pipeline est valide.

Étape 6.3 — Démarrer Logstash :

sudo systemctl enable logstash
sudo systemctl start logstash

Pour approfondir les concepts d'architecture ELK (shards, ILM, Query DSL), consultez notre article dédié : ELK architecture : shards, ILM et Query DSL expliqués simplement.

7. Installer Filebeat (recommandé)

sudo apt install -y filebeat

Étape 7.1 — Configurer Filebeat :

sudo nano /etc/filebeat/filebeat.yml

Configurez l'envoi vers Logstash (recommandé) ou directement vers Elasticsearch :

# Envoi vers Logstash (recommandé pour filtrage)
output.logstash:
  hosts: ["localhost:5044"]

# OU envoi direct vers Elasticsearch
# output.elasticsearch:
#   hosts: ["https://localhost:9200"]
#   username: "elastic"
#   password: "VOTRE_MOT_DE_PASSE"
#   ssl.certificate_authorities: ["/etc/elasticsearch/certs/http_ca.crt"]

Étape 7.2 — Activer le module system :

sudo filebeat modules enable system

Étape 7.3 — Charger les dashboards Kibana (optionnel mais recommandé) :

sudo filebeat setup --dashboards

Cette commande précharge des dashboards prédéfinis dans Kibana pour visualiser les logs système. Elle ne fonctionne que si Kibana est opérationnel.

Étape 7.4 — Démarrer Filebeat :

sudo systemctl enable filebeat
sudo systemctl start filebeat

8. Vérifier que tout fonctionne ensemble

Maintenant que tous les composants sont installés, vérifiez chaque service :

# Vérifier Elasticsearch
curl --cacert /etc/elasticsearch/certs/http_ca.crt -u elastic:VOTRE_MOT_DE_PASSE https://localhost:9200

# Vérifier Kibana (doit répondre HTTP 200)
curl -s -o /dev/null -w "%{http_code}" http://localhost:5601/api/status

# Vérifier Logstash
curl http://localhost:9600?pretty

# Vérifier Filebeat
sudo systemctl status filebeat

Dans Kibana : accédez à http://localhost:5601, puis allez dans Stack Management > Index Management. Vous devriez voir des index syslog-YYYY.MM.dd ou filebeat-* apparaître si les logs sont correctement acheminés.

Rendez-vous ensuite dans Discover pour explorer vos premiers logs en temps réel.

9. Sécurisation de base

Une stack ELK expose des données sensibles. Voici les mesures de sécurité minimales à appliquer :

9.1 — Configurer le pare-feu UFW :

# Autoriser SSH
sudo ufw allow 22/tcp

# Autoriser Kibana (uniquement depuis votre IP si accès distant)
sudo ufw allow from VOTRE_IP to any port 5601

# NE PAS exposer Elasticsearch directement (garder 9200 en local)
# NE PAS exposer Logstash (garder 5044 en local)

# Activer le pare-feu
sudo ufw enable
sudo ufw status

9.2 — Vérifier les bind addresses :

Elasticsearch doit écouter uniquement sur 127.0.0.1 (configuration par défaut). Ne passez jamais network.host: 0.0.0.0 sans pare-feu et authentification configurés.

9.3 — Authentification :

Elasticsearch 8.x active la sécurité par défaut (TLS + authentification). Si vous l'avez désactivée pour les tests, réactivez-la avant toute mise en production :

# Dans /etc/elasticsearch/elasticsearch.yml
xpack.security.enabled: true
xpack.security.transport.ssl.enabled: true
xpack.security.http.ssl.enabled: true

Pour approfondir les sujets d'architecture et de sécurité ELK, consultez notre article sur l'architecture ELK avancée.

10. Tableau récapitulatif des ports et services

En production, seul le port 5601 (Kibana) devrait être accessible depuis l'extérieur, idéalement via un reverse proxy Nginx avec HTTPS.

11. Troubleshooting : erreurs courantes et solutions

Pour consulter les logs de chaque composant en cas de problème :

# Logs Elasticsearch
sudo tail -f /var/log/elasticsearch/elk-lenidit.log

# Logs Kibana
sudo journalctl -u kibana -f

# Logs Logstash
sudo tail -f /var/log/logstash/logstash-plain.log

# Logs Filebeat
sudo journalctl -u filebeat -f

12. Et après ?

Votre stack ELK est opérationnelle. Voici les prochaines étapes pour passer au niveau supérieur :

• Créer des dashboards Kibana personnalisés : visualisez vos logs sous forme de graphiques, alertes et tableaux de bord interactifs
• Mettre en place ILM (Index Lifecycle Management) : gérez automatiquement la rétention des index pour éviter de saturer votre disque
• Configurer des alertes : soyez notifié en cas d'anomalie (pic d'erreurs, tentatives de connexion suspectes)
• Ajouter Metricbeat : collectez les métriques système (CPU, RAM, disque) en complément des logs
• Sécurisation avancée : reverse proxy Nginx avec HTTPS/Let's Encrypt devant Kibana, rôles et utilisateurs Elasticsearch, audit logs
• Dockeriser votre stack ELK : pour un déploiement reproductible et portable. Si vous n'êtes pas encore familier avec Docker, consultez notre formation Docker

Pour approfondir les concepts d'architecture (shards, réplicas, Query DSL), retrouvez notre article dédié à l'architecture ELK. Et pour un tour d'horizon complet de la stack, commencez par le guide complet ELK.