Guide de Configuration d'un Proxy Velocity sur Serveur Minecraft
Published on November 11, 2025 at 03:09 PM
Ce guide vous accompagne dans la configuration d'un proxy Velocity pour votre réseau de serveurs Minecraft
# Guide de Configuration d'un Proxy Velocity sur Serveur Minecraft
**Accès à votre panel Wisp** : [https://panel.verycloud.fr/](https://panel.verycloud.fr/)
**Documentation complète** : [https://verycloud.fr/docs](https://verycloud.fr/docs)
## Qu'est-ce que Velocity ?
Velocity est un proxy Minecraft moderne, performant et sécurisé qui permet de :
- Connecter plusieurs serveurs Minecraft ensemble
- Permettre aux joueurs de passer d'un serveur à l'autre sans se déconnecter
- Réduire la charge sur chaque serveur individuel
- Centraliser l'authentification des joueurs
- Améliorer la sécurité avec le modern forwarding
- Support complet de Minecraft 1.7.2 à 1.21+
## Pourquoi Utiliser Velocity ?
**Avantages** :
- **Performance** : Écrit en Java avec optimisations modernes
- **Sécurité** : Modern forwarding pour protéger vos serveurs backend
- **Compatibilité** : Support de Paper, Spigot, Bukkit, Fabric, Forge
- **Flexibilité** : Configuration facile avec fichiers TOML
- **Plugins** : Écosystème de plugins en croissance
## Architecture d'un Réseau Velocity
```
Joueurs → Velocity Proxy (Port 25565) → Serveurs Backend
├─ Lobby (Port 25566)
├─ Survie (Port 25567)
├─ Créatif (Port 25568)
└─ Mini-jeux (Port 25569)
```
## Prérequis
Avant de commencer, assurez-vous d'avoir :
- Accès à votre panel Wisp VeryCloud
- Au moins 2 serveurs Minecraft sur Wisp :
- 1 serveur pour Velocity (proxy)
- 1+ serveur(s) backend (Paper, Spigot, etc.)
- Les identifiants de connexion Wisp
- Connexion SSH ou accès au gestionnaire de fichiers
## Partie 1 : Installation du Serveur Velocity
### Étape 1 : Créer un Nouveau Serveur pour Velocity
1. Connectez-vous à [https://panel.verycloud.fr/](https://panel.verycloud.fr/)
2. Dans le dashboard, cliquez sur **Créer un serveur** (si vous n'avez pas encore créé le serveur Velocity)
3. Sélectionnez :
- **Type** : Java (Velocity)
- **Version** : Velocity (dernière version)
- **RAM** : Minimum 512 MB (1 GB recommandé pour 50+ joueurs)
- **Nom** : "Proxy-Velocity" ou similaire
4. Cliquez sur **Créer**
### Étape 2 : Sélection du Serveur Velocity
Si vous avez déjà un serveur dédié à Velocity :
1. Dans votre liste de serveurs, cliquez sur votre serveur Velocity
2. Vous arrivez sur la console du serveur
### Étape 3 : Téléchargement de Velocity
**Via le panel Wisp** :
1. Allez dans **Files** (Fichiers) dans le menu de gauche
2. Vérifiez que le fichier `velocity.jar` est présent
3. Si ce n'est pas le cas, téléchargez-le :
- Allez sur https://papermc.io/downloads/velocity
- Téléchargez la dernière version
- Uploadez-le via le panel dans le dossier racine
### Étape 4 : Premier Démarrage de Velocity
1. Retournez dans la **Console**
2. Cliquez sur **Start** (Démarrer)
3. Velocity va générer les fichiers de configuration
4. Attendez le message : `Done! Velocity is ready to accept connections.`
5. Cliquez sur **Stop** pour arrêter le serveur
## Partie 2 : Configuration de Velocity
### Étape 1 : Accès au Fichier de Configuration
1. Dans le panel Wisp, allez dans **Files**
2. Localisez et ouvrez le fichier **velocity.toml**
3. Le fichier s'ouvre dans l'éditeur intégré
### Étape 2 : Configuration de Base
Voici les sections importantes à configurer :
#### Configuration Réseau
```toml
# Configuration du bind (ne pas modifier généralement)
bind = "0.0.0.0:25577"
# MOTD du serveur (message affiché dans la liste)
motd = "&3Bienvenue sur Mon Réseau Minecraft\n&bPowered by Velocity"
# Nombre maximum de joueurs
show-max-players = 100
# Version du protocole à annoncer
# Laissez vide pour auto-détection
announce-forge = false
```
**Note** : Le port `25577` est le port interne. Wisp fera automatiquement le mapping vers le port externe (généralement 25565).
#### Configuration des Serveurs Backend
C'est la section la plus importante. Ajoutez vos serveurs backend :
```toml
[servers]
# Format: nom-serveur = "adresse:port"
# Serveur lobby (serveur par défaut)
lobby = "127.0.0.1:25566"
# Serveur survie
survival = "127.0.0.1:25567"
# Serveur créatif
creative = "127.0.0.1:25568"
# Serveur mini-jeux
minigames = "127.0.0.1:25569"
# Vous pouvez ajouter autant de serveurs que nécessaire
```
**Important** :
- Si vos serveurs sont sur le **même VPS** que Velocity, utilisez `127.0.0.1:PORT`
- Si vos serveurs sont sur des **VPS différents**, utilisez l'IP publique : `123.45.67.89:PORT`
#### Ordre de Connexion (Try List)
Définissez l'ordre de connexion des joueurs :
```toml
[servers]
# ... vos serveurs ci-dessus ...
try = [
"lobby",
"survival"
]
```
Les joueurs tenteront de se connecter d'abord au `lobby`, puis à `survival` si le lobby est indisponible.
#### Configuration du Forwarding
**CRITIQUE pour la sécurité** :
```toml
[forwarding]
# Mode de forwarding
# Options: "none", "legacy", "modern"
mode = "modern"
# Clé secrète pour modern forwarding
# GÉNÉREZ UNE CLÉ UNIQUE ET SÉCURISÉE
secret = "VOTRE_CLE_SECRETE_ICI"
# Taille maximale du buffer
forwarding-secret-file = ""
```
**Génération d'une clé secrète** :
Utilisez un générateur de clé aléatoire. Exemple en ligne de commande :
```bash
openssl rand -base64 32
```
Ou utilisez un générateur en ligne : https://generate.plus/en/base64
**Exemple de clé** : `dXJhbmRvbWtleWhlcmVmb3JzZWN1cml0eXB1cnBvc2Vz`
### Étape 3 : Configuration Avancée (Optionnelle)
#### Messages Personnalisés
```toml
[messages]
# Message de kick lorsqu'aucun serveur n'est disponible
no-available-servers = "&cAucun serveur disponible. Réessayez plus tard."
# Message lorsqu'un serveur est déjà connecté
already-connected = "&cVous êtes déjà connecté à ce serveur!"
# Message de connexion refusée
connection-denied = "&cConnexion refusée. Contactez un administrateur."
```
#### Configuration de la Requête
```toml
[query]
# Activer le protocole Query
enabled = true
# Port pour les requêtes (généralement identique au port de jeu)
port = 25577
# Afficher les plugins
show-plugins = false
```
#### Configuration Avancée
```toml
[advanced]
# Taille de la compression réseau
compression-threshold = 256
# Niveau de compression (1-9, plus élevé = plus de CPU)
compression-level = -1
# Timeout de connexion (millisecondes)
connection-timeout = 5000
# Timeout de lecture
read-timeout = 30000
# Activer le HAProxy protocol
haproxy-protocol = false
# Activer TCP fast open
tcp-fast-open = false
# Activer BungeeCord plugin messaging channel
bungee-plugin-message-channel = true
# Montrer le ping dans la liste des serveurs
show-ping-requests = false
# Annoncer les erreurs dans la console
announce-proxy-commands = true
# Activer le log des connexions
log-player-connections = true
```
### Étape 4 : Sauvegarde de la Configuration
1. Après avoir modifié `velocity.toml`, cliquez sur **Save** (Sauvegarder) en haut à droite
2. Redémarrez le serveur Velocity via la console : **Restart**
## Partie 3 : Configuration des Serveurs Backend
Chaque serveur backend (Paper, Spigot, etc.) doit être configuré pour fonctionner avec Velocity.
### Étape 1 : Configuration de Paper/Spigot
Pour **chaque serveur backend**, vous devez :
#### A. Configurer le Mode Online
1. Dans le panel Wisp, sélectionnez votre serveur backend (ex: Lobby)
2. Allez dans **Files**
3. Ouvrez **server.properties**
4. Modifiez cette ligne :
```properties
online-mode=false
```
**Important** : Mettez `online-mode=false` sur tous les serveurs backend !
5. Sauvegardez
#### B. Configurer Velocity Forwarding (Paper)
Si vous utilisez **Paper** (recommandé) :
1. Dans le serveur backend, allez dans **Files**
2. Ouvrez le fichier **config/paper-global.yml** (ou **paper.yml** pour les anciennes versions)
3. Trouvez la section `proxies` et modifiez :
```yaml
proxies:
velocity:
enabled: true
online-mode: true
secret: "VOTRE_CLE_SECRETE_ICI"
```
**Important** : Utilisez la **même clé secrète** que celle définie dans `velocity.toml` !
4. Sauvegardez
#### C. Configurer BungeeCord Mode (Spigot)
Si vous utilisez **Spigot** ou **Bukkit** :
1. Dans le serveur backend, ouvrez **spigot.yml**
2. Modifiez :
```yaml
settings:
bungeecord: true
```
3. Sauvegardez
**Note** : Spigot utilise le mode BungeeCord legacy. Modern forwarding n'est disponible que sur Paper.
### Étape 2 : Configuration des Ports
Assurez-vous que chaque serveur backend écoute sur un port différent :
1. Dans **server.properties** de chaque serveur backend :
```properties
# Lobby
server-port=25566
# Survie
server-port=25567
# Créatif
server-port=25568
```
2. Ces ports doivent correspondre à ceux définis dans `velocity.toml`
### Étape 3 : Redémarrage des Serveurs Backend
Pour chaque serveur backend :
1. Allez dans la **Console**
2. Cliquez sur **Restart**
3. Vérifiez qu'il démarre correctement
## Partie 4 : Plugins Velocity Essentiels
### Installation de Plugins
1. Téléchargez les plugins depuis :
- https://hangar.papermc.io/
- https://modrinth.com/
- https://www.spigotmc.org/
2. Dans le panel Wisp, serveur Velocity, allez dans **Files**
3. Naviguez vers le dossier **plugins**
4. Uploadez le fichier `.jar` du plugin
5. Redémarrez Velocity
### Plugins Recommandés
#### LuckPerms (Permissions)
Gestion des permissions à travers tout le réseau.
**Installation** :
1. Téléchargez depuis : https://luckperms.net/download
2. Installez sur Velocity **ET** tous les serveurs backend
3. Configurez la base de données partagée (MySQL recommandé)
**Configuration** :
```yaml
# Dans config.yml de LuckPerms
storage-method: mysql
data:
address: localhost:3306
database: luckperms
username: root
password: motdepasse
```
#### LibertyBans (Modération)
Système de bannissement centralisé.
**Téléchargement** : https://github.com/A248/LibertyBans
**Installation** :
1. Installez sur Velocity uniquement
2. Configure la base de données
3. Utilisez les commandes `/ban`, `/mute`, etc.
#### VelocityTab (Tab List)
Affichage personnalisé de la liste des joueurs.
**Téléchargement** : https://github.com/WiIIiam278/Velocitab
**Installation** :
1. Installez sur Velocity
2. Configurez dans `plugins/velocitab/config.yml`
#### LuckPerms Velocity (Configuration)
Configuration dans `plugins/LuckPerms/config.yml` :
```yaml
server: velocity
storage-method: mysql
data:
address: votre-db-host:3306
database: luckperms
username: luckperms_user
password: votre_password
# Synchronisation entre serveurs
sync-minutes: 3
```
## Partie 5 : Commandes et Gestion
### Commandes Velocity (Console ou In-Game)
#### Commandes de Base
```
/velocity dump
- Génère un dump de diagnostic
/velocity plugins
- Liste les plugins installés
/velocity version
- Affiche la version de Velocity
/velocity reload
- Recharge la configuration (certains changements nécessitent un redémarrage)
```
#### Commandes pour les Joueurs
```
/server
- Se connecter à un serveur spécifique
/server
- Voir les serveurs disponibles
```
### Permissions
Configurez les permissions avec LuckPerms :
```
# Permission pour utiliser /server
velocity.command.server
# Permission pour voir tous les serveurs
velocity.command.server.list
# Permission admin
velocity.admin
```
## Partie 6 : Sécurisation du Réseau
### Étape 1 : Pare-feu sur les Serveurs Backend
**CRITIQUE** : Les serveurs backend ne doivent **PAS** être accessibles directement depuis Internet.
#### Configuration UFW (si applicable)
Sur chaque serveur backend :
```bash
# Bloquer l'accès externe au port du serveur
ufw deny 25566/tcp
# Autoriser uniquement Velocity (même machine)
ufw allow from 127.0.0.1 to any port 25566
```
**Note** : Avec Wisp, cela peut être géré via les allocations de ports.
### Étape 2 : Configuration des Allocations Wisp
1. Dans Wisp, pour chaque serveur backend :
2. Allez dans **Network** (Réseau)
3. Assurez-vous que les ports backend ne sont **pas** exposés publiquement
4. Seul le port Velocity doit être accessible de l'extérieur
### Étape 3 : Modern Forwarding
Le modern forwarding de Velocity chiffre les informations des joueurs, empêchant le spoofing d'IP.
**Vérification** :
Dans `velocity.toml` :
```toml
[forwarding]
mode = "modern"
secret = "votre-cle-secrete"
```
Dans Paper `paper-global.yml` :
```yaml
proxies:
velocity:
enabled: true
secret: "votre-cle-secrete"
```
**Les clés doivent correspondre exactement !**
## Partie 7 : Connexion et Tests
### Étape 1 : Démarrage des Serveurs
1. **Démarrez tous les serveurs backend en premier** :
- Lobby
- Survie
- Créatif
- etc.
2. **Attendez qu'ils soient complètement démarrés**
3. **Démarrez Velocity en dernier**
### Étape 2 : Vérification dans la Console
Console Velocity devrait afficher :
```
[INFO] Listening on /0.0.0.0:25577
[INFO] Done! Velocity is ready to accept connections.
```
### Étape 3 : Connexion au Réseau
1. Lancez Minecraft
2. Ajoutez le serveur avec :
- **Adresse** : `votre-ip-vps:25565` (ou le port configuré)
- **Nom** : Nom de votre réseau
3. Connectez-vous
4. Vous devriez arriver sur le serveur par défaut (lobby)
### Étape 4 : Test de Navigation
Testez la commande `/server` :
```
/server
```
Vous devriez voir la liste de tous vos serveurs.
Testez la connexion à un autre serveur :
```
/server survival
```
Vous devriez être téléporté sur le serveur survie sans déconnexion.
## Partie 8 : Dépannage
### Problème : "Can't connect to server"
**Causes possibles** :
1. **Velocity n'est pas démarré**
- Solution : Vérifiez la console Velocity
2. **Port incorrect**
- Solution : Vérifiez les allocations dans Wisp
3. **Pare-feu bloque la connexion**
- Solution : Vérifiez les règles de pare-feu
### Problème : "Connexion mais kick immédiat"
**Causes possibles** :
1. **Aucun serveur backend disponible**
- Solution : Vérifiez que les serveurs backend sont démarrés
- Vérifiez les logs de Velocity pour voir s'il peut se connecter aux backend
2. **Mauvaise configuration de forwarding**
- Solution : Vérifiez que les clés secrètes correspondent
- Vérifiez que `online-mode=false` sur les backend
3. **Ports incorrects dans velocity.toml**
- Solution : Vérifiez que les ports correspondent à ceux des serveurs backend
### Problème : "Can't connect to backend server"
**Solutions** :
1. Vérifiez que le serveur backend est démarré :
- Dans Wisp, allez sur le serveur backend
- Vérifiez la console
2. Vérifiez les ports dans `velocity.toml` :
```toml
lobby = "127.0.0.1:25566"
```
Le port doit correspondre au `server-port` dans `server.properties` du backend
3. Vérifiez les logs de Velocity :
```
[ERROR] Unable to connect to server lobby
```
### Problème : "Player UUID mismatch"
**Cause** : Configuration de forwarding incorrecte
**Solutions** :
1. Vérifiez que `online-mode=false` sur tous les backend
2. Vérifiez la configuration du forwarding :
- Velocity : `velocity.toml` → `[forwarding]` → `secret`
- Paper : `paper-global.yml` → `proxies.velocity.secret`
3. Les secrets doivent être **identiques**
4. Redémarrez tous les serveurs après modification
### Problème : "Can't use /server command"
**Cause** : Permissions manquantes
**Solutions** :
1. Installez LuckPerms
2. Donnez la permission :
```
/lp user permission set velocity.command.server true
```
3. Ou donnez à tous les joueurs :
```
/lp group default permission set velocity.command.server true
```
## Partie 9 : Optimisation et Performance
### Configuration JVM pour Velocity
Dans Wisp, pour votre serveur Velocity :
1. Allez dans **Startup**
2. Modifiez les arguments JVM :
```
-Xms512M -Xmx1G -XX:+UseG1GC -XX:G1HeapRegionSize=4M -XX:+UnlockExperimentalVMOptions -XX:+ParallelRefProcEnabled -XX:+AlwaysPreTouch
```
### Configuration des Serveurs Backend
Pour chaque serveur backend Paper :
**Dans paper-global.yml** :
```yaml
# Optimisations réseau
network:
kick-on-oversized-packet-exception: true
# Optimisations chunk
chunk-loading:
min-load-radius: 2
max-concurrent-sends: 2
# Désactiver les features inutiles en réseau
feature-seeds:
generate-random-seeds-for-all: true
```
### Monitoring des Performances
Utilisez ces plugins pour surveiller :
1. **Spark** : Profiling et monitoring
- https://spark.lucko.me/
2. **Tab** : Affichage des TPS et performances
- https://github.com/NEZNAMY/TAB
## Partie 10 : Configuration Avancée
### Base de Données Partagée
Pour partager les données entre serveurs (inventaires, économie, etc.) :
#### MySQL Configuration
1. Obtenez un serveur MySQL (VeryCloud peut fournir)
2. Créez une base de données
3. Configurez chaque plugin pour utiliser MySQL :
**LuckPerms** :
```yaml
storage-method: mysql
data:
address: mysql.example.com:3306
database: luckperms
username: luckperms_user
password: password
```
### Système de Lobby Multiple
Pour avoir plusieurs lobbies avec load balancing :
**Dans velocity.toml** :
```toml
[servers]
lobby1 = "127.0.0.1:25566"
lobby2 = "127.0.0.1:25570"
lobby3 = "127.0.0.1:25571"
survival = "127.0.0.1:25567"
try = [
"lobby1",
"lobby2",
"lobby3"
]
```
Velocity répartira automatiquement les joueurs entre les lobbies disponibles.
### Messages de Maintenance
Pour afficher un message personnalisé pendant la maintenance :
**Dans velocity.toml** :
```toml
[forced-hosts]
"maintenance.votreserveur.com" = [
"maintenance"
]
[servers]
maintenance = "127.0.0.1:25580"
```
Créez un serveur "maintenance" qui affiche un message.
## Partie 11 : Plugins Backend Compatibles
### Plugins de Synchronisation
Ces plugins fonctionnent bien avec Velocity :
1. **MySQLPlayerDataBridge** - Sync inventaires
2. **RedisBungee** - Synchronisation avec Redis
3. **SkinsRestorer** - Sync des skins
4. **BungeeGuard** - Sécurité supplémentaire
5. **MultiChat** - Chat global entre serveurs
### Installation de Plugins sur Backend
Pour les plugins qui doivent communiquer via Velocity :
1. Installez le plugin sur **tous les serveurs backend**
2. Configurez une base de données MySQL partagée
3. Redémarrez tous les serveurs
## Partie 12 : Sauvegarde et Maintenance
### Script de Sauvegarde
Créez des sauvegardes régulières :
**Configuration Velocity** :
```bash
# Sauvegarder velocity.toml
cp velocity.toml velocity.toml.backup
```
**Via Wisp** :
1. Allez dans **Backups**
2. Créez une sauvegarde manuelle
3. Configurez des sauvegardes automatiques
### Mise à Jour de Velocity
1. **Téléchargez** la nouvelle version de Velocity
2. **Arrêtez** le serveur Velocity
3. **Remplacez** `velocity.jar` par la nouvelle version
4. **Redémarrez** le serveur
5. **Vérifiez** les logs pour les erreurs
### Maintenance Régulière
**Quotidien** :
- Vérifier les logs d'erreur
- Surveiller l'utilisation RAM/CPU
- Vérifier les connexions joueurs
**Hebdomadaire** :
- Sauvegarder les configurations
- Mettre à jour les plugins
- Nettoyer les logs anciens
**Mensuel** :
- Mettre à jour Velocity et serveurs backend
- Revoir les permissions et configurations
- Tester les sauvegardes
## Support VeryCloud
Si vous rencontrez des difficultés :
**Documentation** : [https://verycloud.fr/docs](https://verycloud.fr/docs)
**Panel Wisp** : [https://panel.verycloud.fr/](https://panel.verycloud.fr/)
**Support technique** :
- Ouvrez un ticket depuis votre espace client VeryCloud
- Contactez le support par Discord
- Consultez la base de connaissances
Lorsque vous contactez le support, fournissez :
- Nom de votre serveur Velocity
- Logs de la console (dernières 100 lignes)
- Votre fichier `velocity.toml` (masquez les secrets)
- Description détaillée du problème
## Ressources Complémentaires
### Documentation Officielle
- **Velocity Docs** : https://docs.papermc.io/velocity
- **Paper Docs** : https://docs.papermc.io/paper
- **Velocity GitHub** : https://github.com/PaperMC/Velocity
### Communauté
- **Discord PaperMC** : https://discord.gg/papermc
- **Forums Spigot** : https://www.spigotmc.org/
- **Reddit r/admincraft** : https://reddit.com/r/admincraft
### Plugins et Resources
- **Hangar** : https://hangar.papermc.io/
- **Modrinth** : https://modrinth.com/
- **SpigotMC** : https://www.spigotmc.org/resources/
## Conclusion
Votre réseau Minecraft avec Velocity est maintenant configuré et opérationnel ! Vous pouvez désormais :
- Connecter plusieurs serveurs ensemble
- Permettre aux joueurs de naviguer entre les serveurs
- Centraliser la gestion des permissions
- Améliorer la sécurité avec modern forwarding
- Scaler votre réseau facilement
**Points clés à retenir** :
- Modern forwarding est **essentiel** pour la sécurité
- Les serveurs backend doivent avoir `online-mode=false`
- Velocity doit démarrer **après** les serveurs backend
- Sauvegardez régulièrement vos configurations
- Surveillez les performances et les logs
**Bon jeu et bonne administration de votre réseau Minecraft avec VeryCloud !**