Monitoring serveur avec l'IA : alertes intelligentes

SI cpu > 90% ALORS alerte
SI ram > 85% ALORS alerte
SI disque > 80% ALORS alerte

# Utilisation CPU instantanée
top -bn1 | grep "Cpu(s)" | awk '{print $2}'

# Load average (1, 5, 15 minutes)
cat /proc/loadavg

# Nombre de cœurs (pour interpréter le load)
nproc

# Mémoire utilisée/disponible
free -h

# Détail avec buffers/cache
free -m | awk 'NR==2{printf "Used: %sMB / %sMB (%.1f%%)\n", $3, $2, $3*100/$2}'

# Espace disque
df -h /

# Inodes (souvent oublié, peut bloquer même avec de l'espace libre)
df -i /

# I/O en cours
iostat -x 1 3 2>/dev/null || echo "iostat non disponible"

# Services critiques
systemctl is-active nginx postgresql docker openclaw

# Uptime serveur
uptime -p

# Ports en écoute
ss -tlnp | grep -E ':(80|443|5432|8080|3000)'

# Erreurs système récentes
journalctl -p err -n 20 --no-pager

# Tentatives SSH échouées
journalctl -u sshd -n 50 --no-pager | grep -i "failed\|invalid"

# OOM killer (processus tués par manque de RAM)
dmesg | grep -i "oom\|killed process" | tail -5

#!/bin/bash
# /root/scripts/server-health.sh
# Collecte les métriques serveur pour analyse IA

echo "=== SERVER HEALTH REPORT ==="
echo "Date: $(date -u +'%Y-%m-%d %H:%M UTC')"
echo "Hostname: $(hostname)"
echo "Uptime: $(uptime -p)"
echo ""

# CPU
echo "--- CPU ---"
echo "Load average: $(cat /proc/loadavg | awk '{print $1, $2, $3}')"
echo "Cores: $(nproc)"
CPU_USAGE=$(top -bn1 | grep "Cpu(s)" | awk '{print $2}')
echo "CPU usage: ${CPU_USAGE}%"
echo ""

# RAM
echo "--- MEMORY ---"
free -m | awk 'NR==2{printf "Total: %sMB\nUsed: %sMB\nFree: %sMB\nBuffers/Cache: %sMB\nAvailable: %sMB\nUsage: %.1f%%\n", $2, $3, $4, $6, $7, $3*100/$2}'
echo ""

# Disque
echo "--- DISK ---"
df -h / | tail -1 | awk '{printf "Total: %s\nUsed: %s\nAvailable: %s\nUsage: %s\n", $2, $3, $4, $5}'
echo "Inodes: $(df -i / | tail -1 | awk '{print $5}') used"
echo ""

# Services
echo "--- SERVICES ---"
for svc in nginx postgresql docker; do
    STATUS=$(systemctl is-active $svc 2>/dev/null || echo "not-found")
    echo "$svc: $STATUS"
done
echo ""

# Ports
echo "--- LISTENING PORTS ---"
ss -tlnp 2>/dev/null | grep -E 'LISTEN' | awk '{print $4}' | sort -u
echo ""

# Erreurs récentes
echo "--- RECENT ERRORS (last 30 min) ---"
journalctl -p err --since "30 min ago" --no-pager -q 2>/dev/null | tail -10
echo ""

# Sécurité
echo "--- SECURITY ---"
FAILED_SSH=$(journalctl -u sshd --since "1 hour ago" --no-pager 2>/dev/null | grep -c "Failed\|Invalid" || echo "0")
echo "Failed SSH attempts (1h): $FAILED_SSH"

# Docker (si disponible)
if command -v docker &>/dev/null; then
    echo ""
    echo "--- DOCKER ---"
    docker ps --format "{{.Names}}: {{.Status}}" 2>/dev/null
    STOPPED=$(docker ps -a --filter "status=exited" --format "{{.Names}}" 2>/dev/null | wc -l)
    echo "Stopped containers: $STOPPED"
fi

chmod +x /root/scripts/server-health.sh

/root/scripts/server-health.sh

# Dans votre HEARTBEAT.md ou configuration heartbeat
## 📊 Monitoring serveur
- Vérifier la santé du serveur via /root/scripts/server-health.sh
- Si anomalie détectée, alerter via Telegram
- Ne PAS alerter pour : pics CPU courts (<5min), usage RAM <85%, cron jobs connus

# Rapport de santé toutes les 6 heures
0 */6 * * * Exécute /root/scripts/server-health.sh, analyse les résultats, compare avec les rapports précédents. Si anomalie, envoie un résumé Telegram. Sinon, log silencieusement.

# Créer le dossier d'historique
mkdir -p /root/monitoring/history

# Script wrapper qui stocke + analyse
#!/bin/bash
# /root/scripts/monitor-and-store.sh

REPORT_DIR="/root/monitoring/history"
TIMESTAMP=$(date +%Y%m%d_%H%M)
REPORT_FILE="$REPORT_DIR/health_${TIMESTAMP}.txt"

# Collecter
/root/scripts/server-health.sh > "$REPORT_FILE"

# Garder seulement les 7 derniers jours
find "$REPORT_DIR" -name "health_*.txt" -mtime +7 -delete

# Afficher pour l'agent
cat "$REPORT_FILE"

# Comparer l'usage disque avec hier
grep "Usage:" /root/monitoring/history/health_$(date -d yesterday +%Y%m%d)*.txt

## 📋 Tâche : Monitoring serveur intelligent

Exécute `/root/scripts/server-health.sh` et analyse les résultats.

### Règles d'alerte

**NE PAS alerter si :**
- CPU < 85% (usage normal)
- RAM < 80% (en comptant les buffers/cache)
- Disque < 75%
- Load average < nombre_de_coeurs × 0.8
- Les processus gourmands sont des tâches connues (apt, backup, cron)

**ALERTER si :**
- Un service critique est down (nginx, postgresql, docker)
- CPU > 90% pendant plus de 5 minutes sans raison identifiable
- RAM disponible < 500MB
- Disque > 85% ou inodes > 80%
- Plus de 50 tentatives SSH échouées en 1h
- Un conteneur Docker est stopped alors qu'il devrait tourner
- Des erreurs OOM dans les logs

### Format d'alerte Telegram

Si alerte nécessaire, envoie UN SEUL message structuré :

🚨 **Alerte serveur [hostname]**
**Problème :** [description courte]
**Détail :** [explication contextuelle]
**Impact :** [ce que ça affecte]
**Action suggérée :** [quoi faire]

### Si tout va bien
Ne rien envoyer. Log silencieusement.

--- CPU ---
Load average: 3.8 2.1 1.5
Cores: 4
CPU usage: 92%

--- MEMORY ---
Usage: 78.5%

--- SERVICES ---
nginx: active
postgresql: active
docker: active

# /root/scripts/alert-cooldown.sh
# Vérifie si une alerte a déjà été envoyée récemment

ALERT_TYPE="$1"  # ex: "cpu_high", "disk_full"
COOLDOWN_DIR="/root/monitoring/cooldowns"
COOLDOWN_SECONDS=3600  # 1 heure

mkdir -p "$COOLDOWN_DIR"

LAST_ALERT_FILE="$COOLDOWN_DIR/$ALERT_TYPE"

if [ -f "$LAST_ALERT_FILE" ]; then
    LAST_TIME=$(cat "$LAST_ALERT_FILE")
    NOW=$(date +%s)
    DIFF=$((NOW - LAST_TIME))

    if [ "$DIFF" -lt "$COOLDOWN_SECONDS" ]; then
        echo "COOLDOWN_ACTIVE"
        exit 1
    fi
fi

# Enregistrer cette alerte
date +%s > "$LAST_ALERT_FILE"
echo "ALERT_OK"
exit 0

📊 **Rapport serveur quotidien**
📅 2025-01-15

✅ Tous les services opérationnels
💻 CPU moyen : 23% | Max : 67%
🧠 RAM : 4.2GB / 8GB (52%)
💾 Disque : 34GB / 80GB (42%)
🔒 12 tentatives SSH bloquées
🐳 5 conteneurs Docker actifs

Prochaine vérification dans 24h.

# Ajouter au script server-health.sh

# Vérifier qu'un site répond
echo "--- WEB CHECK ---"
HTTP_CODE=$(curl -s -o /dev/null -w "%{http_code}" http://localhost:80 2>/dev/null)
echo "Nginx HTTP: $HTTP_CODE"

# Vérifier la taille de la base de données
echo "--- DATABASE ---"
if command -v psql &>/dev/null; then
    DB_SIZE=$(psql -U postgres -t -c "SELECT pg_size_pretty(pg_database_size('main'));" 2>/dev/null)
    echo "DB size: $DB_SIZE"
fi

# Vérifier les certificats SSL
echo "--- SSL ---"
DOMAIN="votre-domaine.com"
EXPIRY=$(echo | openssl s_client -servername $DOMAIN -connect $DOMAIN:443 2>/dev/null | openssl x509 -noout -enddate 2>/dev/null | cut -d= -f2)
echo "SSL expiry: $EXPIRY"

# Erreurs dans les logs de votre app
echo "--- APP LOGS ---"
if [ -f /var/log/myapp/error.log ]; then
    ERRORS_1H=$(find /var/log/myapp/error.log -newer <(date -d "1 hour ago" +%Y%m%d%H%M) 2>/dev/null | wc -l)
    echo "App errors (1h): $ERRORS_1H"
    # Dernières erreurs
    tail -5 /var/log/myapp/error.log
fi

# Conteneurs qui consomment trop
docker stats --no-stream --format \
  "{{.Name}}: CPU={{.CPUPerc}} MEM={{.MemUsage}}" 2>/dev/null

# Conteneurs qui ont redémarré récemment
docker ps --format "{{.Names}} {{.Status}}" | grep -i "restarting"

# Logs d'erreur des conteneurs
for container in $(docker ps -q); do
    NAME=$(docker inspect --format '{{.Name}}' $container | tr -d '/')
    ERRORS=$(docker logs --since 1h $container 2>&1 | grep -ci "error\|fatal\|panic")
    if [ "$ERRORS" -gt 0 ]; then
        echo "⚠️ $NAME: $ERRORS errors in last hour"
    fi
done

# Extraire l'usage disque des 7 derniers jours
for f in /root/monitoring/history/health_*.txt; do
    DATE=$(echo $f | grep -oP '\d{8}')
    USAGE=$(grep "Usage:" $f | head -1 | grep -oP '\d+' | head -1)
    echo "$DATE $USAGE"
done

## 📈 Analyse de tendance

Compare les 5 derniers rapports dans /root/monitoring/history/
Cherche :
- Métriques qui augmentent régulièrement (fuite mémoire, disque qui se remplit)
- Corrélations (CPU + RAM qui montent ensemble)
- Patterns temporels (problèmes toujours à la même heure)

# 1. Créer les dossiers
mkdir -p /root/scripts /root/monitoring/{history,cooldowns}

# 2. Créer le script de collecte
# (copier server-health.sh ci-dessus)
nano /root/scripts/server-health.sh
chmod +x /root/scripts/server-health.sh

# 3. Créer le wrapper
# (copier monitor-and-store.sh ci-dessus)
nano /root/scripts/monitor-and-store.sh
chmod +x /root/scripts/monitor-and-store.sh

# 4. Tester
/root/scripts/server-health.sh

# 5. Configurer le cron système (backup)
crontab -e
# Ajouter : */30 * * * * /root/scripts/monitor-and-store.sh > /dev/null 2>&1

# 6. Configurer OpenClaw heartbeat
# (ajouter les instructions monitoring au heartbeat)