Guide d'Installation d'un Serveur Rust sur VPS Linux
Published on November 11, 2025 at 03:10 PM
Guide complet pour installer et configurer un serveur Rust dédié sur VPS Linux (Ubuntu/Debian). Ce tutoriel détaillé couvre l'installation via SteamCMD, la configuration des paramètres de jeu, l'installation d'uMod/Oxide avec plugins, la gestion via RCON, les wipes réguliers, et le service systemd pour démarrage automatique. Inclut également les sauvegardes automatiques, la surveillance des performances, la gestion multi-serveurs, le dépannage et l'optimisation.
# Guide d'Installation d'un Serveur Rust sur VPS Linux
## Introduction
Rust est un jeu de survie multijoueur populaire qui permet de créer des serveurs dédiés personnalisés. Ce guide vous accompagne dans l'installation complète d'un serveur Rust sur un VPS Linux (Ubuntu/Debian).
## Prérequis
Avant de commencer l'installation, assurez-vous que votre VPS dispose de :
- Ubuntu 20.04/22.04 LTS ou Debian 11/12
- Au moins 8 Go de RAM (16 Go recommandés pour 100+ joueurs)
- 25 Go d'espace disque disponible (40 Go recommandés)
- Processeur avec au moins 2 cœurs (4 cœurs recommandés)
- Connexion Internet stable avec bande passante suffisante
- Accès root ou sudo
- Adresse IP publique statique
## Étape 1 : Mise à Jour du Système
Connectez-vous à votre VPS via SSH et mettez à jour le système :
```bash
sudo apt update && sudo apt upgrade -y
```
Redémarrez le serveur si nécessaire :
```bash
sudo reboot
```
## Étape 2 : Installation des Dépendances
Installez les packages nécessaires :
```bash
sudo apt install -y lib32gcc-s1 lib32stdc++6 curl wget tar screen htop net-tools
```
Pour les systèmes 64 bits, installez les bibliothèques 32 bits :
```bash
sudo dpkg --add-architecture i386
sudo apt update
sudo apt install -y libc6:i386 libstdc++6:i386
```
## Étape 3 : Création de l'Utilisateur Rust
Pour des raisons de sécurité, créez un utilisateur dédié pour le serveur Rust :
```bash
sudo adduser --disabled-login --no-create-home rustserver
```
Créez le répertoire du serveur :
```bash
sudo mkdir -p /home/rustserver
sudo chown rustserver:rustserver /home/rustserver
```
## Étape 4 : Installation de SteamCMD
### Installation de SteamCMD
1. Créez un répertoire pour SteamCMD :
```bash
sudo mkdir -p /home/rustserver/steamcmd
cd /home/rustserver/steamcmd
```
2. Téléchargez SteamCMD :
```bash
sudo wget https://steamcdn-a.akamaihd.net/client/installer/steamcmd_linux.tar.gz
```
3. Extrayez l'archive :
```bash
sudo tar -xvzf steamcmd_linux.tar.gz
```
4. Supprimez l'archive :
```bash
sudo rm steamcmd_linux.tar.gz
```
5. Changez les permissions :
```bash
sudo chown -R rustserver:rustserver /home/rustserver
```
## Étape 5 : Installation du Serveur Rust
### Téléchargement des fichiers via SteamCMD
1. Créez un script d'installation :
```bash
sudo nano /home/rustserver/install_rust.sh
```
2. Ajoutez le contenu suivant :
```bash
#!/bin/bash
cd /home/rustserver/steamcmd
./steamcmd.sh +force_install_dir /home/rustserver/rust-server +login anonymous +app_update 258550 +quit
```
3. Rendez le script exécutable :
```bash
sudo chmod +x /home/rustserver/install_rust.sh
sudo chown rustserver:rustserver /home/rustserver/install_rust.sh
```
4. Exécutez le script d'installation :
```bash
sudo -u rustserver /home/rustserver/install_rust.sh
```
Le téléchargement peut prendre du temps (environ 15-20 Go). Attendez que le message "Success! App '258550' fully installed" apparaisse.
## Étape 6 : Configuration du Serveur
### Création du script de démarrage
1. Créez un script de démarrage :
```bash
sudo nano /home/rustserver/start_rust.sh
```
2. Ajoutez le contenu suivant (personnalisez selon vos besoins) :
```bash
#!/bin/bash
# Variables de configuration
IDENTITY="my-rust-server"
HOSTNAME="Mon Serveur Rust"
MAXPLAYERS=100
WORLDSIZE=4000
SEED=12345
SAVEINTERVAL=300
RCONPORT=28016
RCONPASSWORD="motdepassercon"
SERVERPORT=28015
DESCRIPTION="Bienvenue sur mon serveur Rust!"
URL="https://monsite.com"
# Démarrage du serveur
cd /home/rustserver/rust-server
./RustDedicated -batchmode \
-nographics \
+server.ip 0.0.0.0 \
+server.port ${SERVERPORT} \
+server.maxplayers ${MAXPLAYERS} \
+server.hostname "${HOSTNAME}" \
+server.identity "${IDENTITY}" \
+server.level "Procedural Map" \
+server.worldsize ${WORLDSIZE} \
+server.seed ${SEED} \
+server.saveinterval ${SAVEINTERVAL} \
+server.description "${DESCRIPTION}" \
+server.url "${URL}" \
+rcon.ip 0.0.0.0 \
+rcon.port ${RCONPORT} \
+rcon.password "${RCONPASSWORD}" \
+rcon.web 1
```
3. Rendez le script exécutable :
```bash
sudo chmod +x /home/rustserver/start_rust.sh
sudo chown rustserver:rustserver /home/rustserver/start_rust.sh
```
### Explication des paramètres importants
- **server.hostname** : Nom du serveur visible dans la liste
- **server.identity** : Nom unique pour les fichiers de sauvegarde
- **server.maxplayers** : Nombre maximum de joueurs (50-150 recommandé)
- **server.worldsize** : Taille de la carte (3000-6000, par défaut 4000)
- **server.seed** : Graine pour générer la carte (même seed = même carte)
- **server.saveinterval** : Intervalle de sauvegarde en secondes
- **server.level** : Type de carte ("Procedural Map" pour générée, ou nom de carte custom)
- **rcon.password** : Mot de passe pour l'administration à distance
- **rcon.port** : Port RCON (par défaut 28016)
### Paramètres additionnels utiles
Vous pouvez ajouter ces paramètres au script de démarrage :
```bash
+server.headerimage "URL_IMAGE_HEADER" \
+server.logoimage "URL_IMAGE_LOGO" \
+decay.scale 1.0 \
+pve.enabled false \
+server.radiation false \
+server.stability true \
+server.events true
```
## Étape 7 : Configuration du Pare-feu
Ouvrez les ports nécessaires pour Rust :
```bash
# Port principal du jeu
sudo ufw allow 28015/tcp
sudo ufw allow 28015/udp
# Port RCON
sudo ufw allow 28016/tcp
# Port Query (optionnel)
sudo ufw allow 28017/tcp
# Activez le pare-feu si ce n'est pas déjà fait
sudo ufw enable
```
Vérifiez l'état du pare-feu :
```bash
sudo ufw status
```
## Étape 8 : Création d'un Service Systemd
Pour gérer le serveur comme un service système :
1. Créez un fichier de service :
```bash
sudo nano /etc/systemd/system/rust-server.service
```
2. Ajoutez le contenu suivant :
```ini
[Unit]
Description=Rust Dedicated Server
After=network.target
[Service]
Type=simple
User=rustserver
WorkingDirectory=/home/rustserver/rust-server
ExecStart=/home/rustserver/start_rust.sh
Restart=on-failure
RestartSec=10
StandardOutput=journal
StandardError=journal
[Install]
WantedBy=multi-user.target
```
3. Rechargez systemd :
```bash
sudo systemctl daemon-reload
```
4. Activez le service au démarrage :
```bash
sudo systemctl enable rust-server
```
5. Démarrez le serveur :
```bash
sudo systemctl start rust-server
```
6. Vérifiez l'état du serveur :
```bash
sudo systemctl status rust-server
```
## Étape 9 : Gestion du Serveur
### Commandes systemd
```bash
# Démarrer le serveur
sudo systemctl start rust-server
# Arrêter le serveur
sudo systemctl stop rust-server
# Redémarrer le serveur
sudo systemctl restart rust-server
# Voir les logs en temps réel
sudo journalctl -u rust-server -f
# Voir les derniers logs
sudo journalctl -u rust-server -n 100 --no-pager
```
### Utilisation de Screen (alternative)
Si vous préférez utiliser Screen au lieu de systemd :
```bash
# Démarrer le serveur dans une session screen
sudo -u rustserver screen -dmS rust /home/rustserver/start_rust.sh
# Attacher à la session
sudo -u rustserver screen -r rust
# Détacher de la session (Ctrl+A puis D)
# Lister les sessions screen
screen -ls
# Tuer une session
screen -X -S rust quit
```
## Étape 10 : Administration via RCON
### Installation de Rusty (client RCON)
Rusty est un outil d'administration RCON pour Rust.
1. Téléchargez Rusty sur votre PC local depuis : https://github.com/Kirilligu/Rusty
2. Configurez la connexion :
- **IP** : Adresse IP de votre VPS
- **Port** : 28016 (ou votre port RCON)
- **Mot de passe** : Votre mot de passe RCON
### Commandes RCON utiles
Via Rusty ou en console serveur, vous pouvez utiliser ces commandes :
```bash
# Informations serveur
server.info
# Voir les joueurs connectés
playerlist
# Kicker un joueur
kick "nom_joueur" "raison"
# Bannir un joueur
banid "steamid" "raison"
# Débannir un joueur
removeid "steamid"
# Sauvegarder le serveur
server.save
# Téléporter vers un joueur
teleportpos x y z
# Donner des items
inventory.give "nom_joueur" "item" quantité
# Changer l'heure
env.time 12
# Activer/désactiver PvE
server.pve true/false
# Message global
say "Votre message"
```
## Étape 11 : Configuration Avancée
### Fichiers de configuration
Les fichiers de configuration se trouvent dans :
```bash
/home/rustserver/rust-server/server/my-rust-server/cfg
```
### server.cfg
Créez un fichier de configuration personnalisé :
```bash
sudo nano /home/rustserver/rust-server/server/my-rust-server/cfg/server.cfg
```
Exemple de configuration :
```
// Paramètres généraux
server.hostname "Mon Serveur Rust Personnalisé"
server.description "Serveur PvP/PvE avec modifications"
server.url "https://discord.gg/monserveur"
server.headerimage "https://i.imgur.com/example.jpg"
server.logoimage "https://i.imgur.com/logo.jpg"
// Paramètres de jeu
server.maxplayers 150
server.worldsize 4500
server.seed 987654
// Taux de récolte
gather.rate dispenser * 2.0
gather.rate pickup * 2.0
// Craft plus rapide
crafting.instant true
// Recycleur plus rapide
recycler.efficiency 2.0
// Désactivation de certains événements
bradley.enabled false
helicopter.enabled false
// Paramètres de decay (dégradation)
decay.scale 0.5
decay.upkeep false
// Autres paramètres
server.stability true
server.radiation false
server.events true
```
Chargez ce fichier au démarrage en modifiant votre script :
```bash
./RustDedicated -batchmode +server.cfg server.cfg ...
```
### users.cfg
Pour configurer les administrateurs :
```bash
sudo nano /home/rustserver/rust-server/server/my-rust-server/cfg/users.cfg
```
Ajoutez vos admins avec leur SteamID64 :
```
ownerid 76561198012345678 "NomAdmin" "Raison"
moderatorid 76561198087654321 "NomModo" "Raison"
```
Trouvez votre SteamID64 sur : https://steamid.io/
### Bans configuration
```bash
sudo nano /home/rustserver/rust-server/server/my-rust-server/cfg/bans.cfg
```
Format :
```
banid 76561198012345678 "Raison du ban"
```
## Étape 12 : Installation d'Oxide/uMod
Oxide (maintenant uMod) est un framework de modding pour Rust qui permet d'installer des plugins.
### Installation d'uMod
1. Téléchargez la dernière version :
```bash
cd /home/rustserver
sudo wget https://umod.org/games/rust/download
sudo mv download oxide-rust.zip
```
2. Installez unzip si nécessaire :
```bash
sudo apt install unzip -y
```
3. Extrayez dans le dossier du serveur :
```bash
sudo unzip oxide-rust.zip -d /home/rustserver/rust-server/
sudo rm oxide-rust.zip
```
4. Changez les permissions :
```bash
sudo chown -R rustserver:rustserver /home/rustserver/rust-server/
```
5. Redémarrez le serveur :
```bash
sudo systemctl restart rust-server
```
### Installation de plugins
Les plugins se placent dans :
```bash
/home/rustserver/rust-server/oxide/plugins/
```
Plugins populaires :
- **Kits** : Système de kits de démarrage
- **StackSizeController** : Modifier la taille des stacks
- **RemoverTool** : Outil pour supprimer des structures
- **VoteDay** : Vote pour changer l'heure
- **Economics** : Système d'économie
- **BetterChat** : Amélioration du chat
Téléchargez des plugins depuis : https://umod.org/plugins
Exemple d'installation d'un plugin :
```bash
cd /home/rustserver/rust-server/oxide/plugins/
sudo wget https://umod.org/plugins/Kits.cs
sudo chown rustserver:rustserver Kits.cs
```
Le plugin sera chargé automatiquement au prochain démarrage ou via commande RCON :
```
oxide.reload Kits
```
### Configuration des plugins
Les configurations se trouvent dans :
```bash
/home/rustserver/rust-server/oxide/config/
```
Chaque plugin a son propre fichier JSON de configuration.
## Étape 13 : Mise à Jour du Serveur
### Mise à jour manuelle
1. Arrêtez le serveur :
```bash
sudo systemctl stop rust-server
```
2. Exécutez le script de mise à jour :
```bash
sudo -u rustserver /home/rustserver/install_rust.sh
```
3. Redémarrez le serveur :
```bash
sudo systemctl start rust-server
```
### Script de mise à jour automatique
Créez un script pour automatiser :
```bash
sudo nano /home/rustserver/update_rust.sh
```
Contenu :
```bash
#!/bin/bash
echo "Arrêt du serveur Rust..."
systemctl stop rust-server
echo "Mise à jour du serveur..."
cd /home/rustserver/steamcmd
./steamcmd.sh +force_install_dir /home/rustserver/rust-server +login anonymous +app_update 258550 validate +quit
echo "Redémarrage du serveur..."
systemctl start rust-server
echo "Mise à jour terminée!"
```
Rendez-le exécutable :
```bash
sudo chmod +x /home/rustserver/update_rust.sh
```
### Mise à jour automatique via cron
Pour vérifier les mises à jour tous les jours à 4h du matin :
```bash
sudo crontab -e
```
Ajoutez :
```
0 4 * * * /home/rustserver/update_rust.sh
```
## Étape 14 : Sauvegardes
### Script de sauvegarde
Créez un script de sauvegarde :
```bash
sudo nano /home/rustserver/backup_rust.sh
```
Contenu :
```bash
#!/bin/bash
BACKUP_DIR="/backup/rust"
DATE=$(date +%Y%m%d_%H%M%S)
SERVER_DIR="/home/rustserver/rust-server/server/my-rust-server"
mkdir -p $BACKUP_DIR
# Sauvegarde des données du serveur
echo "Création de la sauvegarde..."
tar -czf $BACKUP_DIR/rust_backup_$DATE.tar.gz $SERVER_DIR
# Garder seulement les 7 dernières sauvegardes
find $BACKUP_DIR -name "rust_backup_*.tar.gz" -mtime +7 -delete
echo "Sauvegarde terminée: rust_backup_$DATE.tar.gz"
```
Rendez-le exécutable :
```bash
sudo chmod +x /home/rustserver/backup_rust.sh
```
### Sauvegarde automatique
Ajoutez au crontab pour une sauvegarde quotidienne à 3h :
```bash
sudo crontab -e
```
Ajoutez :
```
0 3 * * * /home/rustserver/backup_rust.sh
```
### Restauration d'une sauvegarde
```bash
# Arrêtez le serveur
sudo systemctl stop rust-server
# Extrayez la sauvegarde
sudo tar -xzf /backup/rust/rust_backup_YYYYMMDD_HHMMSS.tar.gz -C /
# Redémarrez le serveur
sudo systemctl start rust-server
```
## Étape 15 : Wipes (Réinitialisations)
Rust nécessite des wipes réguliers. Voici comment effectuer différents types de wipes :
### Wipe de la carte uniquement
```bash
# Arrêtez le serveur
sudo systemctl stop rust-server
# Supprimez les fichiers de carte
sudo rm -rf /home/rustserver/rust-server/server/my-rust-server/*.map
sudo rm -rf /home/rustserver/rust-server/server/my-rust-server/*.sav*
# Redémarrez le serveur
sudo systemctl start rust-server
```
### Wipe complet (carte + blueprints)
```bash
# Arrêtez le serveur
sudo systemctl stop rust-server
# Supprimez tous les fichiers du serveur
sudo rm -rf /home/rustserver/rust-server/server/my-rust-server/*
# Redémarrez le serveur
sudo systemctl start rust-server
```
### Wipe uniquement des blueprints
```bash
# Arrêtez le serveur
sudo systemctl stop rust-server
# Supprimez les fichiers de blueprints
sudo rm -rf /home/rustserver/rust-server/server/my-rust-server/*.db
# Redémarrez le serveur
sudo systemctl start rust-server
```
### Changement de seed après wipe
Modifiez le seed dans votre script de démarrage pour générer une nouvelle carte :
```bash
sudo nano /home/rustserver/start_rust.sh
```
Changez la valeur de SEED puis redémarrez.
## Étape 16 : Surveillance et Optimisation
### Surveillance des ressources
Installez htop pour surveiller en temps réel :
```bash
htop
```
Vérifiez l'utilisation :
- CPU : devrait rester sous 80%
- RAM : Rust utilise 4-8 Go selon le nombre de joueurs
- Réseau : surveillez la bande passante
### Optimisation des performances
Ajoutez ces paramètres à votre script de démarrage pour de meilleures performances :
```bash
./RustDedicated -batchmode \
-nographics \
-logfile output.txt \
+server.tickrate 30 \
+server.entityrate 15 \
...
```
### Logs du serveur
Les logs se trouvent dans :
```bash
/home/rustserver/rust-server/output.txt
```
Consultez les logs en temps réel :
```bash
tail -f /home/rustserver/rust-server/output.txt
```
### Nettoyage automatique des logs
Pour éviter que les logs ne prennent trop d'espace :
```bash
sudo nano /home/rustserver/clean_logs.sh
```
Contenu :
```bash
#!/bin/bash
LOG_FILE="/home/rustserver/rust-server/output.txt"
if [ -f "$LOG_FILE" ]; then
# Garder seulement les 1000 dernières lignes
tail -n 1000 "$LOG_FILE" > "$LOG_FILE.tmp"
mv "$LOG_FILE.tmp" "$LOG_FILE"
fi
```
Automatisez avec cron (tous les jours) :
```
0 2 * * * /home/rustserver/clean_logs.sh
```
## Étape 17 : Connexion au Serveur
### Pour les joueurs
Les joueurs peuvent se connecter de plusieurs façons :
**1. Via la console du jeu (F1)** :
```
client.connect IP:PORT
```
Exemple :
```
client.connect 123.45.67.89:28015
```
**2. Via la liste des serveurs** :
- Lancez Rust
- Allez dans "Jouer"
- Cherchez le nom de votre serveur dans la liste
- Cliquez pour rejoindre
**3. Via les favoris** :
- Appuyez sur F1 dans le jeu
- Tapez : `client.connect IP:PORT`
- Ou ajoutez le serveur aux favoris
### Informations à communiquer
Donnez à vos joueurs :
- **IP** : Adresse IP publique de votre VPS
- **Port** : 28015 (ou celui configuré)
- **Nom du serveur** : Pour recherche
- **Discord/Site web** : Pour la communauté
## Dépannage
### Le serveur ne démarre pas
**Vérifications** :
1. Vérifiez les logs :
```bash
sudo journalctl -u rust-server -n 50
```
2. Vérifiez les permissions :
```bash
sudo chown -R rustserver:rustserver /home/rustserver/
```
3. Vérifiez que les ports ne sont pas utilisés :
```bash
sudo netstat -tlnp | grep 28015
```
4. Vérifiez l'espace disque :
```bash
df -h
```
### Erreur "Cannot allocate memory"
Si vous manquez de RAM :
1. Créez un fichier swap :
```bash
sudo fallocate -l 4G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile
```
2. Rendez-le permanent :
```bash
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab
```
### Les joueurs ne peuvent pas se connecter
**Vérifications** :
1. Vérifiez que le pare-feu autorise les connexions :
```bash
sudo ufw status
```
2. Vérifiez que le serveur écoute sur le bon port :
```bash
sudo netstat -tlnp | grep RustDedicated
```
3. Vérifiez les logs pour les erreurs :
```bash
tail -f /home/rustserver/rust-server/output.txt
```
4. Testez la connectivité depuis l'extérieur :
```bash
telnet VOTRE_IP 28015
```
### Crash du serveur
**Solutions** :
1. Vérifiez les logs de crash :
```bash
tail -100 /home/rustserver/rust-server/output.txt
```
2. Augmentez la RAM disponible ou ajoutez du swap
3. Vérifiez la compatibilité des plugins Oxide
4. Réduisez la taille de la carte ou le nombre de joueurs
### Performances faibles (lag)
**Solutions** :
1. Réduisez le nombre maximum de joueurs
2. Diminuez la taille de la carte (worldsize)
3. Augmentez les ressources du VPS
4. Optimisez les paramètres de tickrate
5. Désactivez les plugins non essentiels
6. Nettoyez régulièrement les entités abandonnées
```bash
# Via RCON
entid delete
```
## Configuration Multi-Serveurs
Pour héberger plusieurs serveurs Rust sur le même VPS :
1. Copiez le dossier du serveur :
```bash
sudo cp -r /home/rustserver/rust-server /home/rustserver/rust-server2
```
2. Créez un nouveau script de démarrage avec des ports différents :
```bash
sudo nano /home/rustserver/start_rust2.sh
```
Changez les ports :
- server.port: 28025
- rcon.port: 28026
3. Créez un nouveau service systemd :
```bash
sudo nano /etc/systemd/system/rust-server2.service
```
4. Ouvrez les nouveaux ports dans le pare-feu :
```bash
sudo ufw allow 28025/tcp
sudo ufw allow 28025/udp
sudo ufw allow 28026/tcp
```
## Ressources Supplémentaires
### Sites utiles
- **Site officiel Rust** : https://rust.facepunch.com/
- **Wiki Rust** : https://rust.fandom.com/wiki/Rust_Wiki
- **uMod (Oxide)** : https://umod.org/
- **Plugins uMod** : https://umod.org/plugins
- **RustMaps** : https://rustmaps.com/ (générateur et visualisateur de cartes)
- **RCON Tools** : https://www.rustadmin.com/
### Communauté
- Reddit : r/playrust et r/playrustadmin
- Discord officiel Rust
- Forums Facepunch
### Documentation officielle
- Documentation serveur : https://wiki.facepunch.com/rust/
- Variables serveur : https://rust.fandom.com/wiki/Server_Variables
## Conclusion
Votre serveur Rust est maintenant installé et configuré sur votre VPS Linux ! Vous pouvez désormais :
- Héberger votre propre communauté Rust
- Personnaliser l'expérience de jeu avec des plugins
- Gérer les joueurs via RCON
- Automatiser les mises à jour et sauvegardes
**Points importants à retenir** :
- Faites des sauvegardes régulières avant les wipes
- Maintenez le serveur à jour après chaque patch Rust
- Surveillez les performances et les logs
- Écoutez les retours de votre communauté
- Planifiez les wipes en avance et communiquez-les
Bon jeu et bonne administration !