Comment créer son serveur Rust
Ce guide vous explique comment installer et configurer un serveur dédié Rust sur votre VPS ou serveur dédié Linux, avec la possibilité d'ajouter des plugins grâce à Oxide (uMod).
Commander un serveur
Pour héberger votre serveur Rust, HostMyServers propose plusieurs offres adaptées au gaming. Rust est un jeu très gourmand : privilégiez un processeur rapide et beaucoup de RAM (8 Go au minimum, davantage pour un serveur public).
- VPS Performance - Ressources dédiées et processeurs rapides, idéal pour Rust
- VPS NVMe - Pour un petit serveur ou un serveur de test
- Serveurs dédiés Eco - Pour les serveurs avec beaucoup de joueurs
- Serveurs dédiés Performance - Performance maximale
Prérequis
Les ressources indiquées ci-dessous correspondent aux besoins du serveur et ne tiennent pas compte des ressources déjà utilisées par le système d'exploitation, les logiciels installés ou les autres services présents sur la machine. Comptez 200 Mbps pour 100 joueurs en tickrate 30 (estimation communautaire). La configuration requise est basée sur un serveur vanilla (sans extensions ni plugins).
- Accès SSH root ou utilisateur avec sudo
- Système Linux 64 bits (Debian 12/13 ou Ubuntu 22.04/24.04 recommandé)
- Pare-feu actif : nftables (recommandé), iptables ou ufw (n'utilisez qu'un seul outil de pare-feu à la fois)
- Minimum 8 Go de RAM (32 Go recommandés)
- Environ 20 Go d'espace disque libre (SSD NVMe recommandé)
- Ports 28015 UDP, 28017 UDP et 28082 TCP accessibles, et port 28016 TCP (RCON) accessible depuis votre adresse IP fixe uniquement
Configuration requise
| Composant | Minimum | Recommandé |
|---|---|---|
| RAM | 8 Go | 32 Go et plus |
| CPU | 2 cœurs | 4 cœurs ou plus, fréquence élevée |
| Stockage | 20 Go SSD | 40 Go SSD NVMe |
| Réseau | 300 Mbps | 1 Gbps |
Le moteur de Rust dépend surtout des performances d'un seul cœur : un processeur à fréquence élevée est plus important qu'un grand nombre de cœurs.
Mise à jour du système
sudo apt update && sudo apt upgrade -y
Installation des dépendances
Installez les paquets nécessaires :
sudo apt install -y wget tar unzip screen lib32gcc-s1
Création d'un utilisateur dédié
Pour des raisons de sécurité, créez un utilisateur dédié :
sudo adduser --disabled-password --gecos "" rust
Ports utilisés
| Port | Protocole | Utilisation |
|---|---|---|
| 28015 | UDP | Jeu |
| 28017 | UDP | Requêtes (liste des serveurs) |
| 28016 | TCP | RCON (administration à distance), à limiter à vos adresses IP |
| 28082 | TCP | Rust+ (application mobile) |
Configuration du pare-feu
Ouvrez les ports nécessaires. Le port RCON (28016 en TCP) doit être limité à votre adresse IP fixe : remplacez VOTRE_IP.
Avec UFW
sudo ufw allow 28015/udp
sudo ufw allow 28017/udp
sudo ufw allow from VOTRE_IP to any port 28016 proto tcp
sudo ufw allow 28082/tcp
sudo ufw reload
Avec iptables
sudo iptables -A INPUT -p udp --dport 28015 -j ACCEPT
sudo iptables -A INPUT -p udp --dport 28017 -j ACCEPT
sudo iptables -A INPUT -p tcp -s VOTRE_IP --dport 28016 -j ACCEPT
sudo iptables -A INPUT -p tcp --dport 28082 -j ACCEPT
sudo iptables-save | sudo tee /etc/iptables/rules.v4
La sauvegarde des règles au redémarrage nécessite le paquet iptables-persistent.
Avec nftables
Ces commandes utilisent la table inet filter et la chaîne input, présentes par défaut dans /etc/nftables.conf sous Debian.
sudo nft add rule inet filter input udp dport 28015 accept
sudo nft add rule inet filter input udp dport 28017 accept
sudo nft add rule inet filter input ip saddr VOTRE_IP tcp dport 28016 accept
sudo nft add rule inet filter input tcp dport 28082 accept
(echo "flush ruleset"; sudo nft list ruleset) | sudo tee /etc/nftables.conf
Le port RCON (28016) permet d'administrer le serveur : ne l'ouvrez jamais à tout le monde. Sans adresse IP fixe, n'ouvrez pas ce port et passez par un tunnel SSH.
Installation de SteamCMD
Connectez-vous en tant qu'utilisateur rust :
sudo -u rust bash
cd ~
Créez les répertoires et téléchargez SteamCMD :
mkdir -p ~/steamcmd ~/rust-server
cd ~/steamcmd
wget https://steamcdn-a.akamaihd.net/client/installer/steamcmd_linux.tar.gz
tar -xzf steamcmd_linux.tar.gz
Téléchargement du serveur Rust
Lancez l'installation du serveur (identifiant d'application 258550) :
./steamcmd.sh +force_install_dir /home/rust/rust-server +login anonymous +app_update 258550 validate +quit
Si l'installation s'arrête avec une erreur, relancez simplement la même commande : SteamCMD reprend où il s'est arrêté.
À la fin, le message Success! App '258550' fully installed. s'affiche.
Script de lancement
Le script de lancement dépend du type de map. Choisissez l'une des deux versions ci-dessous.
Map générée (par défaut)
Créez le script de lancement :
nano ~/rust-server/start.sh
#!/bin/bash
cd /home/rust/rust-server
export LD_LIBRARY_PATH="/home/rust/rust-server/RustDedicated_Data/Plugins/x86_64:$LD_LIBRARY_PATH"
exec ./RustDedicated -batchmode \
+server.ip 0.0.0.0 \
+server.port 28015 \
+server.queryport 28017 \
+server.identity "server1" \
+server.level "Procedural Map" \
+server.seed 12345 \
+server.worldsize 3500 \
+server.maxplayers 100 \
+server.hostname "Mon Serveur Rust" \
+server.description "Bienvenue sur mon serveur Rust" \
+server.saveinterval 300 \
+rcon.port 28016 \
+rcon.password "ChangezMoi" \
+rcon.web 1 \
+app.port 28082
Map personnalisée
Pour utiliser une map personnalisée hébergée en ligne, remplacez les paramètres de génération de la map par +server.levelurl :
nano ~/rust-server/start.sh
#!/bin/bash
cd /home/rust/rust-server
export LD_LIBRARY_PATH="/home/rust/rust-server/RustDedicated_Data/Plugins/x86_64:$LD_LIBRARY_PATH"
exec ./RustDedicated -batchmode \
+server.ip 0.0.0.0 \
+server.port 28015 \
+server.queryport 28017 \
+server.identity "server1" \
+server.levelurl "https://votre_domaine.fr/ma_map.map" \
+server.maxplayers 100 \
+server.hostname "Mon Serveur Rust" \
+server.description "Bienvenue sur mon serveur Rust" \
+server.saveinterval 300 \
+rcon.port 28016 \
+rcon.password "ChangezMoi" \
+rcon.web 1 \
+app.port 28082
Rendre le script exécutable
Quelle que soit la version choisie, rendez le script exécutable :
chmod +x ~/rust-server/start.sh
Choisissez un mot de passe rcon.password long et unique. Toute personne qui le connaît peut administrer votre serveur.
Paramètres principaux
| Paramètre | Description |
|---|---|
server.identity | Nom du dossier de sauvegarde du serveur (dans server/) |
server.level | Type de map (Procedural Map pour une map générée) |
server.seed | Graine de génération de la map |
server.worldsize | Taille de la map (de 1000 à 6000) |
server.levelurl | Adresse de téléchargement d'une map personnalisée (si défini, server.worldsize et server.seed doivent être supprimés) |
server.maxplayers | Nombre maximum de joueurs |
server.hostname | Nom public du serveur |
server.description | Description affichée dans la liste des serveurs |
server.saveinterval | Intervalle de sauvegarde automatique (secondes) |
rcon.port | Port du RCON |
rcon.password | Mot de passe du RCON |
rcon.web | 1 = RCON WebSocket (utilisé par les outils d'administration) |
app.port | Port de Rust+ |
Au premier démarrage, la génération de la map prend plusieurs minutes. Le serveur est prêt quand les logs affichent Server startup complete.
Premier lancement
~/rust-server/start.sh
Pour arrêter le serveur, utilisez Ctrl+C ou la commande quit depuis le RCON.
Installation d'Oxide (uMod)
Oxide permet d'ajouter des plugins à votre serveur. Arrêtez le serveur, puis :
cd ~/rust-server
wget https://github.com/OxideMod/Oxide.Rust/releases/latest/download/Oxide.Rust-linux.zip
unzip -o Oxide.Rust-linux.zip
Au prochain démarrage, le dossier oxide/ est créé. Les plugins se placent dans oxide/plugins/.
Chaque mise à jour de Rust écrase les fichiers d'Oxide. Après chaque mise à jour du serveur, réinstallez Oxide avec la commande unzip -o ci-dessus.
Configuration des tailles de serveur
Mémoire recommandée
| Taille serveur | Joueurs | Taille de map | RAM recommandée |
|---|---|---|---|
| Petit | 1-50 | 2500-3000 | 8 Go |
| Moyen | 50-100 | 3500 | 12-16 Go |
| Grand | 100-200 | 4000 et plus | 16-32 Go |
Ces valeurs sont indicatives : la consommation réelle augmente avec le nombre de plugins et la durée du wipe.
Structure des fichiers
| Chemin | Description |
|---|---|
RustDedicated | Exécutable du serveur |
server/server1/ | Données du serveur (map, sauvegardes, configuration) |
server/server1/cfg/server.cfg | Configuration du serveur |
oxide/plugins/ | Plugins Oxide |
oxide/config/ | Configuration des plugins |
oxide/data/ | Données des plugins |
oxide/logs/ | Journaux d'Oxide |
Ajouter des émojis personnalisés
Créez le dossier serveremoji dans le dossier du serveur (le nom server1 correspond à server.identity) :
mkdir -p /home/rust/rust-server/server/server1/serveremoji
Puis déposez-y vos images.
Prérequis des images
- L'image ne doit pas dépasser 256x256 pixels.
- Format .jpg ou .png uniquement (les PNG 8 ou 16 bits ne fonctionnent pas).
- Le poids de l'image doit être inférieur à 250 Ko.
- Le nom du fichier devient le nom de l'émoji :
poop.pngs'utilise avec:poop:.
Les émojis peuvent être actualisés avec la commande suivante, à exécuter via le RCON :
server.resetserveremoji
Les joueurs doivent se reconnecter pour voir les nouveaux émojis.
Facepunch peut retirer de la liste des serveurs ceux qui utilisent des émojis offensants ou inappropriés.
Configuration en tant que service systemd
Créer le fichier de service
Quittez la session de l'utilisateur rust (exit) pour revenir à votre compte administrateur, puis créez le fichier de service :
sudo nano /etc/systemd/system/rust.service
Contenu du fichier :
[Unit]
Description=Rust Dedicated Server
After=network.target
[Service]
Type=simple
User=rust
Group=rust
WorkingDirectory=/home/rust/rust-server
ExecStart=/home/rust/rust-server/start.sh
Restart=on-failure
RestartSec=20
LimitNOFILE=100000
[Install]
WantedBy=multi-user.target
Activer et démarrer le service
sudo systemctl daemon-reload
sudo systemctl enable rust.service
sudo systemctl start rust.service
Commandes de gestion
# Vérifier le statut
sudo systemctl status rust.service
# Arrêter le serveur
sudo systemctl stop rust.service
# Redémarrer le serveur
sudo systemctl restart rust.service
# Voir les logs
sudo journalctl -u rust.service -f
Avant d'arrêter ou de redémarrer le serveur, envoyez la commande server.save via le RCON pour être sûr que la progression des joueurs est enregistrée.
Lancement avec screen (alternative)
Si le service systemd est démarré, arrêtez-le avant (sudo systemctl stop rust.service) : deux serveurs ne peuvent pas utiliser les mêmes ports.
sudo -u rust bash
screen -S rust
~/rust-server/start.sh
Pour détacher : Ctrl+A puis D
Pour revenir : screen -r rust
Lancer en arrière-plan avec un journal
sudo -u rust bash
cd ~/rust-server
screen -AdmSL rust ./start.sh
| Option | Description |
|---|---|
-A | Adapte la fenêtre à la taille du terminal |
-d -m | Démarre la session détachée, en arrière-plan |
-S rust | Nom de la session |
-L | Enregistre la sortie du serveur dans un fichier journal |
Le fichier screenlog.0 est créé dans le dossier où la commande est lancée (~/rust-server) et contient toute la sortie côté serveur. Pour le suivre en direct :
tail -f ~/rust-server/screenlog.0
En cas d'erreur au démarrage, c'est le premier fichier à consulter. Pour revenir à la console du serveur : screen -r rust
Le fichier screenlog.0 grossit à chaque lancement. Pensez à le purger ou à le supprimer régulièrement.
Mise à jour du serveur
Arrêter le serveur
sudo systemctl stop rust.service
Télécharger la nouvelle version
sudo -u rust bash
cd ~/steamcmd
./steamcmd.sh +force_install_dir /home/rust/rust-server +login anonymous +app_update 258550 validate +quit
Mettre à jour / réinstaller Oxide
Si vous utilisez Oxide, réinstallez-le (toujours avec l'utilisateur rust), puis quittez la session :
cd ~/rust-server
wget -O Oxide.Rust-linux.zip https://github.com/OxideMod/Oxide.Rust/releases/latest/download/Oxide.Rust-linux.zip
unzip -o Oxide.Rust-linux.zip
exit
Sans Oxide, tapez simplement exit pour quitter la session de l'utilisateur rust.
Redémarrer le serveur
sudo systemctl start rust.service
Wipe du serveur
Un wipe remet la map à zéro. Arrêtez le serveur, puis supprimez les fichiers de la map avec l'utilisateur rust :
sudo systemctl stop rust.service
sudo -u rust bash
cd ~/rust-server/server/server1
rm -f *.*.map *.*.sav*
Pour un wipe complet incluant les blueprints des joueurs, supprimez également :
rm -f clans.*.db
rm -f player.blueprints*.db
rm -f player.deaths*.db
rm -f player.identities*.db
rm -f player.states*.db
rm -f player.tokens*
rm -f relationship*
rm -f sv.files*
Quittez ensuite la session de l'utilisateur rust :
exit
| Fichier | Contenu | Effet de la suppression |
|---|---|---|
clans.*.db | Clans (membres, rôles) | Les clans disparaissent |
player.blueprints*.db | Blueprints appris par les joueurs | Remise à zéro des blueprints |
player.deaths*.db | Historique des morts | Historique effacé |
player.identities*.db | Identité du joueur (nom, apparence du personnage) | Les joueurs repartent avec un personnage neuf |
player.states*.db | État persistant des joueurs | Progression remise à zéro |
player.tokens* | Données propres à chaque joueur (marqueurs de carte, minuteurs) | Données réinitialisées |
relationship* | Relations entre joueurs | Relations effacées |
sv.files* | Fichiers stockés par le serveur (images des panneaux, peintures) | Images des panneaux et peintures supprimées |
Modifiez ensuite +server.seed dans start.sh (ou l'adresse +server.levelurl pour une map personnalisée) pour générer une nouvelle map, puis redémarrez le serveur.
Facepunch impose un wipe de map le premier jeudi de chaque mois, avec la mise à jour du jeu.
Commandes console
Ces commandes s'utilisent via le RCON (outil d'administration ou console du jeu).
| Commande | Description |
|---|---|
status | Affiche les joueurs connectés |
server.save | Sauvegarder le monde |
say <message> | Envoyer un message à tous les joueurs |
kick <joueur> | Expulser un joueur |
ban <joueur> | Bannir un joueur |
unban <steamid> | Débannir un joueur |
ownerid <steamid> "nom" "raison" | Donner les droits propriétaire |
moderatorid <steamid> "nom" "raison" | Donner les droits modérateur |
server.writecfg | Enregistrer la configuration et les droits |
oxide.plugins | Lister les plugins chargés |
oxide.reload <plugin> | Recharger un plugin |
quit | Arrêter le serveur |
Sauvegarde automatique
Script de sauvegarde
sudo nano /home/rust/backup.sh
#!/bin/bash
BACKUP_DIR="/home/rust/backups"
SERVER_DIR="/home/rust/rust-server"
DATE=$(date +%Y-%m-%d_%H-%M-%S)
mkdir -p $BACKUP_DIR
# Sauvegarde des données du serveur et d'Oxide
# (retirez les dossiers oxide/... si vous n'utilisez pas Oxide)
tar -czf $BACKUP_DIR/rust_$DATE.tar.gz -C $SERVER_DIR server/server1 oxide/data oxide/config oxide/plugins
# Supprimer les sauvegardes de plus de 7 jours
find $BACKUP_DIR -name "rust_*.tar.gz" -mtime +7 -delete
echo "Sauvegarde terminée : rust_$DATE.tar.gz"
sudo chown rust:rust /home/rust/backup.sh
sudo chmod +x /home/rust/backup.sh
Planifier la sauvegarde
sudo crontab -u rust -e
Ajoutez :
# Sauvegarde toutes les 6 heures
0 */6 * * * /home/rust/backup.sh
Connexion au serveur
Les joueurs peuvent se connecter via :
- Lancer Rust
- Ouvrir la console avec la touche
F1 - Taper :
client.connect IP_DU_SERVEUR:28015
Vous pouvez aussi ajouter le serveur dans les favoris de Steam (menu Affichage, Serveurs, onglet Favoris).
En cas de problème
Le serveur ne démarre pas
- Vérifiez les logs :
sudo journalctl -u rust.service -n 100 - Vérifiez que le script est exécutable :
ls -l ~/rust-server/start.sh - Vérifiez l'espace disque disponible :
df -h - Vérifiez la mémoire disponible :
free -h
Erreur steamclient.so
Si les logs signalent une erreur sur steamclient.so, connectez-vous en tant qu'utilisateur rust, puis créez le lien vers le fichier 64 bits de SteamCMD :
sudo -u rust bash
mkdir -p ~/.steam/sdk64
ln -sf ~/steamcmd/linux64/steamclient.so ~/.steam/sdk64/steamclient.so
exit
Les joueurs ne peuvent pas se connecter
-
Vérifiez que le port 28015 est ouvert en UDP :
sudo ufw statussudo iptables -L INPUT -n --line-numbers | grep 28015sudo nft list ruleset | grep 28015 -
Vérifiez que le serveur écoute :
ss -ulnp | grep 28015 -
Attendez la fin du démarrage (
Server startup completedans les logs)
Le serveur n'apparaît pas dans la liste
- Vérifiez que le port 28017 UDP est ouvert
- Patientez quelques minutes après le démarrage
- Vérifiez que le serveur a accès à Internet
Oxide ne charge pas les plugins
- Réinstallez Oxide après chaque mise à jour de Rust
- Vérifiez la version d'Oxide avec la commande
oxide.version - Consultez les journaux dans
oxide/logs/
Problèmes de performance
- Réduisez
server.worldsizeetserver.maxplayers - Désactivez les plugins les plus gourmands
- Augmentez la RAM de votre instance
- Planifiez un ou deux redémarrages journaliers
- En dernier recours, passez à l'offre supérieure
FAQ
Quels sont les ports à ouvrir ?
En plus des ports du serveur (voir le tableau « Ports utilisés »), ces ports sont nécessaires à Steam. Ils permettent au serveur de recevoir les réponses des serveurs Steam lorsque votre pare-feu bloque le trafic entrant par défaut :
UFW :
sudo ufw allow proto udp from any port 27000:27030 to any port 1025:65535
sudo ufw allow proto udp from any port 4380 to any port 1025:65535
sudo ufw reload
iptables :
sudo iptables -A INPUT -p udp -m udp --sport 27000:27030 --dport 1025:65535 -j ACCEPT
sudo iptables -A INPUT -p udp -m udp --sport 4380 --dport 1025:65535 -j ACCEPT
sudo iptables-save | sudo tee /etc/iptables/rules.v4
nftables :
sudo nft add rule inet filter input udp sport 27000-27030 udp dport 1025-65535 accept
sudo nft add rule inet filter input udp sport 4380 udp dport 1025-65535 accept
(echo "flush ruleset"; sudo nft list ruleset) | sudo tee /etc/nftables.conf
J'obtiens « Permission non accordée » en exécutant ./steamcmd.sh
Appliquez un chmod :
chmod +x /home/rust/steamcmd/linux32/steamcmd && chmod +x /home/rust/steamcmd/steamcmd.sh
J'ai le message « WARNING: setlocale('en_US.UTF-8') failed, using locale: 'C' »
Ce n'est pas un réel problème : seuls certains caractères internationaux peuvent mal s'afficher. Pour le corriger :
sudo locale-gen en_US.UTF-8
sudo update-locale LANG=en_US.UTF-8
Si la commande locale-gen est introuvable, installez d'abord le paquet locales avec sudo apt install -y locales.