# 🚀 Guide de Déploiement - Serveur NationsGlory sur /srv/minecraft

## Architecture de production

```
/srv/minecraft/
├── proxy/              # Velocity/BungeeCord (futur)
├── survie/             # Serveur survie vanilla (futur)
├── moddé/              # ← Serveur NationsGlory MCPC+ 1.6.4
│   ├── docker-compose.yml
│   ├── .env
│   ├── data/           # Données serveur
│   │   ├── mcpc.jar
│   │   ├── server.properties
│   │   ├── ops.txt
│   │   └── ...
│   ├── mods/           # 13 mods Forge
│   ├── plugins/        # WorldEdit + Essentials
│   ├── config/         # Configurations mods
│   ├── libraries/      # Dépendances Maven
│   └── world/          # Monde Minecraft
└── backups/            # Sauvegardes automatiques
```

## 📋 Prérequis

### Sur la machine de production

1. **Docker & Docker Compose**
```bash
# Installer Docker
curl -fsSL https://get.docker.com | sh

# Installer Docker Compose
sudo apt install docker-compose

# Ajouter l'utilisateur au groupe docker
sudo usermod -aG docker $USER
```

2. **Permissions sur /srv**
```bash
sudo mkdir -p /srv/minecraft
sudo chown $USER:$USER /srv/minecraft
```

3. **Ports disponibles**
- Port 25565 (Minecraft)
- Ou configurer un autre port dans docker-compose.yml

## 🚚 Migration du serveur

### Méthode 1 : Script automatique (recommandé)

```bash
# Sur la machine de développement
cd "/home/innotex/Documents/Projet/Serveur NationsGlory"

# Rendre le script exécutable
chmod +x migrate-to-srv.sh

# Exécuter la migration (nécessite sudo)
sudo ./migrate-to-srv.sh
```

Le script va :
- ✅ Créer la structure /srv/minecraft
- ✅ Copier tous les fichiers nécessaires
- ✅ Configurer les permissions
- ✅ Créer un backup de sécurité
- ✅ Installer docker-compose.yml

### Méthode 2 : Migration manuelle

```bash
# 1. Créer la structure
sudo mkdir -p /srv/minecraft/moddé/{data,mods,plugins,config,libraries,backups}

# 2. Copier les fichiers
sudo cp -r server-final/mcpc.jar /srv/minecraft/moddé/data/
sudo cp -r server-final/mods/* /srv/minecraft/moddé/mods/
sudo cp -r server-final/plugins/* /srv/minecraft/moddé/plugins/
sudo cp -r server-final/config/* /srv/minecraft/moddé/config/
sudo cp -r server-final/libraries/* /srv/minecraft/moddé/libraries/
sudo cp server-final/server.properties /srv/minecraft/moddé/data/
sudo cp server-final/ops.txt /srv/minecraft/moddé/data/

# 3. Copier la configuration Docker
sudo cp docker-compose.yml /srv/minecraft/moddé/
sudo cp .env.example /srv/minecraft/moddé/.env

# 4. Permissions
sudo chown -R 1000:1000 /srv/minecraft/moddé
sudo chmod -R 755 /srv/minecraft/moddé
```

### Méthode 3 : Transfert vers machine distante

```bash
# Créer une archive
cd "/home/innotex/Documents/Projet/Serveur NationsGlory"
tar -czf nationsglory-server.tar.gz server-final/ docker-compose.yml .env.example

# Transférer via SCP
scp nationsglory-server.tar.gz user@serveur-prod:/tmp/

# Sur le serveur de production
ssh user@serveur-prod
cd /srv/minecraft
sudo mkdir -p moddé
cd moddé
sudo tar -xzf /tmp/nationsglory-server.tar.gz
sudo mv server-final/* data/
sudo chown -R 1000:1000 .
```

## 🐳 Utilisation avec Docker

### Démarrer le serveur

```bash
cd /srv/minecraft/moddé

# Premier démarrage (création du monde)
docker-compose up -d

# Voir les logs en temps réel
docker-compose logs -f

# Attendre le message "Done!" dans les logs
```

### Commandes Docker Compose

```bash
# Démarrer
docker-compose up -d

# Arrêter proprement
docker-compose down

# Redémarrer
docker-compose restart

# Voir les logs
docker-compose logs -f

# Voir l'état
docker-compose ps

# Exécuter une commande dans le conteneur
docker-compose exec nationsglory-modded rcon-cli

# Entrer dans le conteneur
docker-compose exec nationsglory-modded bash
```

### Commandes serveur via RCON

```bash
# Se connecter à la console serveur
docker-compose exec nationsglory-modded rcon-cli

# Puis taper vos commandes :
> op <pseudo>
> stop
> save-all
> list
```

## ⚙️ Configuration

### Modifier les paramètres (.env)

```bash
cd /srv/minecraft/moddé
nano .env
```

Variables importantes :
```env
MEMORY=2G              # RAM maximale
INIT_MEMORY=1G         # RAM initiale
MINECRAFT_PORT=25565   # Port d'écoute
MAX_PLAYERS=20         # Joueurs max
VIEW_DISTANCE=10       # Distance de vue
GAMEMODE=creative      # Mode par défaut
LEVEL_TYPE=FLAT        # Type de monde
```

Après modification :
```bash
docker-compose down
docker-compose up -d
```

### Modifier server.properties

```bash
cd /srv/minecraft/moddé
nano data/server.properties
```

Puis redémarrer :
```bash
docker-compose restart
```

## 📊 Monitoring et logs

### Logs en temps réel

```bash
# Tous les logs
docker-compose logs -f

# Seulement les nouvelles lignes
docker-compose logs -f --tail=100

# Filtrer par mot-clé
docker-compose logs -f | grep ERROR
```

### Fichiers de logs

Les logs sont dans `/srv/minecraft/moddé/data/logs/` :
```bash
tail -f /srv/minecraft/moddé/data/logs/latest.log
```

### Statistiques conteneur

```bash
# Utilisation ressources
docker stats mc-nationsglory

# Processus dans le conteneur
docker top mc-nationsglory
```

## 💾 Sauvegardes

### Backup manuel

```bash
cd /srv/minecraft/moddé

# Arrêter le serveur
docker-compose down

# Créer le backup
sudo tar -czf /srv/minecraft/backups/world-$(date +%Y%m%d-%H%M).tar.gz \
    data/world/ \
    data/ops.txt \
    data/white-list.txt \
    data/banned-*.txt

# Redémarrer
docker-compose up -d
```

### Script de backup automatique

Créer `/srv/minecraft/backup.sh` :
```bash
#!/bin/bash
cd /srv/minecraft/moddé

# Sauvegarder le monde via RCON
docker-compose exec -T nationsglory-modded rcon-cli save-all flush
sleep 5

# Créer l'archive
tar -czf /srv/minecraft/backups/auto-$(date +%Y%m%d-%H%M).tar.gz \
    data/world/ data/ops.txt data/white-list.txt

# Supprimer les backups > 7 jours
find /srv/minecraft/backups/ -name "auto-*.tar.gz" -mtime +7 -delete

echo "Backup terminé: $(date)"
```

Automatiser avec cron :
```bash
sudo crontab -e

# Backup quotidien à 3h du matin
0 3 * * * /srv/minecraft/backup.sh >> /var/log/minecraft-backup.log 2>&1
```

### Restaurer un backup

```bash
cd /srv/minecraft/moddé

# Arrêter le serveur
docker-compose down

# Sauvegarder le monde actuel
mv data/world data/world.old

# Restaurer
tar -xzf /srv/minecraft/backups/world-YYYYMMDD-HHMM.tar.gz

# Redémarrer
docker-compose up -d
```

## 🔒 Sécurité

### Firewall (UFW)

```bash
# Autoriser le port Minecraft
sudo ufw allow 25565/tcp

# Vérifier
sudo ufw status
```

### Whitelist (liste blanche)

```bash
# Activer la whitelist
docker-compose exec nationsglory-modded rcon-cli whitelist on

# Ajouter un joueur
docker-compose exec nationsglory-modded rcon-cli whitelist add <pseudo>

# Liste des joueurs autorisés
docker-compose exec nationsglory-modded rcon-cli whitelist list
```

### Bannir un joueur

```bash
# Bannir
docker-compose exec nationsglory-modded rcon-cli ban <pseudo> <raison>

# Débannir
docker-compose exec nationsglory-modded rcon-cli pardon <pseudo>
```

## 🔧 Maintenance

### Mettre à jour l'image Docker

```bash
cd /srv/minecraft/moddé

# Arrêter le serveur
docker-compose down

# Récupérer la dernière image
docker-compose pull

# Redémarrer
docker-compose up -d
```

### Nettoyer les logs

```bash
cd /srv/minecraft/moddé

# Supprimer les anciens logs
rm -f data/logs/*.log.gz
rm -f data/*.log.*
```

### Réinitialiser le monde

⚠️ **ATTENTION** : Supprime toutes les constructions !

```bash
cd /srv/minecraft/moddé

# Backup avant suppression
tar -czf /srv/minecraft/backups/world-before-reset-$(date +%Y%m%d).tar.gz data/world/

# Arrêter le serveur
docker-compose down

# Supprimer le monde
sudo rm -rf data/world/

# Redémarrer (nouveau monde généré)
docker-compose up -d
```

## 🌐 Intégration avec Traefik (reverse proxy)

Si vous utilisez Traefik pour gérer vos services :

### docker-compose.yml modifié

```yaml
services:
  nationsglory-modded:
    # ... configuration existante ...
    
    labels:
      # Traefik
      - "traefik.enable=true"
      - "traefik.tcp.routers.minecraft.rule=HostSNI(`*`)"
      - "traefik.tcp.routers.minecraft.entrypoints=minecraft"
      - "traefik.tcp.routers.minecraft.service=minecraft"
      - "traefik.tcp.services.minecraft.loadbalancer.server.port=25565"
    
    networks:
      - traefik-network
      - minecraft-network

networks:
  traefik-network:
    external: true
  minecraft-network:
    driver: bridge
```

## 📈 Optimisation des performances

### Augmenter la RAM

Dans `.env` :
```env
MEMORY=4G
INIT_MEMORY=2G
```

Puis :
```bash
docker-compose down
docker-compose up -d
```

### Limiter la view-distance

Dans `data/server.properties` :
```properties
view-distance=8  # Au lieu de 10
```

### Optimiser le GC (Garbage Collector)

Dans `docker-compose.yml`, section `environment` :
```yaml
JVM_OPTS: "-XX:+UseG1GC -XX:MaxGCPauseMillis=50"
```

## 🐛 Dépannage

### Le serveur ne démarre pas

```bash
# Voir les logs complets
docker-compose logs

# Vérifier les permissions
ls -la /srv/minecraft/moddé/data/

# Vérifier que mcpc.jar existe
ls -lh /srv/minecraft/moddé/data/mcpc.jar
```

### Erreur de mémoire

```bash
# Augmenter la RAM dans .env
MEMORY=3G

# Redémarrer
docker-compose restart
```

### Port déjà utilisé

```bash
# Vérifier quel processus utilise le port
sudo netstat -tuln | grep 25565

# Changer le port dans .env
MINECRAFT_PORT=25566
```

### Problème de permissions

```bash
# Réparer les permissions
cd /srv/minecraft/moddé
sudo chown -R 1000:1000 .
sudo chmod -R 755 .
```

## 📞 Support

### Logs importants

- **Logs Docker** : `docker-compose logs`
- **Logs serveur** : `/srv/minecraft/moddé/data/logs/latest.log`
- **Crash reports** : `/srv/minecraft/moddé/data/crash-reports/`

### Commandes de diagnostic

```bash
# État du conteneur
docker ps

# Statistiques
docker stats mc-nationsglory

# Espace disque
du -sh /srv/minecraft/moddé/

# Processus Java
docker-compose exec nationsglory-modded ps aux | grep java
```

## 🎯 Checklist de déploiement

- [ ] Docker et Docker Compose installés
- [ ] Structure /srv/minecraft créée
- [ ] Fichiers migrés dans /srv/minecraft/moddé
- [ ] Permissions configurées (1000:1000)
- [ ] Fichier .env configuré
- [ ] Port 25565 ouvert dans le firewall
- [ ] docker-compose up -d exécuté
- [ ] Logs vérifiés (pas d'erreurs)
- [ ] Connexion testée depuis un client
- [ ] OP donné au premier joueur
- [ ] Backup automatique configuré
- [ ] Documentation consultée

---

**Version** : MCPC+ 1.6.4-R2.1-forge965-B251  
**Image Docker** : itzg/minecraft-server:java8  
**Production ready** : ✅