Configuration de déploiement unifié NationsGlory

- Scripts de déploiement (deploy.sh, stop.sh, check-config.sh)
- Documentation complète (README, QUICKSTART, etc.)
- Configuration portable avec chemins relatifs
This commit is contained in:
innotex
2026-02-05 18:29:25 +01:00
commit c58d85d751
9 changed files with 1393 additions and 0 deletions

13
.gitignore vendored Normal file
View File

@@ -0,0 +1,13 @@
# Ignorer les sous-repositories (ils ont leurs propres repos)
NationsGlory_ServeurBuild_Red/
WebNationsGlory_ServeurBuild_Red/
# Fichiers de configuration sensibles
.env
# Logs
*.log
# OS
.DS_Store
Thumbs.db

59
CHEATSHEET.txt Normal file
View File

@@ -0,0 +1,59 @@
╔════════════════════════════════════════════════════════════════╗
║ AIDE-MÉMOIRE NATIONSGLORY ║
╚════════════════════════════════════════════════════════════════╝
🚀 COMMANDES PRINCIPALES
═══════════════════════════════════════════════════════════════
./check-config.sh Vérifier la configuration
./deploy.sh Démarrer tous les services
./stop.sh Arrêter tous les services
📖 ACCÈS AUX SERVICES
═══════════════════════════════════════════════════════════════
Minecraft votre-ip:25565
Web Admin http://votre-ip:4001
🔍 LOGS ET DEBUG
═══════════════════════════════════════════════════════════════
# Logs serveur Minecraft
cd NationsGlory_ServeurBuild_Red
docker compose logs -f
# Logs application web
cd WebNationsGlory_ServeurBuild_Red
docker compose logs -f
# Status des conteneurs
docker ps
⚙️ CONFIGURATION
═══════════════════════════════════════════════════════════════
Serveur MC NationsGlory_ServeurBuild_Red/.env
App Web WebNationsGlory_ServeurBuild_Red/.env
⚠️ IMPORTANT: RCON_PASSWORD doit être identique dans les 2 !
🔐 SÉCURITÉ
═══════════════════════════════════════════════════════════════
# Ouvrir les ports (pare-feu)
sudo ufw allow 25565/tcp # Minecraft
sudo ufw allow 25575/tcp # RCON
sudo ufw allow 4001/tcp # Web Admin
# Générer un nouveau SESSION_SECRET
openssl rand -base64 32
📚 DOCUMENTATION
═══════════════════════════════════════════════════════════════
README.md Guide complet
QUICKSTART.md Guide rapide (5 min)
MODIFICATIONS.md Détails techniques
SETUP_COMPLETE.md Guide de configuration
═══════════════════════════════════════════════════════════════

306
MODIFICATIONS.md Normal file
View File

@@ -0,0 +1,306 @@
# 📝 Résumé des Modifications - Configuration Portable
Ce document résume les modifications apportées pour rendre le déploiement portable et simplifié.
## 🎯 Objectifs Atteints
**Chemins relatifs** : Plus de chemins absolus du type `/home/innotex/...`
**Variables d'environnement** : Configuration centralisée via fichiers `.env`
**Détection automatique de l'hôte** : L'API fonctionne avec localhost, IP ou domaine
**Déploiement unifié** : Un seul script pour tout démarrer
**Portabilité totale** : Fonctionne sur n'importe quelle machine Linux
## 📁 Fichiers Créés
### Dossier racine (`Serveur NationsGlory/`)
- **`deploy.sh`** : Script principal de déploiement (démarre MC + Web)
- **`stop.sh`** : Script d'arrêt de tous les services
- **`check-config.sh`** : Script de vérification de configuration
- **`README.md`** : Documentation principale du projet
- **`QUICKSTART.md`** : Guide de démarrage rapide
### Application Web (`WebNationsGlory_ServeurBuild_Red/`)
- **`.env.example`** : Template de configuration avec toutes les variables
- **`nginx.conf.example`** : Configuration nginx pour production avec SSL
## 🔧 Fichiers Modifiés
### Application Web
#### `docker-compose.yml`
**Avant** :
```yaml
environment:
SERVER_DIR: /home/innotex/NationsGloryRED/NationsGlory_ServeurBuild_Red
volumes:
- /home/innotex/NationsGloryRED/NationsGlory_ServeurBuild_Red:/mc-server
```
**Après** :
```yaml
env_file:
- .env
environment:
SERVER_DIR: /mc-server
RCON_HOST: ${RCON_HOST:-localhost}
# ... autres variables
volumes:
- ${MC_SERVER_PATH:-../NationsGlory_ServeurBuild_Red}:/mc-server:ro
network_mode: host # Pour accès depuis l'extérieur
```
#### `backend/src/server.js`
**Modification** : CORS dynamique pour supporter toutes les origines
```javascript
// Avant
app.use(cors({ origin: true, credentials: true }));
// Après
app.use(cors({
origin: (origin, callback) => {
const allowedOrigin = process.env.CORS_ORIGIN || true;
callback(null, allowedOrigin);
},
credentials: true
}));
```
#### `frontend/public/js/app.js`
**Avant** :
```javascript
const API_URL = window.location.hostname === 'localhost' || window.location.hostname === '127.0.0.1'
? 'http://localhost:4001/api'
: `http://${window.location.hostname}:4001/api`;
```
**Après** :
```javascript
const API_URL = (() => {
const protocol = window.location.protocol; // http: ou https:
const hostname = window.location.hostname; // IP ou domaine
const port = '4001';
if (window.location.port === port) {
return `${protocol}//${hostname}:${port}/api`;
}
return `${protocol}//${hostname}:${port}/api`;
})();
```
**Supporte automatiquement** : `http:` et `https:`, localhost, IP, domaine
### Serveur Minecraft
#### `docker-compose.yml`
Ajout du support des variables d'environnement :
```yaml
env_file:
- .env
environment:
SERVER_PORT: ${SERVER_PORT:-25565}
RCON_PORT: ${RCON_PORT:-25575}
RCON_PASSWORD: ${RCON_PASSWORD:-minecraft}
# ... etc
```
#### `.env.example`
Complété avec toutes les variables nécessaires
## 🔐 Configuration Requise
### Fichier `.env` du serveur Minecraft
```bash
cp NationsGlory_ServeurBuild_Red/.env.example NationsGlory_ServeurBuild_Red/.env
nano NationsGlory_ServeurBuild_Red/.env
```
**Paramètres importants** :
- `RCON_PASSWORD` : Changez pour la production
### Fichier `.env` de l'application web
```bash
cp WebNationsGlory_ServeurBuild_Red/.env.example WebNationsGlory_ServeurBuild_Red/.env
nano WebNationsGlory_ServeurBuild_Red/.env
```
**Paramètres critiques** :
- `SESSION_SECRET` : Générez avec `openssl rand -base64 32`
- `RCON_PASSWORD` : **Doit être identique** au serveur MC
- `MC_SERVER_PATH` : Chemin relatif vers le serveur (défaut: `../NationsGlory_ServeurBuild_Red`)
## 🚀 Utilisation
### 1. Vérification de la configuration
```bash
./check-config.sh
```
### 2. Déploiement
```bash
./deploy.sh
```
### 3. Accès
- **Serveur Minecraft** : `votre-ip:25565`
- **Interface Web** : `http://votre-ip:4001`
### 4. Arrêt
```bash
./stop.sh
```
## 🌐 Accès à Distance
L'application web fonctionne maintenant nativement avec :
-`http://localhost:4001` (local)
-`http://192.168.1.X:4001` (réseau local)
-`http://votre-ip-publique:4001` (internet)
-`http://votre-domaine.com:4001` (domaine)
-`https://votre-domaine.com` (avec nginx reverse proxy)
**Aucune configuration supplémentaire nécessaire** dans le code.
## 📦 Portabilité
### Déployer sur une nouvelle machine
1. **Copier le dossier** `Serveur NationsGlory` complet
2. **Créer les fichiers `.env`** :
```bash
cd WebNationsGlory_ServeurBuild_Red
cp .env.example .env
nano .env # Configurer SESSION_SECRET et RCON_PASSWORD
cd ../NationsGlory_ServeurBuild_Red
cp .env.example .env
nano .env # Configurer RCON_PASSWORD (même valeur)
```
3. **Déployer** :
```bash
cd ..
./deploy.sh
```
**C'est tout !** 🎉
### Pas de dépendances aux chemins
- ❌ Plus de `/home/innotex/...`
- ❌ Plus de configuration IP hardcodée
- ✅ Tout est relatif au dossier parent
- ✅ Détection automatique de l'environnement
## 🔒 Sécurité
### Checklist de production
- [ ] Changez `SESSION_SECRET` dans `.env` de l'app web
- [ ] Changez `RCON_PASSWORD` dans les deux `.env`
- [ ] Ouvrez les ports firewall (25565, 25575, 4001)
- [ ] Configurez nginx avec SSL (optionnel mais recommandé)
- [ ] Restreignez l'accès admin (firewall, VPN)
- [ ] Configurez les sauvegardes automatiques
### Exemple de génération de secrets
```bash
# SESSION_SECRET
openssl rand -base64 32
# RCON_PASSWORD (alphanumérique)
openssl rand -base64 16 | tr -dc 'a-zA-Z0-9'
```
## 📊 Architecture
```
Serveur NationsGlory/
├── deploy.sh # Démarrage unifié
├── stop.sh # Arrêt unifié
├── check-config.sh # Vérification
├── NationsGlory_ServeurBuild_Red/
│ ├── .env # Config du serveur MC
│ ├── docker-compose.yml # Orchestration Docker
│ └── mcpc.jar # Serveur Minecraft
└── WebNationsGlory_ServeurBuild_Red/
├── .env # Config de l'app web
├── docker-compose.yml # Orchestration Docker
├── backend/ # API Node.js
└── frontend/ # Interface web
Communication:
- App Web → Serveur MC (RCON sur localhost:25575)
- Client Web → App Web (HTTP sur port 4001)
- Client MC → Serveur MC (TCP sur port 25565)
```
## 🎓 Points Techniques
### 1. Montage relatif du serveur MC
Le docker-compose de l'app web monte le serveur avec un chemin relatif :
```yaml
volumes:
- ${MC_SERVER_PATH:-../NationsGlory_ServeurBuild_Red}:/mc-server:ro
```
Le `:ro` (read-only) assure que l'app web ne modifie pas les fichiers du serveur.
### 2. Network mode host
```yaml
network_mode: host
```
Permet à l'application d'être accessible depuis l'extérieur sans NAT Docker.
Nécessaire pour que l'API fonctionne avec n'importe quelle IP/domaine.
### 3. Détection automatique du protocole
Le frontend détecte automatiquement `http:` ou `https:` depuis `window.location.protocol`,
permettant le support SSL transparent via nginx.
### 4. Variables d'environnement avec valeurs par défaut
```yaml
RCON_PORT: ${RCON_PORT:-25575}
```
Si `RCON_PORT` n'est pas défini dans `.env`, utilise `25575`.
## 🐛 Dépannage
### Le script deploy.sh échoue
```bash
./check-config.sh # Vérifier la configuration
```
### L'app web ne se connecte pas au serveur MC
1. Vérifiez que `RCON_PASSWORD` est identique
2. Vérifiez que le serveur MC a démarré complètement
3. Testez RCON : `docker exec -it mc-nationsglory rcon-cli`
### L'API ne répond pas depuis l'extérieur
1. Vérifiez le pare-feu : `sudo ufw status`
2. Ouvrez le port : `sudo ufw allow 4001/tcp`
3. Testez : `curl http://votre-ip:4001/api/health`
## 📚 Références
- [Docker Compose Documentation](https://docs.docker.com/compose/)
- [Express.js CORS](https://expressjs.com/en/resources/middleware/cors.html)
- [Nginx Reverse Proxy](https://docs.nginx.com/nginx/admin-guide/web-server/reverse-proxy/)
---
**Date de modification** : Février 2026
**Version** : 2.0 - Configuration portable

88
QUICKSTART.md Normal file
View File

@@ -0,0 +1,88 @@
# 🚀 Guide de Démarrage Rapide - NationsGlory
## Installation en 5 minutes
### 1⃣ Configuration du serveur Minecraft
```bash
cd NationsGlory_ServeurBuild_Red
cp .env.example .env
nano .env # Modifiez RCON_PASSWORD
```
### 2⃣ Configuration de l'application web
```bash
cd ../WebNationsGlory_ServeurBuild_Red
cp .env.example .env
nano .env
```
**Modifiez au minimum :**
- `SESSION_SECRET` : Générez avec `openssl rand -base64 32`
- `RCON_PASSWORD` : **Même valeur** que dans le serveur MC
### 3⃣ Déploiement
```bash
cd ..
./deploy.sh
```
### 4⃣ Accès
**Serveur Minecraft :**
- Adresse : `votre-ip:25565`
**Interface Web :**
- URL : `http://votre-ip:4001`
- Créez votre compte admin au premier accès
## ⚡ Commandes Rapides
```bash
# Démarrer
./deploy.sh
# Arrêter
./stop.sh
# Logs du serveur MC
cd NationsGlory_ServeurBuild_Red && docker-compose logs -f
# Logs de l'application web
cd WebNationsGlory_ServeurBuild_Red && docker-compose logs -f
```
## 🔧 Configuration Minimale Requise
- **Docker** : version 20.10+
- **Docker Compose** : version 2.0+
- **RAM** : 4 GB minimum (2 GB pour Minecraft + 1 GB pour l'app web)
- **Ports** : 25565, 25575, 4001
## ✅ Vérification
1. Testez l'API web : `curl http://localhost:4001/api/health`
2. Connectez-vous au serveur Minecraft avec un client 1.6.4
3. Accédez à l'interface web et créez un compte admin
## 🐛 Problèmes Courants
**Le serveur ne démarre pas**
```bash
cd NationsGlory_ServeurBuild_Red
docker-compose logs
```
**L'application web ne se connecte pas au serveur**
- Vérifiez que `RCON_PASSWORD` est identique dans les deux `.env`
- Attendez que le serveur MC soit complètement démarré (30-60 secondes)
**Erreur de connexion API depuis l'extérieur**
- Ouvrez le port 4001 dans votre pare-feu
- Vérifiez que Docker utilise `network_mode: host`
## 📖 Documentation Complète
Consultez [README.md](README.md) pour plus de détails.

276
README.md Normal file
View File

@@ -0,0 +1,276 @@
# 🎮 NationsGlory - Déploiement Unifié
Ce dossier contient le serveur Minecraft NationsGlory modé et son interface web d'administration.
## 📁 Structure
```
Serveur NationsGlory/
├── NationsGlory_ServeurBuild_Red/ # Serveur Minecraft 1.6.4
├── WebNationsGlory_ServeurBuild_Red/ # Application web admin
├── deploy.sh # Script de déploiement
└── stop.sh # Script d'arrêt
```
## 🚀 Déploiement Rapide
### Prérequis
- Docker et Docker Compose installés
- Ports disponibles: 25565 (Minecraft), 25575 (RCON), 4001 (Web Admin)
### Installation en 3 étapes
#### 1. Configuration initiale
```bash
cd WebNationsGlory_ServeurBuild_Red
cp .env.example .env
nano .env
```
Modifiez au minimum :
- `SESSION_SECRET` : Générez avec `openssl rand -base64 32`
- `RCON_PASSWORD` : Mot de passe pour RCON (doit correspondre au serveur MC)
#### 2. Déploiement
```bash
cd .. # Retour au dossier parent
./deploy.sh
```
Le script va automatiquement :
- ✅ Vérifier les dépendances (Docker, Docker Compose)
- ✅ Configurer les chemins relatifs entre les projets
- ✅ Démarrer le serveur Minecraft
- ✅ Démarrer l'application web admin
- ✅ Afficher les URLs d'accès
#### 3. Accès
**Serveur Minecraft:**
- Adresse: `votre-ip:25565`
- Version: 1.6.4 (Forge modé)
**Interface Web Admin:**
- Local: `http://localhost:4001`
- Réseau: `http://votre-ip:4001`
- Premier accès: Créez le compte admin
## 🛠️ Gestion
### Arrêter les services
```bash
./stop.sh
```
### Voir les logs
**Serveur Minecraft:**
```bash
cd NationsGlory_ServeurBuild_Red
docker-compose logs -f
```
**Application web:**
```bash
cd WebNationsGlory_ServeurBuild_Red
docker-compose logs -f
```
### Redémarrer
```bash
./stop.sh
./deploy.sh
```
## 🔧 Configuration Avancée
### Variables d'environnement (WebNationsGlory_ServeurBuild_Red/.env)
```bash
# Environnement
NODE_ENV=production
PORT=4001
# Chemin relatif vers le serveur MC
MC_SERVER_PATH=../NationsGlory_ServeurBuild_Red
# RCON (doit correspondre au serveur MC)
RCON_HOST=localhost
RCON_PORT=25575
RCON_PASSWORD=minecraft
# Sécurité (IMPORTANT!)
SESSION_SECRET=votre-secret-genere
# Optionnel: Domaine public
# PUBLIC_HOST=votre-domaine.com
```
### Personnalisation du serveur Minecraft
Éditez `NationsGlory_ServeurBuild_Red/server.properties` selon vos besoins.
Redémarrez ensuite :
```bash
cd NationsGlory_ServeurBuild_Red
docker-compose restart
```
## 📡 Accès à Distance
L'application est conçue pour fonctionner nativement avec n'importe quelle adresse :
- **Localhost**: `http://localhost:4001`
- **IP locale**: `http://192.168.1.X:4001`
- **IP publique**: `http://votre-ip-publique:4001`
- **Nom de domaine**: `http://votre-domaine.com:4001`
Le frontend détecte automatiquement l'hôte et configure les appels API en conséquence.
### Configuration du pare-feu
Si vous déployez sur un serveur distant, ouvrez les ports :
```bash
# UFW (Ubuntu/Debian)
sudo ufw allow 25565/tcp # Minecraft
sudo ufw allow 25575/tcp # RCON
sudo ufw allow 4001/tcp # Web Admin
# Firewalld (CentOS/RHEL)
sudo firewall-cmd --permanent --add-port=25565/tcp
sudo firewall-cmd --permanent --add-port=25575/tcp
sudo firewall-cmd --permanent --add-port=4001/tcp
sudo firewall-cmd --reload
```
## 🔐 Sécurité
### Recommandations
1. **Changez le SESSION_SECRET** : Utilisez une valeur aléatoire forte
```bash
openssl rand -base64 32
```
2. **Changez le RCON_PASSWORD** : Ne laissez pas "minecraft" par défaut
3. **Utilisez HTTPS** : Pour la production, configurez un reverse proxy (nginx, Caddy) avec SSL
4. **Restreignez l'accès** : Utilisez un pare-feu ou VPN pour l'interface admin
### Exemple de configuration nginx avec SSL
```nginx
server {
listen 443 ssl http2;
server_name votre-domaine.com;
ssl_certificate /path/to/cert.pem;
ssl_certificate_key /path/to/key.pem;
location / {
proxy_pass http://localhost:4001;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
}
```
## 📦 Portabilité
Cette configuration est entièrement portable :
✅ **Pas de chemins absolus** : Tout est relatif au dossier parent
✅ **Configuration par variables d'environnement** : Facile à adapter
✅ **Détection automatique de l'hôte** : Fonctionne sur n'importe quelle machine
✅ **Scripts de déploiement** : Installation simplifiée
### Déployer sur une nouvelle machine
1. Copiez tout le dossier `Serveur NationsGlory`
2. Configurez le fichier `.env`
3. Exécutez `./deploy.sh`
C'est tout ! 🎉
## 🐛 Dépannage
### Le serveur Minecraft ne démarre pas
```bash
cd NationsGlory_ServeurBuild_Red
docker-compose logs
```
Vérifiez que le fichier `mcpc.jar` est présent.
### L'application web ne se connecte pas au serveur MC
1. Vérifiez que `RCON_PASSWORD` est identique dans les deux configurations
2. Vérifiez que le serveur MC a démarré complètement
3. Testez RCON manuellement :
```bash
docker exec -it mc-nationsglory rcon-cli
```
### Erreur "SERVER_DIR not found"
Vérifiez que `MC_SERVER_PATH` dans `.env` pointe correctement vers le serveur MC.
### L'API ne répond pas depuis une machine distante
1. Vérifiez que le port 4001 est ouvert
2. Vérifiez que Docker utilise `network_mode: host` dans le docker-compose.yml
3. Testez l'accès : `curl http://votre-ip:4001/api/health`
## 📚 Documentation
- [QUICKSTART.md](WebNationsGlory_ServeurBuild_Red/QUICKSTART.md) - Guide rapide
- [DEPLOYMENT.md](WebNationsGlory_ServeurBuild_Red/DEPLOYMENT.md) - Guide de déploiement détaillé
- [CONFIGURATION.md](WebNationsGlory_ServeurBuild_Red/CONFIGURATION.md) - Configuration avancée
## 🔄 Mises à jour
Pour mettre à jour le projet :
```bash
./stop.sh
git pull # Si vous utilisez git
./deploy.sh
```
## 💾 Sauvegardes
Les sauvegardes sont gérées via l'interface web admin.
Pour une sauvegarde manuelle :
```bash
cd NationsGlory_ServeurBuild_Red
tar -czf backup-$(date +%Y%m%d-%H%M%S).tar.gz \
--exclude='*.log' \
--exclude='*.log.lck' \
world/ config/ mods/ plugins/
```
## 🤝 Support
Pour toute question ou problème :
1. Consultez les logs Docker
2. Vérifiez les fichiers de configuration
3. Assurez-vous que tous les ports sont ouverts
## 📄 Licence
Projet NationsGlory - Administration serveur Minecraft
---
**Note**: Ce README est généré pour faciliter le déploiement sur n'importe quel serveur. Les chemins sont relatifs et s'adaptent automatiquement à l'environnement.

153
SETUP_COMPLETE.md Normal file
View File

@@ -0,0 +1,153 @@
# ✅ Configuration Terminée !
Votre configuration a été optimisée pour un déploiement portable et simplifié.
## 📝 Ce qui a été fait
### ✅ Fichiers créés
- Scripts de déploiement (`deploy.sh`, `stop.sh`, `check-config.sh`)
- Fichiers de configuration `.env.example` pour les deux projets
- Documentation complète (README.md, QUICKSTART.md, MODIFICATIONS.md)
- Configuration nginx exemple pour production
- Fichiers `.env` initiaux avec SESSION_SECRET sécurisé
### ✅ Fichiers modifiés
- `WebNationsGlory_ServeurBuild_Red/docker-compose.yml` : Chemins relatifs et variables d'environnement
- `WebNationsGlory_ServeurBuild_Red/backend/src/server.js` : CORS dynamique
- `WebNationsGlory_ServeurBuild_Red/frontend/public/js/app.js` : Détection automatique de l'API
- `NationsGlory_ServeurBuild_Red/docker-compose.yml` : Support des variables d'environnement
- README des deux projets mis à jour
## 🚀 Prochaines étapes
### 1. Vérifier la configuration
```bash
./check-config.sh
```
### 2. (Optionnel) Modifier les mots de passe
Si vous souhaitez changer le mot de passe RCON par défaut :
```bash
# Éditer les deux fichiers .env
nano NationsGlory_ServeurBuild_Red/.env
nano WebNationsGlory_ServeurBuild_Red/.env
# Assurez-vous que RCON_PASSWORD est identique dans les deux fichiers
```
### 3. Déployer
```bash
./deploy.sh
```
Le script va automatiquement :
- Démarrer le serveur Minecraft
- Démarrer l'application web admin
- Afficher les URLs d'accès
### 4. Accéder aux services
**Serveur Minecraft :**
- Adresse : `votre-ip:25565`
- Version : 1.6.4 (Forge modé)
**Interface Web Admin :**
- Localhost : `http://localhost:4001`
- Réseau : `http://votre-ip:4001`
Au premier accès, créez votre compte admin (votre pseudo Minecraft doit être OP sur le serveur).
## 📦 Portabilité
Votre configuration est maintenant **100% portable** :
**Aucun chemin absolu** - Tout est relatif
**Configuration centralisée** - Fichiers `.env`
**Détection automatique de l'hôte** - Fonctionne avec localhost, IP, domaine
**Scripts de déploiement** - Installation en une commande
### Pour déployer sur une autre machine :
1. Copiez tout le dossier `Serveur NationsGlory`
2. Copiez les fichiers `.env` ou reconfigurez-les
3. Exécutez `./deploy.sh`
C'est tout ! 🎉
## 🔒 Sécurité
### ✅ Déjà configuré
- SESSION_SECRET unique généré automatiquement
- Montage read-only du serveur MC depuis l'app web
- CORS configuré correctement
### ⚠️ À faire pour la production
1. **Changez RCON_PASSWORD** dans les deux fichiers `.env`
2. **Ouvrez les ports** dans votre pare-feu :
```bash
sudo ufw allow 25565/tcp # Minecraft
sudo ufw allow 25575/tcp # RCON
sudo ufw allow 4001/tcp # Web Admin
```
3. **(Recommandé) Configurez HTTPS** avec nginx (voir `WebNationsGlory_ServeurBuild_Red/nginx.conf.example`)
## 📚 Documentation
- **[README.md](README.md)** : Documentation principale
- **[QUICKSTART.md](QUICKSTART.md)** : Guide de démarrage rapide
- **[MODIFICATIONS.md](MODIFICATIONS.md)** : Détails techniques des modifications
- **[WebNationsGlory_ServeurBuild_Red/nginx.conf.example](WebNationsGlory_ServeurBuild_Red/nginx.conf.example)** : Configuration nginx pour SSL
## 🛠️ Commandes utiles
```bash
# Vérifier la configuration
./check-config.sh
# Démarrer tous les services
./deploy.sh
# Arrêter tous les services
./stop.sh
# Voir les logs du serveur Minecraft
cd NationsGlory_ServeurBuild_Red && docker compose logs -f
# Voir les logs de l'application web
cd WebNationsGlory_ServeurBuild_Red && docker compose logs -f
# Redémarrer tout
./stop.sh && ./deploy.sh
```
## 🎯 Résumé des avantages
### Avant
❌ Chemins absolus `/home/innotex/...`
❌ IP hardcodée dans le code
❌ Configuration dispersée
❌ Déploiement complexe
❌ Non portable entre machines
### Maintenant
✅ Chemins relatifs
✅ Détection automatique de l'hôte
✅ Configuration centralisée (`.env`)
✅ Déploiement en une commande
✅ Portable sur n'importe quelle machine
## 🐛 Support
Si vous rencontrez un problème :
1. Vérifiez les logs Docker
2. Exécutez `./check-config.sh`
3. Consultez [MODIFICATIONS.md](MODIFICATIONS.md) pour les détails techniques
---
**Bon déploiement ! 🚀**

223
check-config.sh Executable file
View File

@@ -0,0 +1,223 @@
#!/bin/bash
#######################################
# Script de vérification de configuration
# Vérifie que tout est prêt pour le déploiement
#######################################
# Ne pas utiliser set -e car on veut continuer malgré les erreurs
# set -e
# Couleurs
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m'
ERRORS=0
WARNINGS=0
log_info() {
echo -e "${BLUE}[INFO]${NC} $1"
}
log_success() {
echo -e "${GREEN}[✓]${NC} $1"
}
log_warning() {
echo -e "${YELLOW}[⚠]${NC} $1"
((WARNINGS++))
}
log_error() {
echo -e "${RED}[✗]${NC} $1"
((ERRORS++))
}
SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
MC_SERVER_DIR="${SCRIPT_DIR}/NationsGlory_ServeurBuild_Red"
WEB_ADMIN_DIR="${SCRIPT_DIR}/WebNationsGlory_ServeurBuild_Red"
echo ""
log_info "═══════════════════════════════════════════════════════"
log_info " Vérification de Configuration - NationsGlory"
log_info "═══════════════════════════════════════════════════════"
echo ""
# Vérification Docker
log_info "Vérification de Docker..."
if command -v docker &> /dev/null; then
log_success "Docker installé: $(docker --version | head -n1)"
else
log_error "Docker n'est pas installé"
fi
if docker compose version &> /dev/null 2>&1; then
log_success "Docker Compose v2 installé"
elif command -v docker-compose &> /dev/null; then
log_success "Docker Compose v1 installé"
else
log_error "Docker Compose n'est pas installé"
fi
echo ""
# Vérification des dossiers
log_info "Vérification des dossiers..."
if [ -d "$MC_SERVER_DIR" ]; then
log_success "Dossier serveur MC trouvé"
else
log_error "Dossier serveur MC introuvable: $MC_SERVER_DIR"
fi
if [ -d "$WEB_ADMIN_DIR" ]; then
log_success "Dossier application web trouvé"
else
log_error "Dossier application web introuvable: $WEB_ADMIN_DIR"
fi
echo ""
# Vérification serveur Minecraft
log_info "Vérification du serveur Minecraft..."
if [ -f "$MC_SERVER_DIR/mcpc.jar" ]; then
log_success "Fichier mcpc.jar trouvé"
else
log_error "Fichier mcpc.jar introuvable"
fi
if [ -f "$MC_SERVER_DIR/docker-compose.yml" ]; then
log_success "docker-compose.yml trouvé"
else
log_error "docker-compose.yml introuvable dans le serveur MC"
fi
if [ -f "$MC_SERVER_DIR/.env" ]; then
log_success "Fichier .env trouvé pour le serveur MC"
# Vérifier RCON_PASSWORD
if grep -q "^RCON_PASSWORD=minecraft$" "$MC_SERVER_DIR/.env" 2>/dev/null; then
log_warning "RCON_PASSWORD utilise la valeur par défaut 'minecraft' - Changez-le pour la production!"
else
log_success "RCON_PASSWORD configuré"
fi
else
log_warning "Fichier .env manquant pour le serveur MC (utilisera les valeurs par défaut)"
if [ -f "$MC_SERVER_DIR/.env.example" ]; then
log_info "Copiez .env.example vers .env et configurez-le"
fi
fi
echo ""
# Vérification application web
log_info "Vérification de l'application web..."
if [ -f "$WEB_ADMIN_DIR/docker-compose.yml" ]; then
log_success "docker-compose.yml trouvé"
else
log_error "docker-compose.yml introuvable dans l'application web"
fi
if [ -f "$WEB_ADMIN_DIR/.env" ]; then
log_success "Fichier .env trouvé pour l'application web"
# Vérifier SESSION_SECRET
if grep -q "^SESSION_SECRET=.*changez.*production" "$WEB_ADMIN_DIR/.env" 2>/dev/null; then
log_error "SESSION_SECRET utilise la valeur par défaut - CHANGEZ-LE IMMÉDIATEMENT!"
log_info "Générez un secret avec: openssl rand -base64 32"
elif grep -q "^SESSION_SECRET=your-secret-key-change-in-production" "$WEB_ADMIN_DIR/.env" 2>/dev/null; then
log_error "SESSION_SECRET utilise la valeur par défaut - CHANGEZ-LE IMMÉDIATEMENT!"
log_info "Générez un secret avec: openssl rand -base64 32"
else
log_success "SESSION_SECRET configuré"
fi
# Vérifier RCON_PASSWORD
WEB_RCON_PASS=$(grep "^RCON_PASSWORD=" "$WEB_ADMIN_DIR/.env" 2>/dev/null | cut -d'=' -f2)
MC_RCON_PASS=$(grep "^RCON_PASSWORD=" "$MC_SERVER_DIR/.env" 2>/dev/null | cut -d'=' -f2)
if [ -n "$WEB_RCON_PASS" ] && [ -n "$MC_RCON_PASS" ]; then
if [ "$WEB_RCON_PASS" = "$MC_RCON_PASS" ]; then
log_success "RCON_PASSWORD identique dans les deux configurations"
else
log_error "RCON_PASSWORD différent entre le serveur MC et l'application web!"
log_info "Serveur MC: $MC_RCON_PASS"
log_info "App Web: $WEB_RCON_PASS"
fi
fi
# Vérifier MC_SERVER_PATH
if grep -q "^MC_SERVER_PATH=" "$WEB_ADMIN_DIR/.env" 2>/dev/null; then
MC_PATH=$(grep "^MC_SERVER_PATH=" "$WEB_ADMIN_DIR/.env" | cut -d'=' -f2)
log_success "MC_SERVER_PATH configuré: $MC_PATH"
else
log_warning "MC_SERVER_PATH non défini (utilisera ../NationsGlory_ServeurBuild_Red par défaut)"
fi
else
log_error "Fichier .env manquant pour l'application web"
if [ -f "$WEB_ADMIN_DIR/.env.example" ]; then
log_info "Copiez .env.example vers .env et configurez-le"
fi
fi
if [ -d "$WEB_ADMIN_DIR/backend/node_modules" ]; then
log_success "Dépendances Node.js installées"
else
log_warning "node_modules manquant - sera installé lors du build Docker"
fi
echo ""
# Vérification des ports
log_info "Vérification des ports..."
check_port() {
local port=$1
local service=$2
if lsof -Pi :$port -sTCP:LISTEN -t >/dev/null 2>&1 || ss -ltn | grep -q ":$port " 2>/dev/null; then
log_warning "Port $port ($service) déjà utilisé"
else
log_success "Port $port ($service) disponible"
fi
}
check_port 25565 "Minecraft"
check_port 25575 "RCON"
check_port 4001 "Web Admin"
echo ""
# Vérification des permissions
log_info "Vérification des permissions..."
if [ -x "$SCRIPT_DIR/deploy.sh" ]; then
log_success "Script deploy.sh exécutable"
else
log_warning "Script deploy.sh non exécutable (chmod +x deploy.sh)"
fi
if [ -x "$SCRIPT_DIR/stop.sh" ]; then
log_success "Script stop.sh exécutable"
else
log_warning "Script stop.sh non exécutable (chmod +x stop.sh)"
fi
echo ""
# Résumé
log_info "═══════════════════════════════════════════════════════"
if [ $ERRORS -eq 0 ] && [ $WARNINGS -eq 0 ]; then
log_success "✓ Toutes les vérifications sont passées!"
log_info "Vous pouvez démarrer le déploiement avec: ./deploy.sh"
elif [ $ERRORS -eq 0 ]; then
log_success "Aucune erreur critique"
log_warning "$WARNINGS avertissement(s) - Vérifiez les points ci-dessus"
log_info "Vous pouvez démarrer le déploiement avec: ./deploy.sh"
else
log_error "$ERRORS erreur(s) trouvée(s)"
log_warning "$WARNINGS avertissement(s)"
log_info "Corrigez les erreurs avant de déployer"
exit 1
fi
log_info "═══════════════════════════════════════════════════════"
echo ""

206
deploy.sh Executable file
View File

@@ -0,0 +1,206 @@
#!/bin/bash
#######################################
# Script de déploiement NationsGlory
# Démarre le serveur Minecraft et l'application web admin
#######################################
set -e
# Couleurs pour les logs
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color
# Fonction pour afficher des messages
log_info() {
echo -e "${BLUE}[INFO]${NC} $1"
}
log_success() {
echo -e "${GREEN}[SUCCESS]${NC} $1"
}
log_warning() {
echo -e "${YELLOW}[WARNING]${NC} $1"
}
log_error() {
echo -e "${RED}[ERROR]${NC} $1"
}
# Récupérer le chemin absolu du script
SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
# Chemins des projets (relatifs au script)
MC_SERVER_DIR="${SCRIPT_DIR}/NationsGlory_ServeurBuild_Red"
WEB_ADMIN_DIR="${SCRIPT_DIR}/WebNationsGlory_ServeurBuild_Red"
log_info "═══════════════════════════════════════════════════════"
log_info " Déploiement NationsGlory - Serveur & Web Admin"
log_info "═══════════════════════════════════════════════════════"
echo ""
# Vérification de Docker
if ! command -v docker &> /dev/null; then
log_error "Docker n'est pas installé. Veuillez installer Docker."
exit 1
fi
if ! command -v docker-compose &> /dev/null && ! docker compose version &> /dev/null; then
log_error "Docker Compose n'est pas installé."
exit 1
fi
# Détecter la commande docker compose
if docker compose version &> /dev/null; then
DOCKER_COMPOSE="docker compose"
else
DOCKER_COMPOSE="docker-compose"
fi
log_success "Docker détecté: $(docker --version)"
log_success "Docker Compose détecté"
echo ""
# Vérification des dossiers
log_info "Vérification des dossiers..."
if [ ! -d "$MC_SERVER_DIR" ]; then
log_error "Dossier serveur Minecraft introuvable: $MC_SERVER_DIR"
exit 1
fi
if [ ! -d "$WEB_ADMIN_DIR" ]; then
log_error "Dossier application web introuvable: $WEB_ADMIN_DIR"
exit 1
fi
log_success "Dossiers trouvés"
log_info " - Serveur MC: $MC_SERVER_DIR"
log_info " - Web Admin: $WEB_ADMIN_DIR"
echo ""
# Configuration de l'application web
log_info "Configuration de l'application web..."
cd "$WEB_ADMIN_DIR"
if [ ! -f ".env" ]; then
log_warning "Fichier .env introuvable. Création depuis .env.example..."
if [ -f ".env.example" ]; then
cp .env.example .env
log_warning "⚠️ IMPORTANT: Éditez le fichier .env et configurez:"
log_warning " - SESSION_SECRET (utilisez: openssl rand -base64 32)"
log_warning " - RCON_PASSWORD (doit correspondre au serveur MC)"
echo ""
read -p "Appuyez sur Entrée pour continuer après avoir configuré .env..."
else
log_error "Fichier .env.example introuvable"
exit 1
fi
else
log_success "Fichier .env trouvé"
fi
# Charger les variables d'environnement
if [ -f ".env" ]; then
export $(cat .env | grep -v '^#' | xargs)
fi
# Calculer le chemin relatif du serveur MC depuis l'application web
MC_RELATIVE_PATH=$(realpath --relative-to="$WEB_ADMIN_DIR" "$MC_SERVER_DIR")
log_info "Chemin relatif calculé: $MC_RELATIVE_PATH"
# Mettre à jour MC_SERVER_PATH dans .env si nécessaire
if ! grep -q "^MC_SERVER_PATH=" .env 2>/dev/null; then
echo "MC_SERVER_PATH=$MC_RELATIVE_PATH" >> .env
log_info "MC_SERVER_PATH ajouté au fichier .env"
fi
echo ""
# Démarrage du serveur Minecraft
log_info "═══════════════════════════════════════════════════════"
log_info "Démarrage du serveur Minecraft..."
log_info "═══════════════════════════════════════════════════════"
cd "$MC_SERVER_DIR"
if [ ! -f "docker-compose.yml" ]; then
log_error "docker-compose.yml introuvable dans le dossier serveur MC"
exit 1
fi
log_info "Arrêt des conteneurs existants (si présents)..."
$DOCKER_COMPOSE down 2>/dev/null || true
log_info "Démarrage du serveur Minecraft..."
$DOCKER_COMPOSE up -d
if [ $? -eq 0 ]; then
log_success "✓ Serveur Minecraft démarré"
else
log_error "Erreur lors du démarrage du serveur Minecraft"
exit 1
fi
echo ""
# Démarrage de l'application web
log_info "═══════════════════════════════════════════════════════"
log_info "Démarrage de l'application web admin..."
log_info "═══════════════════════════════════════════════════════"
cd "$WEB_ADMIN_DIR"
log_info "Arrêt des conteneurs existants (si présents)..."
$DOCKER_COMPOSE down 2>/dev/null || true
log_info "Construction et démarrage de l'application web..."
$DOCKER_COMPOSE up -d --build
if [ $? -eq 0 ]; then
log_success "✓ Application web admin démarrée"
else
log_error "Erreur lors du démarrage de l'application web"
exit 1
fi
echo ""
# Récupérer l'IP locale
LOCAL_IP=$(hostname -I | awk '{print $1}')
# Affichage des informations
log_info "═══════════════════════════════════════════════════════"
log_success "🎉 Déploiement terminé avec succès!"
log_info "═══════════════════════════════════════════════════════"
echo ""
log_info "📋 Informations de connexion:"
echo ""
log_info "Serveur Minecraft:"
log_info " - Port: ${SERVER_PORT:-25565}"
log_info " - RCON: ${RCON_PORT:-25575}"
if [ -n "$LOCAL_IP" ]; then
log_info " - IP locale: $LOCAL_IP:${SERVER_PORT:-25565}"
fi
echo ""
log_info "Application Web Admin:"
log_info " - Port: ${PORT:-4001}"
log_info " - Accès local: http://localhost:${PORT:-4001}"
if [ -n "$LOCAL_IP" ]; then
log_info " - Accès réseau: http://$LOCAL_IP:${PORT:-4001}"
fi
echo ""
log_info "═══════════════════════════════════════════════════════"
log_info "Commandes utiles:"
echo ""
log_info "Voir les logs du serveur MC:"
log_info " cd $MC_SERVER_DIR && $DOCKER_COMPOSE logs -f"
echo ""
log_info "Voir les logs de l'application web:"
log_info " cd $WEB_ADMIN_DIR && $DOCKER_COMPOSE logs -f"
echo ""
log_info "Arrêter tous les services:"
log_info " $0 stop"
echo ""
log_info "═══════════════════════════════════════════════════════"

69
stop.sh Executable file
View File

@@ -0,0 +1,69 @@
#!/bin/bash
#######################################
# Script d'arrêt NationsGlory
# Arrête le serveur Minecraft et l'application web admin
#######################################
set -e
# Couleurs pour les logs
RED='\033[0;31m'
GREEN='\033[0;32m'
BLUE='\033[0;34m'
NC='\033[0m'
log_info() {
echo -e "${BLUE}[INFO]${NC} $1"
}
log_success() {
echo -e "${GREEN}[SUCCESS]${NC} $1"
}
log_error() {
echo -e "${RED}[ERROR]${NC} $1"
}
# Récupérer le chemin absolu du script
SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
MC_SERVER_DIR="${SCRIPT_DIR}/NationsGlory_ServeurBuild_Red"
WEB_ADMIN_DIR="${SCRIPT_DIR}/WebNationsGlory_ServeurBuild_Red"
# Détecter la commande docker compose
if docker compose version &> /dev/null; then
DOCKER_COMPOSE="docker compose"
else
DOCKER_COMPOSE="docker-compose"
fi
log_info "═══════════════════════════════════════════════════════"
log_info " Arrêt NationsGlory - Serveur & Web Admin"
log_info "═══════════════════════════════════════════════════════"
echo ""
# Arrêt de l'application web
if [ -d "$WEB_ADMIN_DIR" ]; then
log_info "Arrêt de l'application web admin..."
cd "$WEB_ADMIN_DIR"
$DOCKER_COMPOSE down
log_success "✓ Application web arrêtée"
else
log_error "Dossier web admin introuvable: $WEB_ADMIN_DIR"
fi
echo ""
# Arrêt du serveur Minecraft
if [ -d "$MC_SERVER_DIR" ]; then
log_info "Arrêt du serveur Minecraft..."
cd "$MC_SERVER_DIR"
$DOCKER_COMPOSE down
log_success "✓ Serveur Minecraft arrêté"
else
log_error "Dossier serveur MC introuvable: $MC_SERVER_DIR"
fi
echo ""
log_success "🛑 Tous les services sont arrêtés"