...
Serveur Ubuntu 24.04 LTS 15 min de lecture Guide de production étape par étape

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.

Configurer un serveur dédié Rust sur Linux

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 :

frapper
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 :

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

Ce 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.

Étape 1

Créez le compte de jeu et installez des packages

Exécuter en tant qu'administrateur :

frapper
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 :

frapper
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.

Étape 2

Téléchargez Steamcmd et installez Rust

Passez au compte de jeu :

frapper
sudo -iu rustserver

Exécutez ce qui suit dans ce shell :

frapper
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 :

frapper
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.

Étape 3

Créer la configuration du serveur

Toujours en tant que RustServer, créez le répertoire de configuration :

frapper
mkdir -p /home/rustserver/rust/server/atal-rust-01/cfg
nano /home/rustserver/rust/server/atal-rust-01/cfg/server.cfg

Entrez :

ini
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 :

frapper
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.

Étape 4

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:

frapper
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 :

frapper
#!/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 :

frapper
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.

Étape 5

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 :

frapper
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
Contrôle de sécurité critique

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.

Étape 6

Exécuter le serveur avec systemd

Créez le service en tant qu'administrateur :

frapper
sudo nano /etc/systemd/system/rust.service

Entrez :

ini
[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 :

frapper
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 :

frapper
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 :

frapper
sudo -u rustserver ls -lt /home/rustserver/logs/

Lisez ce fichier, en remplaçant l'exemple de nom de fichier :

frapper
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 :

trafic de jeux UDP 28015
Accès public aux lecteurs
Requêtes de serveurs UDP 28017
Requêtes publiques pour un serveur public
réplique TCP 28016
Loopback uniquement, atteint via SSH
Rouille+ Désactivée
TCP lorsqu'il est activé, configurez séparément si nécessaire
ssh TCP 22
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 :

frapper
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 :

frapper
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 :

Mode RCON WebRCON
Adresse 127.0.0.1
Port RCON 28016
Mot de passe Le secret RCON généré

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 :

frapper
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 :

la console
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 :

la console
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 :

la console
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

SteamCMD ne parvient pas à démarrer
Vérifiez d'abord : Erreur exacte et packages d'exécution installés
Prochaine action : Corrigez la dépendance nommée avant de télécharger à nouveau
Le serveur est actif mais personne ne peut rejoindre
Vérifiez d'abord : Journal des jeux, écouteur UDP, pare-feu hôte et fournisseur
Prochaine action : Attendez la préparation, puis répétez le test de jointure externe
L'adhésion fonctionne mais la liste ne fonctionne pas
Vérifiez d'abord : Écouteur de requêtes, règle UDP, filtres de navigateur
Prochaine action : Corrigez le chemin d'accès sans ouvrir de larges plages de ports
RCON échoue dans le tunnel
Vérifiez d'abord : session de tunnel, écouteur de bouclage, mode webcon, mot de passe
Prochaine action : Vérifiez chaque couche dans cet ordre
Les sorties de processus lors de la création mondiale
Vérifiez d'abord : RAM disponible, espace disque, journal des jeux, journal du noyau
Prochaine action : Résoudre la défaillance enregistrée au lieu de relever les limites aveuglément
Un nouveau monde apparaît de manière inattendue
Vérifiez d'abord : Identité, graine, taille de la carte, répertoire de travail
Prochaine action : Restaurer les paramètres prévus avant de continuer
Le client signale une non-concordance de protocole
Vérifiez d'abord : Versions client et serveur
Prochaine action : Utilisez la procédure de maintenance pour mettre à jour le serveur

Pour une mise à mort suspectée, inspectez le journal du noyau :

frapper
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.

Économisez
Objectif : Écrire l'état actuel sur le disque
Données : Conserver les progrès mondiaux actuels
Redémarrer
Objectif : Arrêtez et démarrez la même instance
Données : Charger des données sauvegardées compatibles avec la même configuration
Mettre à jour
Objectif : Installer un nouveau logiciel de serveur
Données : Vérifiez la version et enregistrez la compatibilité
effacement
Objectif : Démarrer un monde frais
Données : Supprimer intentionnellement le progrès mondial
Essuie-tout
Objectif : Réinitialiser les plans appris
Données : Séparer d'un effacement de la carte uniquement
Restaurer
Objectif : Récupérer une copie enregistrée
Données : 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 :

la console
server.save

Attendez la preuve que la sauvegarde est terminée dans le journal du jeu. Envoyez ensuite :

la console
quit

La connexion RCON doit se fermer à la fin du serveur. Dans le shell de l'administrateur, vérifiez :

frapper
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 :

frapper
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 :

frapper
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 :

frapper
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 :

frapper
sudo install -o "$(id -un)" -g "$(id -gn)" -m 600 "$backup_path" "$HOME/rust-backup-transfer.tar.gz"

Exécutez ensuite sur votre PC :

frapper
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 :

frapper
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 :

frapper
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 :

frapper
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 :

frapper
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 :

frapper
sudo reboot

Reconnectez-vous sur SSH et vérifiez :

frapper
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 :

Un lecteur distant peut rejoindre le monde prévu.
Le chemin d'accès public à la requête fonctionne dans le cadre de l'intention de la liste publique.
RCON fonctionne via SSH et échoue via le discours public.
Le même monde se charge après un arrêt propre et un redémarrage de l'hôte.
Nous pouvons trouver et lire les journaux de jeu.
Une sauvegarde protégée existe en dehors de l'hôte du jeu.
Une restauration a été vérifiée en rejoignant le monde récupéré.
Quelqu'un possède la révision de la mise à jour, les vérifications de sauvegarde et la réponse aux incidents.

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.

Matériel haute performance

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.

Défiler vers le haut
Seraphinite AcceleratorBannerText_Seraphinite Accelerator
Turns on site high speed to be attractive for people and search engines.