runtipi-appstore/apps/wazuh-runtipi/metadata/description.md

Wazuh 4.14.1 pour Runtipi

Déploiement de Wazuh, la plateforme open-source de sécurité unifiée (XDR et SIEM), sur Runtipi.

Version: Wazuh 4.14.1 Plateforme: Runtipi 4.6.5 Status: ✅ Stable

⚠️ IMPORTANT SÉCURITÉ: Les mots de passe par défaut DOIVENT être changés avant la mise en production. Voir la section "Configuration des Identifiants" ci-dessous.

---

📖 Qu'est-ce que Wazuh ?

Wazuh est une plateforme de sécurité open-source qui fournit:

• SIEM (Security Information and Event Management) - Centralisation et analyse des logs de sécurité
• XDR (Extended Detection and Response) - Détection et réponse aux menaces
• Conformité - Vérification de conformité (PCI DSS, HIPAA, GDPR, etc.)
• Détection des vulnérabilités - Scan et gestion des vulnérabilités
• Détection d'intrusion - Monitoring temps réel des fichiers système
• Réponse aux incidents - Automatisation des réponses de sécurité

Ressources Officielles

• Site Web: https://wazuh.com/
• Documentation: https://documentation.wazuh.com/current/
• GitHub Wazuh: https://github.com/wazuh/wazuh
• Wazuh Docker: https://github.com/wazuh/wazuh-docker
• Community: https://groups.google.com/g/wazuh

---

🏗️ Architecture

Ce projet déploie une stack Wazuh complète sur Runtipi avec 5 conteneurs Docker:

┌──────────────────────────────────────────────────────────────┐
│                    Votre Infrastructure                      │
│                                                              │
│   ┌──────────┐   ┌──────────┐   ┌──────────┐   ┌──────────┐  │
│   │ Serveur  │   │ Serveur  │   │ Desktop  │   │  Cloud   │  │
│   │  Linux   │   │ Windows  │   │  MacOS   │   │ Instance │  │
│   └────┬─────┘   └────┬─────┘   └────┬─────┘   └────┬─────┘  │
│        │              │              │              │        │
│        │         Wazuh Agents (1514 / 1515)         │        │
│        └──────────────┬──────────────┬──────────────┘        │
└───────────────────────┼──────────────┼───────────────────────┘
                        ▼              │
┌───────────────────────┼──────────────┼───────────────────────┐
│                   Stack Wazuh (Runtipi)                      │
│                                                              │
│  ┌────────────────────────────────────────────────────────┐  │
│  │     Wazuh Manager (Ports 1514 / 1515 / 55000)          │  │
│  │  - Collecte des événements                             │  │
│  │  - Analyse & corrélation                               │  │
│  │  - Règles de détection                                 │  │
│  │  - API REST                                            │  │
│  └────────────────────┬───────────────────────────────────┘  │
│                       │ (Filebeat)                           │
│                       ▼                                      │
│  ┌────────────────────────────────────────────────────────┐  │
│  │     Wazuh Indexer (OpenSearch - Port 9200)             │  │
│  │  - Stockage & indexation                               │  │
│  │  - Recherches rapides                                  │  │
│  │  - Statistiques / agrégations                          │  │
│  └────────────────────┬───────────────────────────────────┘  │
│                       │                                      │
│                       ▼                                      │
│  ┌────────────────────────────────────────────────────────┐  │
│  │     Wazuh Dashboard (Port 5601) - Interface Web        │  │
│  │  - Visualisation des alertes                           │  │
│  │  - Tableaux de bord                                    │  │
│  │  - Gestion des agents                                  │  │
│  │  - Configuration / Admin                               │  │
│  └────────────────────────────────────────────────────────┘  │
│                                                              │
│  Services additionnels :                                     │
│   • wazuh-certs : génération certificats SSL/TLS             │
│   • wazuh-indexer-init : initialisation sécurité OpenSearch  │
└──────────────────────────────────────────────────────────────┘
                        │
                        ▼
              Accès via navigateur
              https://VOTRE_IP:5601

Composants

1. Wazuh Manager - Analyse les événements de sécurité collectés par les agents
2. Wazuh Indexer - Base de données OpenSearch pour stocker et indexer les événements
3. Wazuh Dashboard - Interface web pour visualiser et gérer la sécurité
4. Wazuh Certs Generator - Génère les certificats SSL/TLS pour les communications sécurisées
5. Wazuh Indexer Init - Initialise la configuration de sécurité d'OpenSearch

---

🚀 Installation

Prérequis

• Runtipi 4.6.5+ installé et fonctionnel
• Ressources minimales:
  • CPU: 2 cores minimum (4 cores recommandés)
  • RAM: 4GB minimum (8GB recommandés pour production)
  • Disque: 20GB minimum (60GB+ recommandé pour production avec agents)
• Accès root au serveur Runtipi

⚠️ IMPORTANT - Configuration système requise:

Avant l'installation, exécutez cette commande sur votre serveur:

sudo sysctl -w vm.max_map_count=262144
echo "vm.max_map_count=262144" | sudo tee -a /etc/sysctl.conf

Cette configuration est obligatoire pour le bon fonctionnement d'OpenSearch (le moteur d'indexation de Wazuh). Sans elle, le conteneur wazuh-indexer ne démarrera pas correctement.

Étape 1: Installer via Runtipi

1. Ouvrir l'interface Runtipi dans votre navigateur
2. Aller dans "App Store"
3. Rechercher "Wazuh"
4. Cliquer sur "Install"
5. ⚠️ IMPORTANT : Attendre 5 minutes complètes.

Warning

Le déploiement de Wazuh est lourd. Le service wazuh-dashboard peut redémarrer plusieurs fois pendant les 5 premières minutes le temps que l'indexeur soit prêt. Si vous voyez le statut "Rebooting" ou "Starting", ne touchez à rien et patientez. C'est le comportement normal du script de surveillance (Watchdog).

C'est tout! L'installation est 100% automatique ✅

Étape 2: Vérifier l'Installation

Connectez-vous en SSH au serveur Runtipi:

# Vérifier que tous les services sont démarrés et healthy
docker ps -a | grep wazuh

Résultat attendu:

Vous devriez voir 5 conteneurs:

• ✅ wazuh-certs - Up X min (healthy)
• ✅ wazuh-indexer - Up X min (healthy)
• ✅ wazuh-indexer-init - Up X min (healthy)
• ✅ wazuh-manager - Up X min (healthy)
• ✅ wazuh-dashboard - Up X min (healthy)

Note: Le conteneur wazuh-indexer-init reste running avec un health check (adaptation Runtipi). Il initialise la sécurité OpenSearch au démarrage, crée un fichier marker .init-complete, puis reste en veille. Le statut "healthy" confirme que l'initialisation est terminée.

Étape 3: Accéder au Dashboard

1. Ouvrir votre navigateur
2. Aller à: https://VOTRE_IP_SERVEUR:5601
3. Se connecter avec les credentials par défaut

🔐 Configuration des Identifiants

Variables d'Environnement

Lors de l'installation via Runtipi, vous pouvez configurer les identifiants dans l'interface GUI:

Variable	Description	Valeur par défaut
INDEXER_USERNAME	Nom d'utilisateur admin de l'indexer	admin
INDEXER_PASSWORD	Mot de passe admin de l'indexer	admin
DASHBOARD_USERNAME	Utilisateur interne dashboard→indexer	kibanaserver
DASHBOARD_PASSWORD	Mot de passe interne dashboard→indexer	kibanaserver
API_PASSWORD	Mot de passe de l'API REST (user: wazuh-wui)	MyS3cr37P450r.*-

Credentials par Défaut

Si vous utilisez les valeurs par défaut:

Service	Username	Password	Usage
Dashboard	admin	admin	Interface web principale
API	wazuh-wui	MyS3cr37P450r.*-	API REST du manager
Kibanaserver	kibanaserver	kibanaserver	Connexion dashboard→indexer

⚠️ AVERTISSEMENT: Ces mots de passe par défaut sont publics. Vous DEVEZ les changer immédiatement après l'installation en suivant la procédure officielle ci-dessous.

Étape 4: Changer les Mots de Passe (OBLIGATOIRE pour Production)

⚠️ AVERTISSEMENT DE SÉCURITÉ: Les mots de passe par défaut sont publics et constituent une vulnérabilité critique. Vous DEVEZ les changer après l'installation.

⚠️ Source officielle: Wazuh Documentation - Changing Default Passwords

Note importante pour Runtipi: La configuration des mots de passe via les variables d'environnement Runtipi AVANT installation ne suffit PAS. Vous devez impérativement suivre la procédure officielle ci-dessous APRÈS l'installation pour sécuriser votre déploiement.

Procédure Officielle de Changement des Mots de Passe

A. Changer le mot de passe des utilisateurs Indexer (admin/kibanaserver):

1. Se déconnecter du dashboard Wazuh pour éviter les conflits de session

2. Générer le hash du nouveau mot de passe:

   docker run --rm -ti wazuh/wazuh-indexer:4.14.1 bash /usr/share/wazuh-indexer/plugins/opensearch-security/tools/hash.sh
   

   Exemple d'interaction:

   [Password:]
   $2y$12$aBcDeFgHiJkLmNoPqRsTuVwXyZ123456789abcdefghijklmnopqr
   

   ⚠️ IMPORTANT: Copiez le hash complet (commence par $2y$12$...). Vous en aurez besoin à l'étape suivante.

3. Éditer le fichier internal_users.yml:

   Le wildcard * fonctionne directement avec nano:

   nano /opt/runtipi/app-data/*/wazuh-runtipi/data/indexer-security/internal_users.yml
   

   Pour changer le mot de passe admin:

   • Trouvez la section admin:
   • Remplacez le hash dans la ligne hash: par le nouveau hash généré
   • Exemple:

   admin:
     hash: "$2y$12$VOTRE_NOUVEAU_HASH_ICI"
     reserved: true
     backend_roles:
     - "admin"
     description: "Demo admin user"
   

   Pour changer le mot de passe kibanaserver:

   • Trouvez la section kibanaserver:
   • Remplacez le hash de la même manière

   Sauvegardez: Ctrl+X, puis y, puis Entrée

4. Redémarrer l'application via l'interface Runtipi:

   • Allez dans Runtipi → Apps → Wazuh
   • Cliquez sur "Arreter"
   • Attendez quelques secondes
   • Cliquez sur "Démarrer"

5. Appliquer les changements avec securityadmin.sh:

   # Se connecter au conteneur wazuh-indexer
   docker exec -it $(docker ps --filter "name=wazuh-indexer" --format "{{.Names}}" | grep -v init) bash
   

   Une fois dans le conteneur:

   # Configurer les variables d'environnement
   export INSTALLATION_DIR=/usr/share/wazuh-indexer
   export JAVA_HOME=/usr/share/wazuh-indexer/jdk
   
   # Exécuter securityadmin.sh
   bash /usr/share/wazuh-indexer/plugins/opensearch-security/tools/securityadmin.sh \
     -cd /usr/share/wazuh-indexer/opensearch-security/ \
     -cacert /usr/share/wazuh-indexer/config/certs/root-ca.pem \
     -cert /usr/share/wazuh-indexer/config/certs/admin.pem \
     -key /usr/share/wazuh-indexer/config/certs/admin-key.pem \
     -p 9200 -nhnv -icl
   

   Résultat attendu:

   Will update '_all' config types
   SUCC: Configuration for 'config' created or updated
   SUCC: Configuration for 'roles' created or updated
   SUCC: Configuration for 'rolesmapping' created or updated
   SUCC: Configuration for 'internalusers' created or updated
   ...
   Done with success
   

   Quittez le conteneur: exit

6. Mettre à jour les variables d'environnement Runtipi:

   • Allez dans Runtipi → Apps → Wazuh → Paramètres
   • Modifiez INDEXER_USERNAME et INDEXER_PASSWORD avec vos nouveaux identifiants
   • Modifiez aussi DASHBOARD_USERNAME et DASHBOARD_PASSWORD si vous avez changé kibanaserver
   • Cliquez sur "Mettre à jour" puis "Redémarrer" l'application

7. Tester les nouveaux mots de passe:

   Test admin (Dashboard - interface web):

   # Ouvrir dans le navigateur
   https://VOTRE_IP:5601
   # Connectez-vous avec: admin / VOTRE_NOUVEAU_MOT_DE_PASSE
   

   ✅ Succès si vous pouvez vous connecter au dashboard

   Test admin (API OpenSearch - depuis le conteneur):

   # Le port 9200 n'est PAS exposé à l'hôte (sécurité)
   # Il faut tester depuis un conteneur Wazuh
   docker exec -it $(docker ps --filter "name=wazuh-indexer" --format "{{.Names}}" | grep -v init) bash -c \
     "curl -ks https://wazuh.indexer:9200/_cluster/health?pretty -u admin:VOTRE_NOUVEAU_MOT_DE_PASSE"
   

   ✅ Succès si vous voyez: "cluster_name" : "wazuh-cluster"

   Test kibanaserver:

   docker exec -it $(docker ps --filter "name=wazuh-dashboard" --format "{{.Names}}") bash -c \
     "curl -ks https://wazuh.indexer:9200 -u kibanaserver:VOTRE_NOUVEAU_MOT_DE_PASSE"
   

   ✅ Succès si vous voyez: "name" : "wazuh.indexer"

   ⚠️ Test de sécurité (vérifier que les anciens mots de passe ne fonctionnent PLUS):

   docker exec -it $(docker ps --filter "name=wazuh-indexer" --format "{{.Names}}" | grep -v init) bash -c \
     "curl -ks https://wazuh.indexer:9200 -u admin:admin"
   

   ✅ Succès si vous voyez: "type":"security_exception","reason":"Unauthorized"

B. Changer le mot de passe de l'API Wazuh (wazuh-wui):

⚠️ Source officielle: Wazuh Documentation - Changing API Password

⚠️ Exigences du mot de passe: 8-64 caractères avec majuscules, minuscules, chiffres ET symboles

1. Choisir un nouveau mot de passe fort:

   • Exemple: MyN3wP@ssw0rd!2024
   • Doit respecter les critères ci-dessus

2. Mettre à jour le fichier wazuh.yml dans le conteneur dashboard:

   # Se connecter au conteneur dashboard
   docker exec -it $(docker ps --filter "name=wazuh-dashboard" --format "{{.Names}}") bash
   

   Une fois dans le conteneur:

   # Afficher le fichier pour voir son contenu actuel
   cat /usr/share/wazuh-dashboard/data/wazuh/config/wazuh.yml
   
   # Remplacer l'ancien mot de passe par le nouveau
   sed -i 's|password: MyS3cr37P450r\.\*-|password: VOTRE_NOUVEAU_MOT_DE_PASSE|g' \
     /usr/share/wazuh-dashboard/data/wazuh/config/wazuh.yml
   
   # Vérifier que le changement a été effectué
   grep 'password:' /usr/share/wazuh-dashboard/data/wazuh/config/wazuh.yml
   
   # Quitter le conteneur
   exit
   

   ⚠️ IMPORTANT: Remplacez VOTRE_NOUVEAU_MOT_DE_PASSE par votre mot de passe réel (sans guillemets)

3. Mettre à jour la variable d'environnement dans Runtipi:

   • Allez dans Runtipi → Apps → Wazuh → Paramètres
   • Trouvez API_PASSWORD
   • Remplacez MyS3cr37P450r.*- par votre nouveau mot de passe
   • Cliquez sur "Mettre à jour" puis "Redémarrer" l'application

4. Vérifier que le changement est effectif:

   # Tester l'API avec le nouveau mot de passe
   curl -k -u wazuh-wui:VOTRE_NOUVEAU_MOT_DE_PASSE https://localhost:55000/security/user/authenticate
   

   Résultat attendu:

   {
     "data": {
       "token": "eyJ0eXAiOiJKV1QiLCJhbGc..."
     }
   }
   

   ✅ Si vous obtenez un token, le changement est réussi!

⚠️ NOTE IMPORTANTE: Le fichier wazuh.yml est stocké dans /usr/share/wazuh-dashboard/data/ qui n'est PAS un volume persistant. Cela signifie que si vous supprimez complètement l'application (pas juste un redémarrage), vous devrez refaire cette modification. Pour un simple redémarrage ou mise à jour, le fichier est préservé.

---

⚠️ RÉCAPITULATIF IMPORTANT:

Pour les mots de passe Indexer (admin/kibanaserver):

• Il n'existe aucun moyen de contourner la procédure hash.sh + securityadmin.sh
• Même si vous définissez des mots de passe dans le formulaire Runtipi avant l'installation, vous devrez obligatoirement exécuter cette procédure
• C'est la seule méthode officielle supportée par Wazuh pour OpenSearch

Pour le mot de passe API Wazuh (wazuh-wui):

• La modification via variables d'environnement Runtipi est suffisante
• Pas besoin de securityadmin.sh pour l'API

---

🔍 Validation Post-Installation

Diagnostic Automatique

Un script de diagnostic complet est fourni pour vérifier la santé de votre installation:

# Se connecter en SSH au serveur
ssh user@VOTRE_SERVEUR

# Exécuter le diagnostic
bash /opt/runtipi/app-data/*/wazuh-runtipi/data/debug/wazuh-health-check.sh

Ce script vérifie automatiquement:

• ✅ Santé de tous les services (healthy/unhealthy)
• ✅ Utilisation disque (7 GB attendu pour installation fraîche)
• ✅ Présence des 8 fichiers de sécurité OpenSearch
• ✅ Connectivité réseau entre conteneurs
• ✅ Configuration du dashboard et manager
• ✅ Variables d'environnement SSL Filebeat (méthode officielle)
• ✅ Initialisation de la sécurité OpenSearch

Vérification via l'Interface Web

Après l'installation, vous pouvez également vérifier la santé de votre déploiement directement dans l'interface Wazuh:

URL de vérification: https://VOTRE_IP:5601/app/logs#/health-check

Cette page affiche:

• État des services Wazuh (indexer, manager, dashboard)
• Statistiques de performance en temps réel
• Alertes de santé du cluster
• Métriques de connectivité des agents

Note: Remplacez VOTRE_IP par l'adresse IP de votre serveur Runtipi. Si vous utilisez un proxy inverse avec un nom de domaine, utilisez celui-ci à la place.

---

📱 Déployer des Agents Wazuh

Une fois Wazuh installé, vous devez déployer des agents sur vos serveurs/postes à surveiller.

Architecture Agent ↔ Manager

Serveur/Desktop à surveiller          Serveur Wazuh (Runtipi)
┌─────────────────────┐               ┌────────────────────┐
│                     │               │                    │
│   Wazuh Agent  ─────┼──────────────►│   Wazuh Manager    │
│   (Service)         │   Port 1514   │   (Collecte)       │
│                     │   1515        │                    │
│   - Logs système    │               │   - Analyse        │
│   - Fichiers        │               │   - Corrélation    │
│   - Processus       │               │   - Alertes        │
│   - Réseau          │               │                    │
└─────────────────────┘               └────────────────────┘

Agent Linux (Debian/Ubuntu)

# 1. Télécharger l'agent
wget https://packages.wazuh.com/4.x/apt/pool/main/w/wazuh-agent/wazuh-agent_4.14.1-1_amd64.deb

# 2. Installer
sudo dpkg -i wazuh-agent_4.14.1-1_amd64.deb

# 3. Configurer l'adresse du manager (remplacer VOTRE_IP par l'IP de votre serveur Runtipi)
sudo sed -i "s/<address>MANAGER_IP<\/address>/<address>VOTRE_IP<\/address>/" /var/ossec/etc/ossec.conf

# 4. Démarrer l'agent
sudo systemctl daemon-reload
sudo systemctl enable wazuh-agent
sudo systemctl start wazuh-agent

# 5. Vérifier le statut
sudo systemctl status wazuh-agent

Agent Windows

1. Télécharger l'installeur: https://packages.wazuh.com/4.x/windows/wazuh-agent-4.14.1-1.msi

2. Ouvrir PowerShell en tant qu'Administrateur et exécuter:

# Installer (remplacer VOTRE_IP par l'IP de votre serveur Runtipi)
msiexec /i wazuh-agent-4.14.1-1.msi /q WAZUH_MANAGER="VOTRE_IP"

# Démarrer le service
NET START WazuhSvc

# Vérifier le statut
Get-Service WazuhSvc

Agent MacOS

# 1. Télécharger l'agent
curl -O https://packages.wazuh.com/4.x/macos/wazuh-agent-4.14.1-1.pkg

# 2. Installer
sudo installer -pkg wazuh-agent-4.14.1-1.pkg -target /

# 3. Configurer (remplacer VOTRE_IP)
sudo sed -i '' "s/<address>MANAGER_IP<\/address>/<address>VOTRE_IP<\/address>/" /Library/Ossec/etc/ossec.conf

# 4. Démarrer
sudo /Library/Ossec/bin/wazuh-control start

Vérifier les Agents dans le Dashboard

1. Se connecter au dashboard Wazuh
2. Cliquer sur ☰ → Agents
3. Vérifier que vos agents apparaissent avec le statut "Active" (après 1-2 minutes)

Chaque agent doit montrer:

• ✅ Status: Active (point vert)
• ✅ IP Address: L'IP de la machine
• ✅ Version: 4.14.1
• ✅ Last keep alive: < 1 minute

---

🎯 Utilisation du Dashboard

Sections Principales

1. Overview / Vue d'ensemble

   • Résumé des alertes de sécurité
   • Événements récents
   • Top agents
   • Statistiques globales

2. Agents

   • Liste de tous les agents
   • Statut (actif/déconnecté)
   • Détails par agent
   • Déploiement de nouveaux agents

3. Security Events / Événements

   • Alertes de sécurité en temps réel
   • Filtrage par sévérité, agent, règle
   • Timeline des événements
   • Détails complets des alertes

4. Compliance / Conformité

   • PCI DSS
   • GDPR
   • HIPAA
   • NIST 800-53
   • CIS benchmarks

5. Vulnerability Detection

   • CVE détectées sur vos systèmes
   • Score CVSS
   • Packages vulnérables
   • Recommandations de mise à jour

6. File Integrity Monitoring (FIM)

   • Changements de fichiers système
   • Modifications non autorisées
   • Ajouts/suppressions de fichiers

Exemple: Voir les Alertes de Sécurité

1. Menu ☰ → Security Events
2. Filtrer par sévérité: Sélectionner "High" ou "Critical"
3. Cliquer sur une alerte pour voir les détails complets:
   • Description de la menace
   • Agent source
   • Fichiers/processus impliqués
   • Actions recommandées
   • Contexte MITRE ATT&CK

---

🔧 Configuration Avancée

Ports Utilisés

Port	Protocole	Service	Usage
5601	HTTPS	Dashboard	Interface web (publique)
9200	HTTPS	Indexer	API OpenSearch (interne)
1514	TCP	Manager	Communication avec les agents (publique)
1515	TCP	Manager	Enrollment des agents (publique)
514	UDP	Manager	Collection Syslog
55000	HTTPS	Manager	API REST (interne)

Note: Seul les ports 5601, 1514, 1515 (Dashboard et les agents) sont à exposer publiquement. Les autres ports sont utilisés pour la communication interne entre les composants Wazuh et les agents.

Variables d'Environnement Techniques

En plus des variables de configuration utilisateur, le déploiement utilise ces variables techniques (configurées automatiquement):

Indexer:

• OPENSEARCH_JAVA_OPTS: -Xms1g -Xmx1g -Dlog4j2.formatMsgNoLookups=true
  • Configure le heap Java (1GB) et active la protection contre la vulnérabilité Log4j
• DISABLE_INSTALL_DEMO_CONFIG: true
  • Désactive la configuration de démonstration (sécurité)
• bootstrap.memory_lock: true
  • Verrouille la mémoire pour éviter le swapping (performance)

Manager:

• WAZUH_NODE_TYPE: master
  • Définit explicitement le type de nœud (single-node deployment)
• FILEBEAT_SSL_VERIFICATION_MODE: full
  • Active la vérification SSL complète pour Filebeat
• SSL_CERTIFICATE_AUTHORITIES, SSL_CERTIFICATE, SSL_KEY
  • Chemins vers les certificats SSL générés automatiquement

Dashboard:

• SERVER_SSL_ENABLED: true
  • Active explicitement le SSL pour le serveur web
• SERVER_SSL_CERTIFICATE, SERVER_SSL_KEY
  • Certificats SSL pour HTTPS

Note de sécurité: Le flag -Dlog4j2.formatMsgNoLookups=true protège contre CVE-2021-44228 (Log4Shell). Cette configuration suit les recommandations de sécurité officielles de Wazuh.

Limites de Ressources

Configuration par défaut des conteneurs basée sur les recommandations Kubernetes de Wazuh:

Indexer:

• CPU: Réservé: 0.5 / Limite: 1.0 core
• RAM: Réservé: 1GB / Limite: 2GB
• Java heap: 1GB min/max (variable OPENSEARCH_JAVA_OPTS: -Xms1g -Xmx1g -Dlog4j2.formatMsgNoLookups=true)
• Memory lock: illimité (ulimits memlock: -1)
• File descriptors: 65536
• Sécurité: Log4j vulnerability mitigation activé

Manager:

• CPU: Réservé: 1.0 / Limite: 2.0 cores
• RAM: Réservé: 1GB / Limite: 2GB
• Memory lock: illimité (ulimits memlock: -1)
• File descriptors: 655360
• Type de nœud: Master (single-node deployment)

Dashboard:

• CPU: Réservé: 0.2 / Limite: 0.4 core
• RAM: Réservé: 512MB / Limite: 2GB
• SSL: Activé explicitement via SERVER_SSL_ENABLED: true

Note: Ces limites sont configurées dans la section deploy.resources du fichier docker-compose.json. Les limites CPU et RAM sont basées sur les configurations de production Kubernetes de Wazuh pour assurer une stabilité optimale.

Espace Disque

Utilisation disque:

• Installation fraîche: 7 GB
• Production recommandée (basée sur les configurations Kubernetes):
  • Indexer: 10Gi minimum pour stockage des indices OpenSearch
  • Manager: 50Gi minimum pour logs, queue et données d'agents
  • Dashboard: Aucun stockage persistant requis (service sans état)

L'espace augmente avec:

• Nombre d'agents connectés
• Volume d'événements générés
• Période de rétention des logs (7 jours par défaut)

Volumes critiques à sauvegarder:

• indexer-data - État du cluster et indices OpenSearch
• manager-logs - Logs d'événements de sécurité
• manager-queue - Queue de données des agents

Pour surveiller:

# Vérifier la taille totale (incluant data/)
du -sh /opt/runtipi/app-data/*/wazuh-runtipi

# Vérifier uniquement les données persistantes
du -sh /opt/runtipi/app-data/*/wazuh-runtipi/data

# Vérifier par composant
du -sh /opt/runtipi/app-data/*/wazuh-runtipi/data/indexer-data
du -sh /opt/runtipi/app-data/*/wazuh-runtipi/data/manager-logs
du -sh /opt/runtipi/app-data/*/wazuh-runtipi/data/manager-queue

Personnalisation du Manager

Fichier de configuration principal: /var/ossec/etc/ossec.conf

Exemples de personnalisation:

• Règles de détection personnalisées
• Alertes par email
• Intégrations (Slack, PagerDuty, etc.)
• Configuration FIM (File Integrity Monitoring)
• Politique de rétention des logs

Voir la documentation officielle: https://documentation.wazuh.com/current/user-manual/reference/ossec-conf/

---

🔄 Mises à Jour

Runtipi gère automatiquement les mises à jour de l'application Wazuh.

Processus de Mise à Jour

1. Runtipi détecte une nouvelle version dans son repository
2. Télécharge le nouveau docker-compose.json
3. Redémarre les conteneurs avec la nouvelle configuration
4. Préserve vos données et configurations

Aucune action manuelle requise! ✅

Vérification Post-Mise à Jour

# Attendre 2-3 minutes après la mise à jour

# Vérifier que tous les services sont healthy
docker ps -a | grep wazuh

# Diagnostic complet
bash /opt/runtipi/app-data/*/wazuh-runtipi/data/debug/wazuh-health-check.sh

---

🆘 Dépannage

Le Dashboard n'est pas Accessible

Symptôme: Impossible d'accéder à https://VOTRE_IP:5601

Solutions:

# 1. Vérifier que le conteneur dashboard est running
docker ps | grep dashboard

# 2. Vérifier les logs du dashboard
docker logs wazuh-runtipi_*-wazuh-dashboard-1

# 3. Vérifier que le port 5601 est bien exposé
docker port wazuh-runtipi_*-wazuh-dashboard-1

# 4. Tester depuis le serveur
curl -I http://localhost:5601 || curl -I https://localhost:5601

Un Service est "Unhealthy"

Symptôme: docker ps montre un conteneur avec (unhealthy)

Solutions:

# 1. Voir les logs du service problématique
docker logs wazuh-runtipi_*-wazuh-SERVICE-1

# Exemples:
docker logs wazuh-runtipi_*-wazuh-indexer-1
docker logs wazuh-runtipi_*-wazuh-manager-1
docker logs wazuh-runtipi_*-wazuh-dashboard-1

# 2. Redémarrer le service
docker restart wazuh-runtipi_*-wazuh-SERVICE-1

# 3. Si le problème persiste, redémarrer toute la stack
docker restart $(docker ps -q --filter "name=wazuh-runtipi")

Les Agents n'Apparaissent Pas

Symptôme: Agents installés mais invisibles dans le dashboard

Vérifications:

1. Sur la machine agent:

# Linux/MacOS
sudo /var/ossec/bin/agent-auth -m VOTRE_IP
sudo systemctl restart wazuh-agent
sudo tail -f /var/ossec/logs/ossec.log

# Windows (PowerShell Admin)
Restart-Service WazuhSvc
Get-Content "C:\Program Files (x86)\ossec-agent\ossec.log" -Tail 20 -Wait

2. Sur le serveur Wazuh:

# Vérifier les logs du manager
docker logs wazuh-runtipi_*-wazuh-manager-1 | grep -i "agent"

# Vérifier que les ports 1514/1515 sont bien ouverts
docker port wazuh-runtipi_*-wazuh-manager-1

Utilisation Disque Anormalement Élevée

Symptôme: Plus de 20GB utilisés

Solutions:

# 1. Vérifier la taille actuelle
du -sh /opt/runtipi/app-data/*/wazuh-runtipi/data

# 2. Vérifier la taille des indices OpenSearch
docker exec wazuh-runtipi_*-wazuh-indexer-1 curl -k -u admin:admin https://localhost:9200/_cat/indices?v

# 3. Réduire la période de rétention (connexion dashboard)
# Settings → Indices → wazuh-alerts-* → Modifier la rétention

"Index Pattern Warning" dans le health-check

Symptôme: Message No template found for [wazuh-alerts-*]

Explication: C'est normal pour une installation fraîche sans agents!

Les indices wazuh-alerts-* sont créés automatiquement quand:

1. Des agents Wazuh sont connectés
2. Ces agents génèrent des événements/alertes
3. Le manager envoie les données à l'indexer

Solution: Déployez votre premier agent Wazuh. L'alerte disparaîtra automatiquement.

---

📚 Documentation et Ressources

Documentation Wazuh Officielle

• Getting Started: https://documentation.wazuh.com/current/getting-started/
• User Manual: https://documentation.wazuh.com/current/user-manual/
• Installation Guide: https://documentation.wazuh.com/current/installation-guide/
• API Reference: https://documentation.wazuh.com/current/user-manual/api/
• Ruleset: https://documentation.wazuh.com/current/user-manual/ruleset/

Projets Source

• Wazuh (Core): https://github.com/wazuh/wazuh
• Wazuh Docker: https://github.com/wazuh/wazuh-docker
• Wazuh Kubernetes: https://github.com/wazuh/wazuh-kubernetes
• Wazuh Documentation: https://github.com/wazuh/wazuh-documentation

Communauté et Support

• Google Group: https://groups.google.com/g/wazuh
• Slack Community: https://wazuh.com/community/join-us-on-slack/
• GitHub Issues: https://github.com/wazuh/wazuh/issues

Formations et Certifications

• Wazuh Free Training: https://wazuh.com/platform/siem/
• YouTube Channel: https://www.youtube.com/@wazuh

---

📁 Structure du Projet

wazuh-runtipi/
├── docker-compose.json                ← Configuration Docker Compose
├── config.json                        ← Configuration Runtipi
│
├── data/
│   ├── config/
│   │   └── certs.yml                  ← Configuration certificats SSL
│   │
│   ├── scripts/                       ← Scripts d'initialisation
│   │   ├── init-certs.sh              │  Génération certificats SSL
│   │   ├── init-indexer-init.sh       │  Initialisation sécurité OpenSearch
│   │   ├── init-manager.sh            │  Configuration manager + Filebeat
│   │   └── init-dashboard.sh          │  Configuration dashboard + Watchdog
│   │
│   ├── debug/
│   │   └── wazuh-health-check.sh      ← Script de diagnostic complet
│   │
│   ├── indexer-security/              ← Configuration sécurité OpenSearch
│   │   └── .gitkeep                   │  (Dossier vide - tous les fichiers
│   │                                  │   sont copiés depuis le Docker au
│   │                                  │   premier démarrage)
│   │
│   │   # Les 8 fichiers suivants sont automatiquement copiés
│   │   # depuis l'image wazuh-indexer lors du premier démarrage:
│   │   # - config.yml
│   │   # - roles.yml
│   │   # - roles_mapping.yml
│   │   # - internal_users.yml
│   │   # - action_groups.yml
│   │   # - tenants.yml
│   │   # - nodes_dn.yml
│   │   # - whitelist.yml
│
└── metadata/
    ├── description.md                 ← Documentation complète (ce fichier)
    └── logo.jpg                       ← Logo de l'application

Notes importantes:

• Scripts d'initialisation dans data/scripts/ sont montés dans les conteneurs et exécutés au démarrage
• Architecture simple : Un script init par conteneur (init-certs.sh, init-indexer-init.sh, init-manager.sh, init-dashboard.sh)
• Configuration persistante via symlinks vers les dossiers personnalisés
• Filebeat : Configuration automatique via variables d'environnement officielles (FILEBEAT_SSL_VERIFICATION_MODE, SSL_CERTIFICATE_AUTHORITIES, SSL_CERTIFICATE, SSL_KEY)
• Manager Watchdog : Surveille le démarrage de wazuh-db et rend ossec.conf persistant via symlink
• Sécurité OpenSearch : Les 8 fichiers dans indexer-security/ sont automatiquement copiés au premier démarrage et préservés lors des mises à jour

---

📊 Considérations de Production et Scaling

Limitations du Déploiement Single-Node

Ce déploiement est optimisé pour les environnements de petite à moyenne taille:

✅ Adapté pour:

• PME avec 10-50 agents
• Environnements de test/développement
• Labs de sécurité personnels
• Monitoring de petites infrastructures

⚠️ Non recommandé pour:

• Grandes entreprises (>100 agents)
• Environnements critiques nécessitant haute disponibilité
• Charges de travail très élevées (>10000 événements/seconde)

Haute Disponibilité (HA)

Pour des déploiements haute disponibilité, Wazuh recommande Kubernetes avec:

Configuration HA recommandée (basée sur wazuh-kubernetes):

• Indexer: 3 nœuds en cluster (quorum)
• Manager: 1 Master + 2+ Workers avec pod anti-affinity
• Dashboard: 2+ réplicas avec load balancing
• Network Policies: Segmentation réseau zero-trust
• Persistent Volumes: Stockage distribué (EBS, Ceph, etc.)

Référence: Le dossier data/ressources/wazuh-kubernetes-main/ contient les configurations officielles Kubernetes de Wazuh pour déploiements HA.

Recommandations de Scaling

Si vous atteignez les limites du déploiement single-node:

1. Migration vers Kubernetes

   • Utilisez les manifests dans wazuh-kubernetes-main/
   • Configurations pré-configurées pour AWS EKS, GKE, AKS
   • Support pour multi-nodes et auto-scaling

2. Optimisation du Déploiement Actuel

   • Augmentez les ressources CPU/RAM si nécessaire
   • Ajustez la période de rétention des logs
   • Configurez l'archivage des anciens événements
   • Optimisez les règles de détection (désactiver celles non utilisées)

3. Monitoring des Performances

   # Surveiller l'utilisation du CPU/RAM
   docker stats
   
   # Vérifier la santé du cluster OpenSearch
   curl -k -u admin:admin https://localhost:9200/_cluster/health?pretty
   
   # Analyser les logs du manager
   docker logs wazuh-runtipi-wazuh-manager-1
   

Sécurité en Production

✅ Checklist de sécurité:

• Changer TOUS les mots de passe par défaut
• Activer le pare-feu (exposer uniquement ports 5601, 1514, 1515)
• Configurer HTTPS avec certificats valides (non auto-signés)
• Limiter les accès SSH au serveur
• Activer les backups automatiques des volumes critiques
• Configurer la rotation des logs
• Activer l'authentification multi-facteurs si possible
• Surveiller les alertes de sécurité Wazuh pour le serveur lui-même

Backup recommandé:

# Script de backup des volumes critiques
BACKUP_DIR="/backup/wazuh-$(date +%Y%m%d)"
mkdir -p "$BACKUP_DIR"

# Indexer data
tar czf "$BACKUP_DIR/indexer-data.tar.gz" \
  /opt/runtipi/app-data/*/wazuh-runtipi/data/indexer-data

# Manager logs et queue
tar czf "$BACKUP_DIR/manager-data.tar.gz" \
  /opt/runtipi/app-data/*/wazuh-runtipi/data/manager-logs \
  /opt/runtipi/app-data/*/wazuh-runtipi/data/manager-queue

# Security configs
tar czf "$BACKUP_DIR/security-config.tar.gz" \
  /opt/runtipi/app-data/*/wazuh-runtipi/data/indexer-security \
  /opt/runtipi/app-data/*/wazuh-runtipi/data/config

---

🔧 Détails Techniques et Bonnes Pratiques

Configuration Filebeat SSL (Méthode Officielle)

Cette implémentation utilise la méthode officielle Wazuh pour configurer Filebeat avec SSL, documentée sur Docker Hub - Wazuh Manager.

Variables d'environnement utilisées:

FILEBEAT_SSL_VERIFICATION_MODE=full
SSL_CERTIFICATE_AUTHORITIES=/var/ossec/etc/certs/root-ca.pem
SSL_CERTIFICATE=/var/ossec/etc/certs/server.pem
SSL_KEY=/var/ossec/etc/certs/server-key.pem

Le script officiel cont-init.d/1-config-filebeat de l'image Wazuh détecte automatiquement ces variables et génère la configuration Filebeat correcte. Cette approche est préférable à la création manuelle de filebeat.yml car :

• ✅ Respecte le workflow d'initialisation Wazuh natif
• ✅ Évite les conflits avec les scripts internes
• ✅ Simplifie la maintenance (moins de code personnalisé)
• ✅ Garantit la compatibilité avec les futures versions

Initialisation et Boucles Logiques

Tous les scripts d'initialisation utilisent des boucles logiques basées sur des conditions réelles plutôt que des délais fixes, permettant une adaptation automatique à la vitesse de chaque machine :

init-indexer-init.sh :

# Attend la disponibilité réelle de l'API indexer
until curl -ks https://wazuh.indexer:9200; do
    sleep 5
done

init-manager.sh :

# Attend que le processus wazuh-db soit démarré
while [ $ELAPSED -lt $TIMEOUT ]; do
    if pgrep -x "wazuh-db" > /dev/null 2>&1; then
        # wazuh-db running, attendre 5s pour stabilité
        sleep 5
        break
    fi
    sleep 2
done

init-dashboard.sh :

# Pas de watchdog - exécute simplement l'entrypoint officiel
# La configuration est créée via symlink vers opensearch_dashboards.yml
exec /entrypoint.sh

Cette approche garantit :

• 🚀 Démarrage rapide sur machines performantes
• ⏱️ Patience suffisante sur machines plus lentes
• 📊 Logs précis avec temps réels écoulés

Gestion de la Persistance Manager

Le watchdog du manager (init-manager.sh) rend la configuration ossec.conf persistante :

1. Attente : Surveille le démarrage du processus wazuh-db (un des derniers services à démarrer)
2. Stabilité : Attend 5 secondes supplémentaires après détection du processus
3. Persistance : Copie ossec.conf vers /var/ossec/etc/custom/ si nécessaire
4. Symlink : Crée un lien symbolique pour garantir la persistance entre redémarrages

Cette logique garantit que les modifications de configuration survivent aux redémarrages de conteneurs.

---

📄 Licence et Crédits

Wazuh

• Licence: GPL v2
• Copyright: Wazuh, Inc.
• Site Web: https://wazuh.com/

Ce Projet

• Configuration Runtipi: synode-it
• Date: 2025-12-27
• Version: 4.14.1

Ce projet est une configuration Docker Compose de Wazuh optimisée pour Runtipi. Il utilise les images Docker officielles de Wazuh et suit leurs bonnes pratiques de déploiement.

---

🎉 Votre plateforme de sécurité Wazuh est maintenant prête à protéger votre infrastructure!

Pour toute question, consultez la documentation officielle Wazuh ou rejoignez la communauté.