Analyse de logs avec Graylog : Guide complet

Introduction

Dans ce laboratoire, vous apprendrez à utiliser Graylog, une puissante plateforme open-source de gestion des logs, pour collecter et analyser des données de logs. La journalisation centralisée est un composant essentiel de la cybersécurité, vous permettant de surveiller les événements système, de détecter les anomalies et d'enquêter sur les incidents de sécurité à partir d'une interface unique.

Vous commencerez par déployer l'intégralité de la pile Graylog, qui comprend MongoDB et OpenSearch (le remplacement moderne d'Elasticsearch), à l'aide de Docker Compose. Vous configurerez ensuite Graylog pour recevoir des données de logs, lui enverrez des exemples de logs, effectuerez des requêtes de recherche pour filtrer les informations, et enfin, construirez un tableau de bord visuel pour surveiller les métriques clés. À la fin de ce laboratoire, vous aurez une expérience pratique du flux de travail fondamental de l'analyse des logs dans Graylog.

Déployer Graylog avec Docker Compose

Dans cette première étape, vous allez déployer la plateforme de journalisation Graylog. Nous utiliserons Docker Compose v2, un outil pour définir et exécuter des applications Docker multi-conteneurs. Cette approche simplifie le processus d'installation en gérant tous les composants nécessaires — Graylog, OpenSearch et MongoDB — avec un seul fichier de configuration.

Commençons par préparer l'environnement et lancer les services.

Le script d'installation a déjà installé Docker Compose v2 pour vous. Vous pouvez vérifier l'installation en consultant sa version.
```
docker compose version
```
Vous devriez voir une sortie indiquant la version de Docker Compose, similaire à ceci :
```
Docker Compose version v2.29.7
```
Naviguez vers le répertoire dédié à votre configuration Graylog. Cela permet de garder votre projet organisé.
```
cd /home/labex/project/graylog
```
Ensuite, créez le fichier de configuration docker-compose.yml à l'aide de l'éditeur de texte nano. Ce fichier indique à Docker Compose quels conteneurs exécuter et comment les configurer.
```
nano docker-compose.yml
```

Copiez et collez la configuration YAML suivante dans l'éditeur nano. Cette configuration définit trois services :

mongodb : Stocke les données de configuration de Graylog.
opensearch : Indexe et stocke les messages de logs pour une recherche rapide. Notez qu'OpenSearch 2.12+ nécessite un mot de passe administrateur initial.
graylog : L'application principale, fournissant l'interface web et le moteur de traitement des logs.

services:
  mongodb:
    image: mongo:6.0
    container_name: graylog_mongodb
    volumes:
      - mongo_data:/data/db
    networks:
      - graylog_network
    healthcheck:
      test: ["CMD", "mongosh", "--eval", "db.runCommand('ping').ok"]
      interval: 30s
      timeout: 10s
      retries: 3
  opensearch:
    image: opensearchproject/opensearch:2.13.0
    container_name: graylog_opensearch
    environment:
      - discovery.type=single-node
      - plugins.security.disabled=true
      - bootstrap.memory_lock=true
      - "OPENSEARCH_JAVA_OPTS=-Xms512m -Xmx512m"
      - "OPENSEARCH_INITIAL_ADMIN_PASSWORD=StrongPassword123!"
    ulimits:
      memlock:
        soft: -1
        hard: -1
    volumes:
      - opensearch_data:/usr/share/opensearch/data
    networks:
      - graylog_network
    healthcheck:
      test:
        [
          "CMD-SHELL",
          "curl -f http://localhost:9200/_cluster/health || exit 1"
        ]
      interval: 30s
      timeout: 10s
      retries: 3
  graylog:
    image: graylog/graylog:6.1
    container_name: graylog_server
    volumes:
      - graylog_data:/usr/share/graylog/data
    environment:
      - GRAYLOG_PASSWORD_SECRET=somepasswordpepper
      - GRAYLOG_ROOT_PASSWORD_SHA2=8c6976e5b5410415bde908bd4dee15dfb167a9c873fc4bb8a81f6f2ab448a918
      - GRAYLOG_HTTP_EXTERNAL_URI=http://127.0.0.1:9000/
      - GRAYLOG_ELASTICSEARCH_HOSTS=http://opensearch:9200
      - GRAYLOG_MONGODB_URI=mongodb://mongodb:27017/graylog
    depends_on:
      mongodb:
        condition: service_healthy
      opensearch:
        condition: service_healthy
    ports:
      - "9000:9000"
      - "1514:1514"
      - "1514:1514/udp"
      - "12201:12201"
      - "12201:12201/udp"
    networks:
      - graylog_network
volumes:
  mongo_data:
  opensearch_data:
  graylog_data:
networks:
  graylog_network:
    driver: bridge

Appuyez sur Ctrl+O, puis Entrée pour enregistrer le fichier, et Ctrl+X pour quitter nano.

Maintenant, démarrez tous les services en arrière-plan en utilisant l'indicateur -d (detached).
```
docker compose up -d
```

Il faudra peut-être une minute ou deux pour que tous les services s'initialisent. Vous pouvez vérifier l'état de vos conteneurs pour vous assurer qu'ils fonctionnent correctement.

docker compose ps

Vous devriez voir les trois services (graylog_server, graylog_opensearch, graylog_mongodb) avec un State de Up.

NAME                 IMAGE                                 COMMAND                  SERVICE      CREATED              STATUS                        PORTS
graylog_mongodb      mongo:6.0                             "docker-entrypoint.s…"   mongodb      About a minute ago   Up About a minute (healthy)   27017/tcp
graylog_opensearch   opensearchproject/opensearch:2.13.0   "./opensearch-docker…"   opensearch   About a minute ago   Up About a minute (healthy)   9200/tcp, 9300/tcp, 9600/tcp, 9650/tcp
graylog_server       graylog/graylog:6.1                   "tini -- /docker-ent…"   graylog      About a minute ago   Up 34 seconds (healthy)       0.0.0.0:1514->1514/tcp, :::1514->1514/tcp, 0.0.0.0:9000->9000/tcp, 0.0.0.0:1514->1514/udp, :::9000->9000/tcp, :::1514->1514/udp, 0.0.0.0:12201->12201/tcp, 0.0.0.0:12201->12201/udp, :::12201->12201/tcp, :::12201->12201/udp

L'interface web de Graylog est maintenant accessible. Vous avez déployé avec succès la pile Graylog et êtes prêt à la configurer.

Configurer une entrée Syslog

Graylog étant en cours d'exécution, la prochaine étape consiste à configurer une "Entrée" (Input). Une entrée est un composant qui indique à Graylog comment accepter les messages de logs. Pour ce laboratoire, vous allez créer une entrée Syslog UDP, qui est une norme courante pour la collecte de logs à partir d'appareils réseau et de serveurs Linux/Unix.

Ouvrez l'interface web de Graylog dans votre navigateur. Vous pouvez le faire en cliquant sur l'onglet "Web Terminal" et en sélectionnant "Desktop" pour ouvrir le navigateur, ou en utilisant l'icône de navigateur dédiée dans l'environnement de laboratoire. Accédez à l'URL suivante :

http://127.0.0.1:9000
Connectez-vous avec les identifiants par défaut :
- Nom d'utilisateur : admin
- Mot de passe : admin
Une fois connecté, vous allez créer la nouvelle entrée. Dans la barre de navigation supérieure, cliquez sur System, puis sélectionnez Inputs dans le menu déroulant.
Sur la page des Entrées, trouvez le type d'entrée "Syslog UDP" dans la liste déroulante "Select input" et cliquez sur le bouton Launch new input à côté.
Une fenêtre modale apparaîtra. Remplissez le formulaire avec les détails suivants pour configurer l'entrée :
- Node : Sélectionnez le seul nœud disponible dans la liste déroulante (ce sera votre serveur Graylog).
- Title : Syslog UDP Input (C'est un nom descriptif pour votre entrée).
- Bind address : 0.0.0.0 (Cela indique à Graylog d'écouter les logs sur toutes les interfaces réseau du conteneur).
- Port : 1514 (C'est le port sur lequel Graylog écoutera les messages syslog entrants).
Laissez tous les autres paramètres par défaut et cliquez sur Save.
Après avoir enregistré, vous serez ramené à la page des Entrées. Votre nouvelle "Syslog UDP Input" devrait apparaître dans la liste avec un statut vert "Running", indiquant qu'elle est active et prête à recevoir des données.
Pour tester l'entrée, retournez dans votre terminal et envoyez un message de log d'exemple en utilisant l'utilitaire netcat (nc). Cette commande construit un message syslog de base et l'envoie au port UDP 1514 sur votre machine locale.
```
echo "<14>$(date +'%b %d %H:%M:%S') localhost labex: Test syslog message" | nc -w1 -u 127.0.0.1 1514
```

Vous avez maintenant configuré avec succès Graylog pour recevoir des logs. Dans la prochaine étape, vous enverrez des logs plus structurés et apprendrez à les visualiser dans l'interface Graylog.

Envoyer et visualiser des journaux d'exemple

Maintenant que votre entrée Syslog est prête, il est temps de générer et d'envoyer un lot de logs d'exemple. Cela remplira Graylog de données, vous permettant de vous entraîner à la recherche et à l'analyse. Vous allez créer un script shell simple pour simuler des messages de logs provenant d'une application.

Tout d'abord, retournez dans le répertoire racine de votre projet dans le terminal.
```
cd /home/labex/project
```
Créez un nouveau script shell nommé generate_logs.sh à l'aide de l'éditeur nano.
```
nano generate_logs.sh
```
Copiez et collez le script suivant dans l'éditeur. Ce script génère 10 messages de logs en boucle. Chaque message a un niveau de sévérité aléatoire, un horodatage et un corps de message simple. Il utilise ensuite nc pour envoyer chaque log à l'entrée Graylog que vous avez configurée.
```
#!/bin/bash
for i in {1..10}; do
  severity=$(((RANDOM % 8)))
  timestamp=$(date +'%b %d %H:%M:%S')
  echo "<$((severity + 8))>$timestamp localhost sample_app[$i]: Sample log message $i with severity $severity" | nc -w1 -u 127.0.0.1 1514
  echo "Sent log message $i"
  sleep 1
done
```
Appuyez sur Ctrl+O, Entrée, puis Ctrl+X pour enregistrer et quitter.
Rendez le script exécutable en utilisant la commande chmod.
```
chmod +x generate_logs.sh
```
Exécutez le script pour envoyer les logs à Graylog.
```
./generate_logs.sh
```
Vous verrez une sortie dans votre terminal au fur et à mesure que chaque log est envoyé.
```
Sent log message 1
Sent log message 2
...
Sent log message 10
```
Maintenant, visualisons ces logs dans Graylog. Retournez à l'interface web de Graylog dans votre navigateur (http://127.0.0.1:9000).
Cliquez sur l'onglet Search dans la barre de navigation supérieure. Vous devriez voir les messages de logs que vous venez d'envoyer apparaître dans la liste "Messages". Il faudra peut-être quelques secondes pour qu'ils soient indexés et affichés.

Vous pouvez voir comment Graylog analyse automatiquement les messages, les décomposant en champs tels que timestamp, source, application_name et severity. Ces données structurées sont essentielles à une analyse efficace des logs.

Interroger et analyser les données de journaux

Maintenant que les logs affluent dans Graylog, vous pouvez apprendre à les rechercher et à les filtrer. La fonctionnalité de recherche de Graylog est puissante et vous permet de localiser rapidement des événements spécifiques. Ceci est essentiel pour résoudre des problèmes ou enquêter sur des incidents de sécurité.

Accédez à la page Search dans l'interface web de Graylog. La barre de recherche se trouve en haut de la page.
Commençons par une requête simple. Pour trouver tous les logs de votre application simulée, tapez ce qui suit dans la barre de recherche et appuyez sur Entrée :

application_name:sample_app

Ceci filtre les résultats pour n'afficher que les logs où le champ application_name est exactement sample_app.
Maintenant, essayez d'autres requêtes pour explorer différentes capacités de filtrage :
- Trouver les logs avec un niveau de sévérité spécifique (par exemple, niveau 4) : severity:4
- Trouver les logs avec un niveau de sévérité supérieur à 5 (avertissements, erreurs, etc.) : severity:>5
- Rechercher une phrase dans le message de log : message:"log message 5"
- Combiner des filtres en utilisant AND : application_name:sample_app AND severity:<3
Vous pouvez également contrôler la période de temps de votre recherche. Par défaut, Graylog affiche les logs des "5 dernières minutes". Cliquez sur le sélecteur de plage horaire à gauche de la barre de recherche et changez-le pour Last 30 minutes afin de vous assurer que tous les logs générés sont inclus dans les résultats de la recherche.
Pour rendre une requête fréquemment utilisée facilement accessible, vous pouvez l'enregistrer. Enregistrons une recherche pour les événements de haute sévérité.
- Exécutez la requête : severity:>4
- À droite de la barre de recherche, cliquez sur l'icône de disquette (Save Search).
- Dans la boîte de dialogue "Save Search", entrez un Title, par exemple, High Severity Events.
- Cliquez sur Save.
Vous pouvez maintenant accéder à cette recherche enregistrée à tout moment depuis la liste "Saved Searches" dans la barre latérale gauche, ce qui vous permet de vérifier rapidement les événements critiques.

Créer un tableau de bord de surveillance

Alors que la page de recherche est idéale pour les investigations actives, les tableaux de bord offrent un aperçu général de vos données de logs. Dans cette dernière étape, vous allez créer un tableau de bord avec plusieurs widgets pour visualiser les métriques clés de vos logs.

Dans l'interface web de Graylog, naviguez vers la section Dashboards depuis le menu supérieur.
Cliquez sur le bouton Create dashboard.
- Entrez un Title : Application Health Dashboard
- Entrez une Description : Monitors the health and activity of sample_app.
- Cliquez sur Create.
Vous avez maintenant un tableau de bord vide. Ajoutons-lui quelques widgets. Cliquez sur le bouton Unlock / Edit pour passer en mode édition.
Ajouter un widget "Log Count" : Ce widget affichera le nombre total de messages de logs au fil du temps.
- Cliquez sur Create Widget for Dashboard.
- Sélectionnez Aggregation comme type de widget.
- Dans la fenêtre de configuration :
  - Title : Total Log Volume
  - Sous "Rows", sélectionnez timestamp comme champ.
  - Choisissez Bar Chart comme type de visualisation.
- Cliquez sur Create.
Ajouter un widget "Severity Distribution" : Ce widget montrera la répartition des logs par niveau de sévérité.
- Cliquez à nouveau sur Create Widget for Dashboard.
- Sélectionnez Aggregation comme type de widget.
- Dans la fenêtre de configuration :
  - Title : Log Severity Distribution
  - Sous "Rows", sélectionnez severity comme champ.
  - Choisissez Pie Chart comme type de visualisation.
- Cliquez sur Create.
Ajouter un widget "Recent Messages" : Ce widget affichera une liste des messages de logs les plus récents.
- Cliquez sur Create Widget for Dashboard.
- Sélectionnez Messages comme type de widget.
- Dans la fenêtre de configuration :
  - Title : Recent Log Messages
  - Dans le champ "Streams", assurez-vous que All messages est sélectionné.
- Cliquez sur Create.
Une fois que vous avez ajouté les widgets, vous pouvez les faire glisser et les déposer pour organiser la disposition. Vous pouvez également les redimensionner en faisant glisser leurs coins. Disposez-les de manière à ce qu'ils soient faciles à lire.
Lorsque vous êtes satisfait de la disposition, cliquez sur le bouton Lock / Save dans le coin supérieur droit pour enregistrer votre tableau de bord.

Vous avez maintenant créé un tableau de bord de surveillance de base. Dans un scénario réel, des tableaux de bord comme celui-ci sont inestimables pour surveiller la santé du système et la posture de sécurité.

Résumé

Dans ce laboratoire, vous avez acquis une expérience pratique des fonctionnalités principales de Graylog pour la gestion et l'analyse des logs. Vous avez commencé par déployer un environnement Graylog complet à l'aide de Docker Compose, qui comprenait le serveur Graylog, OpenSearch et MongoDB.

Vous avez ensuite configuré une entrée Syslog pour permettre la collecte des logs et utilisé un script pour envoyer des données de logs d'exemple, simulant des logs d'application réels. Vous avez appris à utiliser le puissant langage de recherche et de requête de Graylog pour filtrer et trouver des informations spécifiques dans vos logs. Enfin, vous avez tout réuni en construisant un tableau de bord personnalisé avec divers widgets pour visualiser les métriques de logs, offrant une vue d'ensemble de l'activité du système. Ces compétences constituent une base solide pour utiliser Graylog dans la surveillance de la cybersécurité et l'intelligence opérationnelle.

Analyser les logs dans Graylog