Configurer un serveur dédié Rust sur Linux
Pour configurer un serveur dédié Rust sur Linux, nous installons ses fichiers via SteamCMD, créons une instance de serveur nommée, configurons l'accès au lecteur et l'exécutons en tant que service systemd. Nous vérifions ensuite la jonction à distance, restreignons l'accès à l'administration et effectuons une sauvegarde que nous pouvons restaurer.
Ce guide couvre le serveur de jeux Rust PC sur Serveur Ubuntu 24.04 LTS, en utilisant une configuration vanille sans plugins. Il ne nécessite pas le langage de programmation Rust, la cargaison ou la rouille.
Nous utilisons un ensemble de chemins d'accès afin que l'installation, la maintenance et la récupération fassent référence au même monde.
Choisissez la taille de la carte et les ressources du serveur
Un serveur Rust a besoin de ressources pour le processus de jeu, le système d'exploitation, les données mondiales et la maintenance. Une limite de joueur configurée ne prouve pas que l'hôte peut servir autant de joueurs actifs.
Prérequis et versions prises en charge
Commencez par :
- un frais Serveur Ubuntu 24.04 LTS Machine avec un processeur x86-64.
- Un compte administrateur avec sudo Access via SSH.
- Une adresse IP publique accessible et le contrôle des pare-feu pertinents.
- SSD ou Stockage NVMe Avec de la place pour les sauvegardes, les journaux et les sauvegardes.
- Un PC séparé avec un client Rust sous licence pour le test de jointure.
- Accédez à la console du fournisseur si une erreur de pare-feu interrompt SSH.
FacePunch répertorie 12 Go de RAM libre et 15 Go d'espace disque disponible dans ses besoins de serveur. Il note que la demande change avec la charge de travail. Traitez-les comme une référence de départ, pas une promesse de capacité ou un budget de stockage complet.
Pour cette installation, réservez plus d'espace que les logiciels n'en ont besoin. Une sauvegarde mise en scène sur le même disque consomme de l'espace supplémentaire avant de la transférer ailleurs.
Exécutez ces vérifications à partir de la session SSH de l'administrateur :
cat /etc/os-release
uname -m
free -h
df -h /home Confirmez que le système d'exploitation correspond à ce guide et que l'architecture rapporte x86_64. Dans la sortie mémoire, inspectez la mémoire disponible, pas seulement la quantité totale installée.
Choisissez une carte de départ et une limite de joueur
Nous allons utiliser les exemples de paramètres suivants :
| Réglage | Exemple de valeur | Raison |
|---|---|---|
| Identité de serveur | atal-rust-01 | Un nom stable pour les données de cette instance |
| Type de carte | Procedural Map | Un point de départ à la vanille |
| Taille de la carte | 3000 | Une configuration initiale modeste |
| La graine | 12345 | Une valeur fixe pour la configuration répétable |
| Limite des joueurs | 10 | une petite limite d'accès initiale |
| Intervalle de sauvegarde | 300 seconds | Un intervalle de départ de cinq minutes pour évaluer |
atal-rust-01Procedural Map3000 12345 10 300 secondsCe sont des choix de configuration, pas des résultats de référence. Testez avec des acteurs représentatifs et une activité mondiale avant d'augmenter la limite. Gardez la mémoire de réserve et regardez la croissance du stockage au fur et à mesure que le monde se développe.
Choisissez la région d'hébergement en utilisant les itinéraires que vos joueurs utiliseront. Notre guide pour Choisir un emplacement de serveur de jeux Explique les facteurs à comparer.
Gardez la méthode d'installation cohérente
Ce didacticiel utilise SteamCMD pour l'installation et les mises à jour, puis systemd pour le contrôle des processus.
LinuxGSM Fournit une autre route avec ses propres commandes de gestion. Si nous choisissons cet itinéraire, nous devrions suivre sa mise en page plutôt que de combiner des parties de deux méthodes d'installation.
Installer et mettre à jour avec SteamCMD
Nous utiliserons le compte d'administrateur pour les tâches du système d'exploitation et un rustserver Compte pour les fichiers de jeux. Le compte de jeu ne recevra pas d'accès sudo.
Créez le compte de jeu et installez des packages
Exécuter en tant qu'administrateur :
sudo apt update
sudo apt install -y ca-certificates curl tar nano openssl lib32gcc-s1 lib32stdc++6 ufw
sudo adduser --disabled-password --gecos "" rustserver
sudo chmod 750 /home/rustserver
sudo install -d -o rustserver -g rustserver -m 750 /home/rustserver/steamcmd /home/rustserver/rust /home/rustserver/logs Les packages de bibliothèque offrent une prise en charge d'exécution 32 bits utilisée par SteamCMD. Ils ne transforment pas l'hôte en un système 32 bits. Ubuntu fournit ces packages pour la version nommée.
Vérifiez le compte :
id rustserver Il ne doit pas appartenir au groupe sudo. Utilisez le compte administrateur chaque fois qu'une étape ultérieure a besoin de sudo.
Téléchargez Steamcmd et installez Rust
Passez au compte de jeu :
sudo -iu rustserver Exécutez ce qui suit dans ce shell :
cd /home/rustserver/steamcmd
curl -fL --retry 3 -o steamcmd_linux.tar.gz https://steamcdn-a.akamaihd.net/client/installer/steamcmd_linux.tar.gz
tar -xzf steamcmd_linux.tar.gz
chmod u+x steamcmd.sh
./steamcmd.sh +force_install_dir /home/rustserver/rust +login anonymous +app_update 258550 +quit L'ID d'application de serveur dédié de Rust est 258550. Son installation accepte un anonyme Steamcmd Connexion. Nous n'entrons pas ici de mot de passe personnel Steam.
Arrêtez si le téléchargement ou l'installation signale une erreur. Vérifiez que l'exécutable du serveur existe :
test -x /home/rustserver/rust/RustDedicated && printf 'RustDedicated is present and executable.
' Le point de contrôle attendu est un fichier exécutable et un résultat d'installation SteamCMD réussi. La présence de fichiers à elle seule ne prouve pas que le téléchargement est terminé correctement.
Créer la configuration du serveur
Toujours en tant que RustServer, créez le répertoire de configuration :
mkdir -p /home/rustserver/rust/server/atal-rust-01/cfg
nano /home/rustserver/rust/server/atal-rust-01/cfg/server.cfg Entrez :
server.hostname "Our Rust Community"
server.description "A vanilla Rust server for our community."
server.maxplayers 10
server.saveinterval 300 Enregistrez et fermez l'éditeur. Gardez le fichier lisible uniquement par le compte de jeu :
chmod 600 /home/rustserver/rust/server/atal-rust-01/cfg/server.cfg L'identité et le répertoire doivent correspondre. Dans ce guide, Atal-Rust-01 est l'identité, tandis que notre communauté Rust est le nom public. Changer un ne veut pas dire que nous devrions changer l'autre.
Ne répétez pas le même paramètre dans plusieurs fichiers de configuration. Cela rend plus difficile l'identification de la valeur utilisée par le serveur au démarrage.
Créer un secret RCON et un script de démarrage
RCON signifie console distante. Il nous permet d'envoyer des commandes d'administration au serveur.
Create a random password without placing the password itself in shell history:
umask 077
openssl rand -hex 32 > /home/rustserver/.rcon-password
chmod 600 /home/rustserver/.rcon-password
nano /home/rustserver/start-rust.sh Collez ce script :
#!/usr/bin/env bash
set -euo pipefail
cd /home/rustserver/rust
export LD_LIBRARY_PATH="$PWD:$PWD/RustDedicated_Data/Plugins/x86_64${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
rcon_secret=$(< /home/rustserver/.rcon-password)
: "${rcon_secret:?RCON password is empty}"
exec ./RustDedicated -batchmode -nographics +server.identity "atal-rust-01" +server.level "Procedural Map" +server.seed 12345 +server.worldsize 3000 +server.port 28015 +server.queryport 28017 +rcon.ip 127.0.0.1 +rcon.port 28016 +rcon.web 1 +rcon.password "$rcon_secret" +app.port 1- -logfile "/home/rustserver/logs/rust-$(date -u +%Y%m%dT%H%M%SZ).log" Enregistrez-le, puis exécutez :
chmod 700 /home/rustserver/start-rust.sh
bash -n /home/rustserver/start-rust.sh
exit Nous sommes maintenant de retour dans le shell de l'administrateur. Une vérification réussie de Bash -n n'imprime aucune sortie. Il vérifie la syntaxe du shell, pas les paramètres de rouille.
Le script définit le chemin de recherche des bibliothèques natives groupées et garde le mot de passe RCON hors du texte du script. Le processus en cours le reçoit toujours comme argument. Les comptes qui peuvent inspecter ces arguments peuvent le lire. Utilisez cette mise en page sur un hôte avec des utilisateurs de shell de confiance, limitez la sortie de diagnostic et rédigez les listes de processus avant de les partager.
L'argument inhabituel +app.port 1- suit la syntaxe documentée de FacePunch pour désactiver Rust+. Nous gardons ce service en option désactivé lors de la configuration de base.
Configurez le pare-feu avant le premier démarrage
Cet ensemble de règles concerne le nouveau hôte décrit ci-dessus. Si la machine sert déjà d'autres applications, inspectez et conservez les règles requises.
Tout d'abord, identifiez votre port SSH réel. L'exemple ci-dessous suppose le port 22. Remplacez-le si SSH utilise un autre port :
sudo ufw status numbered
sudo ufw allow 22/tcp comment 'SSH administration'
sudo ufw allow 28015/udp comment 'Rust players'
sudo ufw allow 28017/udp comment 'Rust server queries'
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw enable
sudo ufw status verbose Gardez la session SSH ouverte en cours et testez une deuxième connexion avant de continuer. N'ajoutez pas de règle d'autorisation publique pour le port TCP 28016.
Si le fournisseur dispose également d'un pare-feu de réseau, autorisez le même lecteur et interrogez le même trafic. Gardez également RCON bloqué à ce calque. Une machine derrière un routeur doit faire correspondre le transfert UDP à son adresse interne.
Exécuter le serveur avec systemd
Créez le service en tant qu'administrateur :
sudo nano /etc/systemd/system/rust.service Entrez :
[Unit]
Description=Rust Dedicated Server
Wants=network-online.target
After=network-online.target
[Service]
Type=simple
User=rustserver
Group=rustserver
WorkingDirectory=/home/rustserver/rust
ExecStart=/home/rustserver/start-rust.sh
Restart=no
TimeoutStopSec=300
UMask=0077
NoNewPrivileges=true
[Install]
WantedBy=multi-user.target Cette première configuration utilise délibérément Restart=No. Il démarre au démarrage une fois activé, mais il ne cache pas de plantage derrière des redémarrages répétés. Nous pouvons ajouter une politique de redémarrage revu après les tests initiaux et les contrôles de maintenance.
Vérifiez et démarrez-le :
sudo systemd-analyze verify /etc/systemd/system/rust.service
sudo systemctl daemon-reload
sudo systemctl enable --now rust.service
sudo systemctl status rust.service --no-pager Inspectez le journal des services :
sudo journalctl -u rust.service -n 80 --no-pager Le jeu écrit sa sortie dans un fichier horodaté séparé. Trouvez le dernier nom de fichier :
sudo -u rustserver ls -lt /home/rustserver/logs/ Lisez ce fichier, en remplaçant l'exemple de nom de fichier :
sudo -u rustserver tail -f /home/rustserver/logs/rust-YYYYMMDDTHHMMSSZ.log Le premier démarrage crée le monde. Attendez que le jeu signale la fin du démarrage, puis testez l'accès des joueurs. Un état systemd actif signifie que le processus est en cours d'exécution, et non que le jeu soit prêt.
Protéger les ports RCON et requis
Nous devons vérifier trois résultats distincts : les joueurs peuvent rejoindre, le serveur public peut être interrogé et les utilisateurs non autorisés ne peuvent pas accéder à l'administration.
Confirmez ce que fait chaque port
Voici les valeurs explicites utilisées dans notre script :
| Service | Port | Protocole | Politique d'accès |
|---|---|---|---|
| trafic de jeux | 28015 | UDP | Accès public aux lecteurs |
| Requêtes de serveurs | 28017 | UDP | Requêtes publiques pour un serveur public |
| réplique | 28016 | TCP | Loopback uniquement, atteint via SSH |
| Rouille+ | Disabled | TCP lorsqu'il est activé | Configurer séparément si nécessaire |
| ssh | 22 in this example | TCP | Accès administrateur |
Le trafic de jeux et les requêtes de serveurs utilisent des ports UDP distincts. L'ouverture du port de jeu seul ne couvre pas les requêtes serveur-navigateur.
Vérifiez les auditeurs :
sudo ss -lunp
sudo ss -ltnp Trouvez les ports UDP 28015 et 28017. Pour RCON, attendez-vous à 127.0.0.1:28016, et non à un caractère générique ou à une adresse publique. Si RCON écoute publiquement, arrêtez le service, corrigez la liaison et répétez la vérification avant de continuer.
Connectez-vous à RCON via un tunnel SSH
Exécutez cette commande sur votre propre PC, et non dans le shell SSH du serveur :
ssh -N -o ExitOnForwardFailure=yes -L 127.0.0.1:28016:127.0.0.1:28016 ADMIN_USER@SERVER_IP Remplacez admin_user et server_ip. ADD -P your_ssh_port si ssh n'utilise pas le port 22.
Gardez ce terminal ouvert. Il transmet le port TCP local 28016 de votre PC vers le port RCON local du serveur via la connexion SSH cryptée.
Utilisez un client Rust WebCon en cours d'exécution, tel que l'édition Desktop de RustAdmin. Configurer :
| Champ | Valeur |
|---|---|
| Mode RCON | WebRCON |
| Adresse | 127.0.0.1 |
| Port RCON | 28016 |
| Mot de passe | Le secret RCON généré |
WebRCON 127.0.0.1 28016 Utilisez un client local pour ce tunnel. Un service d'administration hébergé ne peut pas utiliser le port de bouclage sur votre PC. Le projet WebCon de FacePunch documente le mode d'administration basé sur WebSocket.
Récupérez le secret via votre session SSH approuvée lors de la configuration du client :
sudo -u rustserver cat /home/rustserver/.rcon-password Gardez-le à l'écart des captures d'écran, des publications de support et des transcriptions terminaux partagées. Stockez-le dans votre gestionnaire de mots de passe.
Dans le client RCON, envoyez :
status Un résultat utile identifie le serveur en cours d'exécution et son état actuel.
Maintenant, testez depuis l'extérieur de l'hôte sans le tunnel. Une connexion directe à Server_IP:28016 doit échouer. S'il réussit, arrêtez et corrigez la stratégie d'écoute ou de pare-feu. Une invite de mot de passe sur un port public n'est pas le résultat attendu pour cette configuration.
Rejoindre depuis un client Rust
Sur le PC du lecteur, ouvrez Rust, appuyez sur F1 et entrez :
client.connect SERVER_IP:28015 Remplacez Server_IP par l'adresse publique. Testez à partir d'un autre réseau lorsque cela est possible.
Après avoir rejoint, vérifiez la liste des serveurs publics séparément. Si la jonction directe fonctionne mais que le serveur est absent de la liste, inspectez le port de requête et les filtres du navigateur avant de modifier la règle de port de jeu.
Pour une vérification de persistance initiale, enregistrez l'emplacement d'une petite structure et l'état de votre joueur. Ceux-ci nous donnent quelque chose de concret à inspecter après un redémarrage ou une restauration.
Ajouter un administrateur uniquement en cas de besoin
L'accès RCON et les droits d'administrateur du jeu sont séparés. Si un compte a besoin des autorisations du propriétaire, utilisez son SteamID64 correct dans la console RCON :
ownerid STEAMID64 "AdminName" "Server administrator"
server.writecfg Le lecteur doit se reconnecter avant de vérifier l'accès. Donnez des autorisations aux propriétaires uniquement aux personnes qui ont besoin d'un contrôle total. Utilisez l'aide à la commande actuelle et inspectez la configuration d'administrateur enregistrée lors de la modification des autorisations.
Dépannage par symptôme
| Symptôme | Vérifiez d'abord | Prochaine action |
|---|---|---|
| SteamCMD ne parvient pas à démarrer | Erreur exacte et packages d'exécution installés | Corrigez la dépendance nommée avant de télécharger à nouveau |
| Le serveur est actif mais personne ne peut rejoindre | Journal des jeux, écouteur UDP, pare-feu hôte et fournisseur | Attendez la préparation, puis répétez le test de jointure externe |
| L'adhésion fonctionne mais la liste ne fonctionne pas | Écouteur de requêtes, règle UDP, filtres de navigateur | Corrigez le chemin d'accès sans ouvrir de larges plages de ports |
| RCON échoue dans le tunnel | session de tunnel, écouteur de bouclage, mode webcon, mot de passe | Vérifiez chaque couche dans cet ordre |
| Les sorties de processus lors de la création mondiale | RAM disponible, espace disque, journal des jeux, journal du noyau | Résoudre la défaillance enregistrée au lieu de relever les limites aveuglément |
| Un nouveau monde apparaît de manière inattendue | Identité, graine, taille de la carte, répertoire de travail | Restaurer les paramètres prévus avant de continuer |
| Le client signale une non-concordance de protocole | Versions client et serveur | Utilisez la procédure de maintenance pour mettre à jour le serveur |
Pour une mise à mort suspectée, inspectez le journal du noyau :
sudo journalctl -k -b --no-pager | grep -Ei 'out of memory|oom|killed process' Une vérification de la prise locale ne prouve pas l'accès à distance. De plus, un test de port TCP réussi ne peut pas prouver que le trafic des lecteurs UDP de Rust fonctionne.
Activez Rust+ uniquement si vous en avez besoin
Rust+ utilise un service d'accompagnement séparé. Pour l'ajouter plus tard, remplacez l'argument de désactivation dans le script de démarrage par un paramètre explicite tel que +app.port 28082, Autorisez TCP 28082 via les pare-feu pertinents et redémarrez pendant la maintenance.
Utilisez app.info via RCON pour inspecter la configuration réelle, puis couplez l'application et testez-la. Gardez Companion.id avec les sauvegardes du serveur et n'utilisez pas la même identité sur deux serveurs Live Companion.
Planifier des sauvegardes, des effacements et des sauvegardes
Un enregistrement, un redémarrage, une mise à jour et un effacement ont des effets différents. Gardez-les séparés dans la procédure d'exploitation et dans l'annonce du lecteur.
| Opération | But | Attente des données |
|---|---|---|
| Économisez | Écrire l'état actuel sur le disque | Conserver les progrès mondiaux actuels |
| Redémarrer | Arrêtez et démarrez la même instance | Charger des données sauvegardées compatibles avec la même configuration |
| Mettre à jour | Installer un nouveau logiciel de serveur | Vérifiez la version et enregistrez la compatibilité |
| effacement | Démarrer un monde frais | Supprimer intentionnellement le progrès mondial |
| Essuie-tout | Réinitialiser les plans appris | Séparer d'un effacement de la carte uniquement |
| Restaurer | Récupérer une copie enregistrée | Retourner à l'état de la sauvegarde lorsque compatible |
Arrêtez le serveur avant de copier ses données
Pour la maintenance planifiée, indiquez aux joueurs quand le serveur s'arrêtera. Dans RCON, envoyez :
server.save Attendez la preuve que la sauvegarde est terminée dans le journal du jeu. Envoyez ensuite :
quit La connexion RCON doit se fermer à la fin du serveur. Dans le shell de l'administrateur, vérifiez :
sudo systemctl status rust.service --no-pager
sudo pgrep -u rustserver -x RustDedicated Ne copiez pas un répertoire mondial en direct. Continuez seulement après la fin du processus de jeu. Effacez ensuite l'état d'exécution du service si nécessaire :
sudo systemctl stop rust.service Si le processus ne se termine pas, inspectez le journal avant de le forcer. Un délai d'arrêt systemd peut se terminer par une mise à mort forcée, de sorte que le délai d'attente de cinq minutes dans notre unité ne garantit pas une sauvegarde terminée.
Sauvegardez le monde et ses fichiers d'exploitation
Rust stocke plusieurs fichiers de sauvegarde. Le répertoire d'identités peut contenir des bases de données de joueurs, des fichiers de journal de base de données, des paramètres et d'autres états. Copiez l'intégralité du répertoire d'identité arrêté au lieu de sélectionner quelques noms de fichiers familiers.
Cet exemple conserve également notre script de lancement, notre secret et notre unité de service. Exécutez-le dans le shell bash de l'administrateur après les vérifications d'arrêt :
sudo install -d -m 700 /var/backups/rust
backup_stamp=$(date -u +%Y%m%dT%H%M%SZ)
backup_path="/var/backups/rust/rust-${backup_stamp}.tar.gz"
sudo tar -czf "$backup_path" -C / home/rustserver/rust/server/atal-rust-01 home/rustserver/start-rust.sh home/rustserver/.rcon-password etc/systemd/system/rust.service
sudo chmod 600 "$backup_path"
sudo tar -tzf "$backup_path"
sudo sha256sum "$backup_path" Nécessite une opération d'archive réussie et inspecte la liste des fichiers. Enregistrez la somme de contrôle avec l'enregistrement de sauvegarde. Une somme de contrôle permet de détecter un transfert modifié ; Cela ne prouve pas que le jeu peut charger le contenu de l'archive.
Enregistrez la construction de Rust, la version du système d'exploitation, les paramètres de la carte, l'heure de la sauvegarde et l'élément de votre journal de maintenance. Utiliser version via RCON avant l'arrêt pour capturer la version du jeu.
Redémarrez après la sauvegarde :
sudo systemctl start rust.service Regardez le nouveau journal et répétez la vérification de la jointure.
Gardez une copie loin de l'hôte du jeu
Une sauvegarde sur le même disque ne protège pas contre la perte de ce disque ou serveur. Transférez-le vers une machine ou une destination de sauvegarde distincte.
Pour un téléchargement unique, organisez l'archive sélectionnée pour votre compte d'administrateur :
sudo install -o "$(id -un)" -g "$(id -gn)" -m 600 "$backup_path" "$HOME/rust-backup-transfer.tar.gz" Exécutez ensuite sur votre PC :
scp ADMIN_USER@SERVER_IP:rust-backup-transfer.tar.gz . Utilisez majuscule -p your_ssh_port avec scp si nécessaire. Comparez la somme de contrôle téléchargée avec la valeur enregistrée. Supprimez la copie de transfert mise en scène après avoir confirmé le téléchargement, tout en conservant les sauvegardes prévues.
L'archive contient un secret d'administration. Utilisez le stockage de sauvegarde chiffré et restreignez l'accès à celui-ci.
Définissez un calendrier de sauvegarde qui correspond à la quantité de progrès que la communauté peut se permettre de perdre. Par exemple, une sauvegarde quotidienne à elle seule peut laisser près d'une journée de progrès à risque. Conservez des copies séparées avant les mises à jour et les lingettes planifiées. Automatisez ce processus uniquement après que les étapes de sauvegarde, d'arrêt, d'archivage, de transfert et de restauration fonctionnent manuellement.
Mettre à jour la rouille sans le mélanger avec le démarrage
Utilisez une fenêtre de maintenance pour les mises à jour. Suivez d'abord les étapes de sauvegarde, d'arrêt, de sauvegarde et de copie hors hôte.
Lorsque le processus est arrêté, exécutez :
sudo -iu rustserver /home/rustserver/steamcmd/steamcmd.sh +force_install_dir /home/rustserver/rust +login anonymous +app_update 258550 +quit Si la mise à jour échoue, enquêtez avant de redémarrer. Après une mise à jour réussie :
sudo systemctl start rust.service
sudo systemctl status rust.service --no-pager Vérifiez le nouveau journal des jeux, rejoignez un client mis à jour et inspectez le monde sauvegardé. Gardez une trace des anciennes et des nouvelles constructions.
Ne mettez pas une commande de mise à jour non examinée dans chaque redémarrage de processus. Cela combine la récupération des incidents avec un changement de logiciel et rend les pannes plus difficiles à tracer.
Si nous ajoutons de l'oxyde ou un autre cadre de mod plus tard, vérifiez ses propres instructions de version et de compatibilité avant chaque mise à jour. Obtenez d'abord la configuration de la vanille.
Restaurer une sauvegarde sans écraser l'état d'origine
Commencez par une répétition de restauration isolée sur un hôte séparé si possible. Utilisez une génération de serveur compatible, bloquez l'accès au public et gardez Rust+ désactivé lors du test de la copie.
Extraire une archive approuvée dans un répertoire intermédiaire en premier :
sudo install -d -m 700 /var/tmp/rust-restore
sudo tar -xzf /path/to/rust-backup.tar.gz -C /var/tmp/rust-restore
sudo ls -la /var/tmp/rust-restore/home/rustserver/rust/server/atal-rust-01 Inspectez les fichiers avant de les utiliser. Ne pas extraire une archive inconnue en tant que root.
Pour la récupération sur l'hôte d'origine, arrêtez le jeu avec la procédure précédente. Conservez le répertoire d'identité existant, puis placez la copie récupérée sur le chemin attendu :
restore_stamp=$(date -u +%Y%m%dT%H%M%SZ)
sudo mv /home/rustserver/rust/server/atal-rust-01 "/home/rustserver/rust/server/atal-rust-01-before-restore-${restore_stamp}"
sudo cp -a /var/tmp/rust-restore/home/rustserver/rust/server/atal-rust-01 /home/rustserver/rust/server/
sudo chown -R rustserver:rustserver /home/rustserver/rust/server/atal-rust-01 Comparez le script de démarrage archivé et l'unité de service avec les copies actuelles. Restaurer les paramètres de correspondance si nécessaire, mais n'écrasez pas aveuglément les chemins d'accès spécifiques à l'hôte ou les choix de réseau.
Démarrez le service et joignez-vous. Vérifiez la structure enregistrée, l'état du joueur, la configuration et l'identité du serveur. Conservez le répertoire de pré-restauration jusqu'à ce que le monde récupéré passe ces vérifications.
Une version de jeu plus récente peut nécessiter un format de sauvegarde qu'une ancienne sauvegarde ne fournit pas. Ne renommez pas une ancienne sauvegarde pour contourner un effacement forcé. Facepunch met en garde contre cette approche. La récupération doit tenir compte à la fois des données et des versions du serveur/client.
Vérifiez la récupération de démarrage et planifiez les lingettes séparément
Après une sauvegarde et un arrêt propres sur l'hôte de test, redémarrez-le :
sudo reboot Reconnectez-vous sur SSH et vérifiez :
sudo systemctl is-enabled rust.service
sudo systemctl status rust.service --no-pager Le service devrait démarrer car il a été activé plus tôt. Rejoignez à nouveau et inspectez le même marqueur mondial. Cela prouve que le démarrage du démarrage est uniquement après l'avoir observé ; Cela ne prouve pas la récupération des incidents ou l'arrêt forcé.
Pour les lingettes, annoncez la portée et conservez d'abord une sauvegarde. Un essuyage de carte ne signifie pas automatiquement une effacement de plans. Utilisez les notes de mise à jour actuelles et la disposition réelle du fichier avant de supprimer quoi que ce soit. N'exécutez pas de commandes de suppression larges ou ne planifiez pas de lingettes destructrices à partir d'une heure de mise à jour supposée.
Terminer le transfert du serveur
Avant d'inviter la communauté au sens large, confirmez :
Une fois que ces vérifications sont passées, passez en revue les exigences du CPU, de la mémoire, du stockage et de la région des joueurs avant de développer le serveur. Nous pouvons aider à évaluer un Configuration du serveur de jeux dédié Utilisation de votre population cible, de la taille de la carte, des plans de plug-in et des besoins de récupération. Confirmez les conditions matérielles et de service sélectionnées avant de commander.
Questions fréquemment posées
Pouvons-nous héberger un serveur dédié Rust sur Linux ?
Oui. Rust fournit une application de serveur dédié Linux. Ce guide utilise Ubuntu et SteamCMD pour l'installer. L'hébergement du serveur est une tâche différente de l'exécution du client Rust Player sous Linux.
Avons-nous besoin d'acheter de la rouille pour installer le serveur ?
Le téléchargement du serveur dédié accepte une connexion SteamCMD anonyme. Un joueur a toujours besoin d'un compte Steam avec Rust pour rejoindre et jouer. L'accès à l'hébergement et les licences de lecteur sont séparés.
Un serveur dédié Rust a-t-il besoin d'un GPU ?
La configuration ici s'exécute sans interface graphique. Nous n'utilisons pas de GPU d'affichage pour le processus serveur. Concentrez l'évaluation de l'hôte sur les performances du processeur, la mémoire disponible, le stockage et la route du réseau vers les joueurs.
Où est server.cfg sur Linux ?
Dans cette configuration, c'est /home/rustserver/rust/server/atal-rust-01/cfg/server.cfg. Si nous choisissons un autre répertoire ou identité d'installation, le chemin change. Vérifiez le script de démarrage avant de modifier un fichier de configuration.
Le redémarrage d'un serveur Rust efface-t-il le monde ?
Un redémarrage normal doit recharger les données sauvegardées compatibles lorsque les paramètres d'identité et de monde restent les mêmes. Un effacement intentionnel, des paramètres de carte modifiés, des fichiers manquants ou une version nécessitant une nouvelle sauvegarde peuvent produire un résultat différent.
Pouvons-nous utiliser un VPS au lieu d'un serveur dédié ?
Oui, si son allocation de CPU, sa mémoire disponible, son stockage et son réseau respectent la charge de travail. Testez pendant le jeu actif. Un Machine dédiée Peut offrir plus de contrôle sur les ressources de l'hôte, mais l'étiquette de produit à elle seule n'établit pas la capacité de Rust Player. Les petites communautés peuvent commencer sur un VPS avant de migrer vers du matériel dédié.
Pouvons-nous installer des plugins plus tard ?
Oui. Terminez les vérifications de jointure, de sauvegarde et de restauration de vanille en premier. Ajoutez ensuite un framework pris en charge et un petit ensemble de plugins. Gardez une sauvegarde et évaluez la compatibilité après chaque mise à jour du jeu plutôt que de changer le jeu et de nombreux plugins à la fois.
Déployez votre serveur Rust sur un métal nu
Faites l'expérience de zéro retard de virtualisation, de vitesses d'horloge CPU monocœur élevées, de performances RAID NVMe et d'atténuation DDoS conçues spécifiquement pour le trafic de jeu.
