docs: nettoyage complet et mise à jour de la documentation

- Suppression de 10 fichiers obsolètes (scripts, tests, docs temporaires)
- Suppression des dossiers vides (frontend/src, backend/src/middlewares)
- Réecriture complète de 7 fichiers de documentation
- README.md: vue d'ensemble avec toutes les fonctionnalités actuelles
- QUICKSTART.md: guide de démarrage rapide en 3 étapes
- CONFIGURATION.md: guide de configuration complète (Docker, RCON, sécurité)
- DEPLOYMENT.md: guide de déploiement production (HTTPS, reverse proxy, backups)
- MAINTENANCE.md: guide de maintenance avec dépannage exhaustif
- INDEX.md: index de navigation simplifié
- CHANGELOG.md: historique complet v1.0.0
- Optimisation docker-compose.yml (suppression version dépréciée)
- Vérification des dépendances (toutes utilisées)
- Création du rapport de nettoyage (.cleanup-report.md)
- Documentation cohérente avec le code actuel
- Projet 100% prêt pour la production
This commit is contained in:
y.campiontrebouta@innotexnas.ovh
2026-02-04 23:39:36 +01:00
parent 57994dce9c
commit 4c48ee5fe4
13 changed files with 2161 additions and 1350 deletions

View File

@@ -1,347 +1,469 @@
# 🔧 Maintenance et Administration
# Maintenance - NationsGlory Web Admin
## Commandes de Base
Guide de maintenance quotidienne et dépannage du panel d'administration.
## 🔄 Opérations Quotidiennes
### Démarrer le Panel
### Démarrer l'application
```bash
cd WebNationsGlory_ServeurBuild_Red
./start.sh
cd /home/innotex/Documents/Projet/Serveur\ NationsGlory/WebNationsGlory_ServeurBuild_Red
docker-compose up -d
```
### Arrêter l'application
### Arrêter le Panel
```bash
# Ctrl+C dans le terminal
docker-compose down
```
### Redémarrer l'application
### Redémarrer le Panel
```bash
# 1. Arrêtez avec Ctrl+C
# 2. Relancez avec ./start.sh
docker-compose restart app
```
## Dépannage
### Voir les Logs
### Vérifier l'état de RCON
```bash
# Test simple
echo "status" | timeout 2 bash -c 'exec 3<>/dev/tcp/localhost/25575; cat >&3; cat <&3' 2>/dev/null || echo "RCON non accessible"
# Logs en temps réel
docker-compose logs -f app
# Avec nc (netcat)
nc -w 2 localhost 25575 < /dev/null && echo "RCON OK" || echo "RCON KO"
# Dernières 100 lignes
docker-compose logs --tail=100 app
# Avec telnet
telnet localhost 25575
# Logs avec timestamp
docker-compose logs -t app
```
### Vérifier les logs du serveur MC
## 📊 Monitoring
### État des Services
```bash
# Dernières 50 lignes
tail -50 /path/to/mc-server/latest.log
# Vérifier que le conteneur tourne
docker-compose ps
# Rechercher les erreurs
grep ERROR /path/to/mc-server/latest.log
# Détails du conteneur
docker inspect webnationsglory_serveurbuild_red-app-1
# Suivre en temps réel
tail -f /path/to/mc-server/latest.log
# Utilisation des ressources
docker stats
```
### Vérifier si le port 3000 est utilisé
### Vérifier le Panel Web
```bash
# Linux/Mac
lsof -i :3000
# Test HTTP
curl -I http://localhost:4001
# Windows PowerShell
Get-Process -Id (Get-NetTCPConnection -LocalPort 3000).OwningProcess
# Tuer le processus (Linux/Mac)
kill -9 $(lsof -t -i :3000)
# Tester la page de login
curl http://localhost:4001 | grep -i "login"
```
### Réinitialiser Node.js
### Vérifier RCON
```bash
cd backend
# Avec rcon-cli (depuis le conteneur Minecraft)
docker exec -it mc-nationsglory rcon-cli --password VotreMotDePasse
# Supprimer node_modules
rm -rf node_modules
rm package-lock.json
# Commande test
docker exec -it mc-nationsglory rcon-cli --password VotreMotDePasse list
```
# Réinstaller
npm install
### Vérifier les Volumes
```bash
# Liste des volumes
docker volume ls | grep web
# Inspecter le volume web-admin
docker volume inspect webnationsglory_serveurbuild_red_web-admin
# Voir le contenu
docker run --rm -v webnationsglory_serveurbuild_red_web-admin:/data alpine ls -lah /data/.web-admin/
```
## 🔧 Maintenance Régulière
### Nettoyage Docker
```bash
# Supprimer les images inutilisées
docker image prune -a
# Supprimer les conteneurs arrêtés
docker container prune
# Supprimer les volumes orphelins
docker volume prune
# Tout nettoyer (attention!)
docker system prune -a --volumes
```
### Mise à Jour du Panel
```bash
cd /home/innotex/Documents/Projet/Serveur\ NationsGlory/WebNationsGlory_ServeurBuild_Red
# Pull des modifications (si git)
git pull origin main
# Rebuild de l'image
docker-compose build --no-cache
# Redémarrer
npm start
docker-compose down
docker-compose up -d
```
## Gestion des OPs
### Rotation des Logs RCON
### Ajouter un OP sur le serveur MC
```
/op NomdujoueurMC
```
L'historique RCON est limité automatiquement, mais vous pouvez le nettoyer manuellement :
### Vérifier les OPs
```bash
# Fichier ops.txt
cat /path/to/mc-server/ops.txt
# Supprimer l'historique via l'API
curl -X DELETE http://localhost:4001/api/rcon/history
# Ou ops.json (Minecraft 1.8+)
cat /path/to/mc-server/ops.json
# Ou directement dans le volume
docker run --rm -v webnationsglory_serveurbuild_red_web-admin:/data alpine rm /data/.web-admin/rcon-history.json
```
## Backups
## 💾 Backups
### Backup Manuel du Volume web-admin
### Créer un backup manuel
```bash
cd /path/to/mc-server
# Créer un dossier de backup
mkdir -p ~/backups/nationsglory
# Créer un tar.gz du serveur
tar -czf ../backup-$(date +%Y%m%d-%H%M%S).tar.gz .
# Backup du volume
docker run --rm \
-v webnationsglory_serveurbuild_red_web-admin:/data \
-v ~/backups/nationsglory:/backup \
alpine tar czf /backup/web-admin-$(date +%Y%m%d-%H%M%S).tar.gz -C /data .
# Avec exclusion de certains fichiers
tar -czf ../backup-$(date +%Y%m%d-%H%M%S).tar.gz \
--exclude='*.log' \
--exclude='cache' \
--exclude='.web-admin' \
.
echo "Backup créé dans ~/backups/nationsglory/"
```
### Restaurer un backup
### Restaurer un Backup
```bash
# Arrêter le serveur d'abord!
./stop.sh
# Arrêter le conteneur
docker-compose down
# Restaurer
cd /backup/location
tar -xzf backup-file.tar.gz -C /path/to/mc-server
docker run --rm \
-v webnationsglory_serveurbuild_red_web-admin:/data \
-v ~/backups/nationsglory:/backup \
alpine sh -c "cd /data && tar xzf /backup/web-admin-YYYYMMDD-HHMMSS.tar.gz"
# Redémarrer
cd /path/to/mc-server
./start.sh
docker-compose up -d
```
## Logs et Monitoring
### Backup Automatique (Cron)
### Voir les logs backend en temps réel
```bash
cd backend
npm start
```
Créez `/opt/backup-web-admin.sh` :
### Voir les logs RCON (historique des commandes)
```bash
cat /path/to/mc-server/.web-admin/rcon-history.json
```
### Nettoyer les vieux logs
```bash
# Supprimer les logs de plus de 30 jours
find /path/to/mc-server -name "*.log" -mtime +30 -delete
```
## Variables d'Environnement
### Changer le port
```env
# backend/.env
PORT=8080
```
### Changer le répertoire du serveur
```env
# backend/.env
SERVER_DIR=/path/to/other/mc-server
```
### Changer les identifiants RCON
```env
# backend/.env
RCON_HOST=192.168.1.100
RCON_PORT=25576
```
## Mise à Jour des Dépendances
### Vérifier les mises à jour disponibles
```bash
cd backend
npm outdated
```
### Mettre à jour les dépendances
```bash
cd backend
npm update
```
### Mettre à jour une dépendance spécifique
```bash
cd backend
npm install express@latest
```
## Sécurité
### Changer le SESSION_SECRET
```bash
# Générer une nouvelle clé
node -e "console.log(require('crypto').randomBytes(32).toString('hex'))"
# Mettre à jour dans backend/.env
SESSION_SECRET=<nouvelle-cle-generee>
# Redémarrer l'application
```
### Changer le mot de passe RCON
```bash
# Via l'interface web: Dashboard → Changer RCON
# Ou éditer manuellement server.properties:
rcon.password=NewPassword123
# Redémarrer le serveur MC
```
## Performance
### Vérifier l'utilisation mémoire Node.js
```bash
ps aux | grep node
# Linux avec plus de détails
ps -eo pid,vsz,rss,comm | grep node
```
### Nettoyer les fichiers temporaires
```bash
cd backend
rm -rf node_modules
npm install
```
## Troubleshooting
### L'application démarre mais l'interface ne charge pas
```bash
# Vérifier que le frontend est bien servi
curl http://localhost:3000/
# Doit retourner l'HTML
# Vérifier la console du navigateur (F12) pour les erreurs
```
### Les commandes RCON n'exécutent pas
```bash
# Vérifier que RCON est activé
grep "enable-rcon" /path/to/mc-server/server.properties
# Doit être: enable-rcon=true
# Vérifier le mot de passe RCON
grep "rcon.password" /path/to/mc-server/server.properties
# Tester RCON directement
echo "say Test" | nc localhost 25575
```
### Base de données de sessions corruptée
```bash
# Supprimer les sessions
rm -rf backend/sessions/*
# Redémarrer l'application
./start.sh
```
## Commandes Minecraft Utiles
### Via la console web
```
/list # Liste les joueurs
/say @a Message # Message à tous
/tp @p @s # Téléporter
/weather clear # Météo
/time set day # Heure
/gamerule <règle> # Game rules
/difficulty 3 # Difficulté
/seed # Seed du monde
/spawnpoint @p 0 100 0 # Spawnpoint
```
## Scripts Automatisés
### Script de backup automatique
```bash
#!/bin/bash
# save-mc-backup.sh
SERVER_DIR="/path/to/mc-server"
BACKUP_DIR="$SERVER_DIR/backups"
BACKUP_DIR="$HOME/backups/nationsglory"
DATE=$(date +%Y%m%d-%H%M%S)
mkdir -p "$BACKUP_DIR"
DATE=$(date +%Y%m%d_%H%M%S)
BACKUP_FILE="$BACKUP_DIR/backup_$DATE.tar.gz"
cd "$SERVER_DIR"
tar -czf "$BACKUP_FILE" \
--exclude='*.log' \
--exclude='cache' \
--exclude='.web-admin' \
.
docker run --rm \
-v webnationsglory_serveurbuild_red_web-admin:/data \
-v "$BACKUP_DIR":/backup \
alpine tar czf "/backup/web-admin-$DATE.tar.gz" -C /data .
echo "Backup créé: $BACKUP_FILE"
# Garder seulement les 7 derniers
ls -t "$BACKUP_DIR"/web-admin-*.tar.gz | tail -n +8 | xargs -r rm
# À ajouter à crontab:
# 0 2 * * * /path/to/save-mc-backup.sh
echo "✅ Backup créé: web-admin-$DATE.tar.gz"
```
### Script de redémarrage programmé
Puis :
```bash
chmod +x /opt/backup-web-admin.sh
# Ajouter au crontab (tous les jours à 2h)
crontab -e
# Ajouter: 0 2 * * * /opt/backup-web-admin.sh
```
## 🐛 Dépannage
### Le Panel ne Démarre Pas
**Symptômes** : `docker-compose up -d` échoue
```bash
# Voir les logs d'erreur
docker-compose logs app
# Vérifier les ports occupés
lsof -i :4001
# Reconstruire from scratch
docker-compose down
docker-compose build --no-cache
docker-compose up -d
```
### Erreur de Connexion RCON
**Symptômes** : "Failed to connect to RCON"
```bash
# 1. Vérifier que le serveur MC est démarré
docker ps | grep mc-nationsglory
# 2. Vérifier que RCON est actif
docker logs mc-nationsglory | grep RCON
# 3. Tester RCON manuellement
docker exec -it mc-nationsglory rcon-cli --password VotreMotDePasse
# 4. Vérifier le mot de passe dans docker-compose.yml
cat docker-compose.yml | grep -A 5 environment
# 5. Vérifier server.properties
docker exec mc-nationsglory cat /mc-server/server.properties | grep rcon
```
### Les Joueurs ne s'Affichent Pas
**Symptômes** : Liste vide dans la section Players
```bash
# 1. Vérifier le dossier players
docker exec mc-nationsglory ls -la /mc-server/world/players/
# 2. Vérifier usercache.json
docker exec mc-nationsglory cat /mc-server/usercache.json
# 3. Vérifier les permissions
docker exec mc-nationsglory ls -la /mc-server/world/
# 4. Voir les logs du panel
docker-compose logs app | grep -i player
```
### Impossible de se Connecter au Panel
**Symptômes** : "Invalid credentials" ou "Not an OP"
```bash
# 1. Vérifier ops.txt
docker exec mc-nationsglory cat /mc-server/ops.txt
# 2. Ajouter un OP si nécessaire
docker exec -it mc-nationsglory rcon-cli --password VotreMotDePasse
> op VotreNom
# 3. Vérifier le fichier users.json
cat backend/data/users.json
# 4. Vider le cache navigateur et réessayer
```
### L'Historique RCON ne se Sauvegarde Pas
**Symptômes** : Historique vide après redémarrage
```bash
# 1. Vérifier que le volume existe
docker volume ls | grep web
# 2. Vérifier les permissions
docker run --rm -v webnationsglory_serveurbuild_red_web-admin:/data alpine ls -la /data/.web-admin/
# 3. Vérifier que le dossier est créé
docker exec webnationsglory_serveurbuild_red-app-1 ls -la /mc-server/.web-admin/
# 4. Voir les logs pour erreurs d'écriture
docker-compose logs app | grep -i "history\|error"
```
### Les Paramètres ne se Sauvegardent Pas
**Symptômes** : Modifications dans Settings non persistées
```bash
# 1. Vérifier que le volume n'est pas en lecture seule
docker inspect webnationsglory_serveurbuild_red-app-1 | grep -A 10 Mounts
# 2. Vérifier les permissions de server.properties
docker exec mc-nationsglory ls -la /mc-server/server.properties
# 3. Tester l'écriture
docker exec webnationsglory_serveurbuild_red-app-1 touch /mc-server/test.txt
# 4. Voir les logs
docker-compose logs app | grep -i "settings\|server.properties"
```
### Le Serveur ne Redémarre/s'Arrête Pas
**Symptômes** : Boutons Shutdown/Restart ne fonctionnent pas
```bash
# 1. Vérifier la connexion RCON
docker exec -it mc-nationsglory rcon-cli --password VotreMotDePasse
# 2. Tester la commande stop manuellement
docker exec -it mc-nationsglory rcon-cli --password VotreMotDePasse
> stop
# 3. Voir les logs du panel
docker-compose logs -f app
# Puis cliquer sur le bouton
# 4. Vérifier la console JavaScript (F12 dans le navigateur)
```
### Performance Lente
**Symptômes** : Le panel répond lentement
```bash
# 1. Vérifier l'utilisation CPU/RAM
docker stats webnationsglory_serveurbuild_red-app-1
# 2. Vérifier les logs pour erreurs
docker-compose logs app | grep -i error
# 3. Nettoyer l'historique RCON si trop volumineux
curl -X DELETE http://localhost:4001/api/rcon/history
# 4. Redémarrer le conteneur
docker-compose restart app
```
## 🔍 Vérifications de Santé
### Checklist Quotidienne
```bash
# Script de vérification
#!/bin/bash
echo "=== Vérification Panel NationsGlory ==="
# 1. Conteneur actif
docker-compose ps | grep -q "Up" && echo "✅ Conteneur actif" || echo "❌ Conteneur arrêté"
# 2. Panel accessible
curl -s http://localhost:4001 > /dev/null && echo "✅ Panel accessible" || echo "❌ Panel inaccessible"
# 3. RCON fonctionnel
docker exec mc-nationsglory rcon-cli --password VotreMotDePasse list > /dev/null 2>&1 && echo "✅ RCON OK" || echo "❌ RCON KO"
# 4. Volume web-admin existe
docker volume ls | grep -q web-admin && echo "✅ Volume web-admin OK" || echo "❌ Volume manquant"
# 5. Espace disque
df -h / | tail -1 | awk '{print "💾 Espace disque: " $5 " utilisé"}'
echo "=== Fin de la vérification ==="
```
### Checklist Hebdomadaire
- [ ] Vérifier les logs pour erreurs : `docker-compose logs app | grep -i error`
- [ ] Nettoyer les images Docker inutilisées : `docker image prune`
- [ ] Vérifier l'espace disque : `df -h`
- [ ] Tester la connexion au panel
- [ ] Tester l'envoi de commandes RCON
- [ ] Vérifier que les backups fonctionnent
### Checklist Mensuelle
- [ ] Backup complet du volume web-admin
- [ ] Mise à jour du panel (si disponible)
- [ ] Vérifier les certificats SSL (si HTTPS)
- [ ] Nettoyer les logs anciens
- [ ] Réviser les accès OP
- [ ] Tester la restauration d'un backup
## 📝 Logs Utiles
### Emplacement des Logs
```bash
# Logs Docker du panel
docker-compose logs app
# Logs Nginx (si reverse proxy)
/var/log/nginx/nationsglory-admin-access.log
/var/log/nginx/nationsglory-admin-error.log
# Logs du serveur Minecraft
docker exec mc-nationsglory cat /mc-server/logs/latest.log
```
### Recherche dans les Logs
```bash
# Erreurs uniquement
docker-compose logs app | grep -i error
# Connexions
docker-compose logs app | grep -i "login\|auth"
# Commandes RCON
docker-compose logs app | grep -i rcon
# Dernières 24h
docker-compose logs --since 24h app
```
## 🚨 Alertes et Notifications
### Script de Monitoring
Créez `/opt/monitor-nationsglory.sh` :
```bash
#!/bin/bash
# restart-mc-server.sh
WEBHOOK="https://discord.com/api/webhooks/..." # Discord webhook (optionnel)
echo "Redémarrage du serveur MC dans 1 minute..."
# Vérifier que le panel tourne
if ! curl -s http://localhost:4001 > /dev/null; then
echo "❌ ALERTE: Panel NationsGlory inaccessible!"
# curl -X POST -H 'Content-Type: application/json' \
# -d '{"content":"🚨 Panel NationsGlory DOWN!"}' \
# "$WEBHOOK"
exit 1
fi
# Via RCON
echo "say Redémarrage dans 1 minute!" | nc localhost 25575
sleep 30
echo "say 30 secondes!" | nc localhost 25575
sleep 20
echo "say 10 secondes!" | nc localhost 25575
sleep 10
echo "stop" | nc localhost 25575
# Vérifier RCON
if ! docker exec mc-nationsglory rcon-cli --password VotreMotDePasse list > /dev/null 2>&1; then
echo "❌ ALERTE: RCON ne répond pas!"
exit 1
fi
sleep 5
# Redémarrer
cd /path/to/mc-server
./start.sh
echo "✅ Tout fonctionne normalement"
```
## Monitoring
Cron toutes les 5 minutes :
### Vérifier l'espace disque
```bash
# Espace utilisé par le serveur
du -sh /path/to/mc-server
# Espace libre
df -h /path/to/mc-server
crontab -e
# Ajouter: */5 * * * * /opt/monitor-nationsglory.sh
```
### Vérifier les processus Node.js
```bash
ps aux | grep node
# Ou
ps aux | grep npm
```
## 📚 Ressources
### Vérifier les ports en écoute
```bash
netstat -tlnp | grep 3000 # Node.js
netstat -tlnp | grep 25575 # RCON
netstat -tlnp | grep 25565 # Serveur MC
```
- [README.md](README.md) - Vue d'ensemble
- [CONFIGURATION.md](CONFIGURATION.md) - Configuration détaillée
- [DEPLOYMENT.md](DEPLOYMENT.md) - Guide de déploiement
- [CHANGELOG.md](CHANGELOG.md) - Historique des versions
---
**💡 Astuce**: Sauvegardez ces commandes pour un accès rapide!
**Support** : Pour tout problème non résolu, vérifier les logs avec `docker-compose logs -f app` et consulter la section Dépannage.