Installer Rust sur un dédié avec Pterodactyl

1Vérifier la machine, le DNS et le budget de ressources

Connectez-vous en SSH avec l’adresse et le port SSH du fournisseur. Lancez les contrôles ci-dessous avant installation. Continuez seulement sur Ubuntu 24.04, architecture x86_64, avec une capacité libre suffisante. Un dédié physique indique normalement none pour la virtualisation ; un VPS OpenVZ/LXC demande confirmation du support Docker par le fournisseur.

La base Rust Facepunch est 12 Go de RAM libres / 15 Go de disque libre. Un budget Rust de 16 Go est un point de départ cité par MineStrator, pas un minimum universel. Gardez des ressources pour les services du système et les copies de sauvegarde ; n’attribuez pas toute la RAM physique aux jeux du node.

cat /etc/os-release
uname -m
systemd-detect-virt
free -m
df -h /

Résultat attenduUbuntu 24.04, x86_64 et un budget de capacité documenté. Les deux noms DNS doivent résoudre vers le dédié avant création des certificats.

2Installer PHP 8.3, MariaDB, Redis et Nginx

Passez dans un shell root avec sudo -i. Sur cette cible Ubuntu 24.04 neuve, PHP 8.3 et MariaDB sont disponibles dans les dépôts Ubuntu ; le PPA PHP de la procédure Ubuntu 22.04 n’est pas nécessaire. Installez extensions requises et outils d’édition/réseau utilisés ci-dessous.

Ce parcours utilise Panel 1.15.1 et Wings 1.13.3, versions stables vérifiées le 5 octobre 2026. Le prérequis PHP déclaré par Panel 1.15.1 accepte 8.3. Notez les versions installées et relisez les notes avant toute mise à niveau ultérieure.

sudo -i

apt update
apt install -y php8.3 php8.3-common php8.3-cli php8.3-gd php8.3-mysql php8.3-mbstring php8.3-bcmath php8.3-xml php8.3-fpm php8.3-curl php8.3-zip mariadb-server redis-server nginx curl ca-certificates tar unzip git nano cron dnsutils certbot

systemctl enable --now mariadb redis-server php8.3-fpm nginx cron
php -v
redis-cli ping
dig +short panel.example.com A
dig +short node.example.com A

Résultat attenduPHP indique 8.3, Redis répond PONG et les deux résultats DNS montrent la bonne IPv4 publique.

3Installer Composer 2 et télécharger le Panel

Téléchargez l’installateur Composer dans /tmp, vérifiez son SHA-384 actuel depuis le point de signature officiel Composer, puis seulement exécutez-le. La somme est récupérée plutôt que figée car l’installateur évolue.

Créez le dossier Panel vide et téléchargez la version ci-dessous. Vérifiez son SHA-256 avant extraction. Ces commandes concernent une première installation, pas l’écrasement d’un Panel existant.

Attention : Si une somme échoue, arrêtez. N’exécutez pas l’installateur et n’extrayez pas l’archive. Gardez .env privé ; il contiendra secrets de base, de mail et de chiffrement.

cd /tmp
curl -fsSLo composer-setup.php https://getcomposer.org/installer
COMPOSER_INSTALLER_SHA384=$(curl -fsSL https://composer.github.io/installer.sig)
printf '%s  composer-setup.php\n' "$COMPOSER_INSTALLER_SHA384" | sha384sum -c -

php /tmp/composer-setup.php --2 --install-dir=/usr/local/bin --filename=composer
composer --version

mkdir -p /var/www/pterodactyl
cd /var/www/pterodactyl
curl -fL -o panel.tar.gz https://github.com/pterodactyl/panel/releases/download/v1.15.1/panel.tar.gz
printf '%s  panel.tar.gz\n' '62c88c035b3e0f3c3ddd06bc3ef12249d087af0e765f49878b6327a066ed860b' | sha256sum -c -

cd /var/www/pterodactyl
tar -xzf panel.tar.gz
chmod -R 755 storage bootstrap/cache
cp .env.example .env
COMPOSER_ALLOW_SUPERUSER=1 composer install --no-dev --optimize-autoloader

Résultat attenduLes vérifications indiquent OK, Composer annonce 2.x et les dépendances PHP du Panel s’installent correctement.

4Créer la base Panel et son mot de passe privé

Ouvrez MariaDB en root. Dans le bloc SQL, remplacez <UNIQUE_DATABASE_PASSWORD> par un nouveau mot de passe alphanumérique généré dans votre gestionnaire avant exécution. Cette base appartient au Panel ; le serveur Rust de ce tutoriel n’a pas besoin d’une autre base MySQL.

L’utilisateur de base est limité à panel et 127.0.0.1. Gardez MariaDB/Redis privés sur cette machine ; n’ouvrez pas leurs ports sur Internet.

mariadb

CREATE DATABASE panel;
CREATE USER 'pterodactyl'@'127.0.0.1' IDENTIFIED BY '<UNIQUE_DATABASE_PASSWORD>';
GRANT ALL PRIVILEGES ON panel.* TO 'pterodactyl'@'127.0.0.1';
EXIT;

Résultat attenduLa base panel et son utilisateur local existent sans erreur SQL.

5Configurer l’environnement et créer l’administrateur Panel

Lancez séparément les commandes ci-dessous depuis /var/www/pterodactyl. Les commandes d’environnement demandent les valeurs indiquées ici.

Conservez .env, notamment APP_KEY, dans un stockage chiffré hors machine. Ne régénérez jamais APP_KEY sur une installation existante : sa perte rend les données chiffrées du Panel irrécupérables.

• Générez la clé d’application une seule fois, pour cette première installation vide.
• Environnement : utilisez votre URL https://panel.example.com et un fuseau horaire valide.
• Cache, sessions et file d’attente : choisissez Redis sur 127.0.0.1, port 6379.
• Base : hôte 127.0.0.1, port 3306, base panel, utilisateur pterodactyl et mot de passe créé à l’étape précédente.
• Mail : renseignez les paramètres de votre vrai service SMTP.
• Initialisez tables et eggs, puis créez votre compte. Répondez oui à la question administrateur.
• Appliquez le propriétaire et les permissions de .env du dernier bloc de commandes.

cd /var/www/pterodactyl
php artisan key:generate --force

cd /var/www/pterodactyl
php artisan p:environment:setup

cd /var/www/pterodactyl
php artisan p:environment:database

cd /var/www/pterodactyl
php artisan p:environment:mail

cd /var/www/pterodactyl
php artisan migrate --seed --force
php artisan p:user:make
chown -R www-data:www-data /var/www/pterodactyl
chmod 600 /var/www/pterodactyl/.env

Résultat attenduLes migrations terminent et votre administrateur existe ; base et sauvegarde APP_KEY sont consignées en privé.

6Activer le planificateur et le worker

Ouvrez le crontab root et ajoutez une seule fois la ligne de planification ci-dessous. Enregistrez. Créez ensuite /etc/systemd/system/pteroq.service avec le contenu fourni et activez le worker. Dans nano, enregistrez avec Ctrl+O, Entrée, puis quittez avec Ctrl+X.

crontab -e

* * * * * /usr/bin/php /var/www/pterodactyl/artisan schedule:run >> /dev/null 2>&1

nano /etc/systemd/system/pteroq.service

[Unit]
Description=Pterodactyl queue worker
After=redis-server.service

[Service]
User=www-data
Group=www-data
Restart=always
ExecStart=/usr/bin/php /var/www/pterodactyl/artisan queue:work --queue=high,standard,low --sleep=3 --tries=3
RestartSec=5

[Install]
WantedBy=multi-user.target

systemctl daemon-reload
systemctl enable --now pteroq
systemctl is-active pteroq redis-server
crontab -l

Résultat attendupteroq et Redis indiquent active et la ligne de planification apparaît une seule fois.

7Servir les vérifications de certificat des deux noms DNS

Dans le pare-feu du fournisseur, autorisez TCP 80 et 443 vers cette machine ; gardez votre port SSH réel accessible depuis votre adresse. N’exposez pas base/Redis. Créez le dossier ACME et le site Nginx provisoire ci-dessous en remplaçant les deux noms DNS.

Cette machine est neuve : désactivez seulement le site Nginx par défaut en déplaçant son lien activé, puis activez le nouveau site. Ce site HTTP sert seulement les vérifications de certificat, pas une page de connexion.

Attention : Si sites-enabled/default est déjà absent, sautez ce déplacement. Ne déplacez ni ne remplacez un autre site existant ; cette recette concerne un dédié neuf.

mkdir -p /var/www/letsencrypt
nano /etc/nginx/sites-available/pterodactyl.conf

server {
    listen 80;
    server_name panel.example.com node.example.com;
    location ^~ /.well-known/acme-challenge/ { root /var/www/letsencrypt; }
    location / { return 404; }
}

mv /etc/nginx/sites-enabled/default /etc/nginx/default-site.disabled
ln -s /etc/nginx/sites-available/pterodactyl.conf /etc/nginx/sites-enabled/pterodactyl.conf
nginx -t

systemctl reload nginx

Résultat attendunginx -t réussit ; les deux noms DNS publics atteignent ce site HTTP.

8Créer le certificat TLS et activer HTTPS

Demandez un certificat couvrant les deux vrais noms DNS. Indiquez une adresse mail suivie dans l’invite Certbot. Après réussite, remplacez le fichier Nginx provisoire par la configuration HTTPS ci-dessous ; le dossier du certificat utilise le premier nom demandé.

Gardez l’emplacement HTTP de vérification pour le renouvellement automatique. Cette configuration utilise le socket PHP 8.3 et le dossier public du Panel, pas la racine du dépôt.

certbot certonly --webroot -w /var/www/letsencrypt -d panel.example.com -d node.example.com

nano /etc/nginx/sites-available/pterodactyl.conf

server {
    listen 80;
    server_name panel.example.com node.example.com;
    location ^~ /.well-known/acme-challenge/ { root /var/www/letsencrypt; }
    location / { return 301 https://$host$request_uri; }
}
server {
    listen 443 ssl http2;
    server_name panel.example.com;
    root /var/www/pterodactyl/public;
    index index.php;
    ssl_certificate /etc/letsencrypt/live/panel.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/panel.example.com/privkey.pem;
    ssl_protocols TLSv1.2 TLSv1.3;
    client_max_body_size 100m;
    client_body_timeout 120s;
    sendfile off;
    add_header X-Content-Type-Options nosniff;
    add_header X-Frame-Options DENY;
    location / { try_files $uri $uri/ /index.php?$query_string; }
    location ~ \.php$ {
        include fastcgi_params;
        fastcgi_pass unix:/run/php/php8.3-fpm.sock;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        fastcgi_param HTTP_PROXY "";
        fastcgi_param PHP_VALUE "upload_max_filesize=100M \n post_max_size=100M";
        fastcgi_read_timeout 300;
    }
    location ~ /\. { deny all; }
}

nginx -t

systemctl reload nginx
systemctl enable --now certbot.timer
certbot renew --dry-run

Résultat attenduhttps://panel.example.com affiche la connexion Panel sans alerte certificat et le test de renouvellement réussit.

9Installer Docker depuis son dépôt Ubuntu officiel

Utilisez le dépôt APT signé Docker sur ce dédié Ubuntu 24.04 amd64 neuf. Créez son fichier de dépôt avec le contenu ci-dessous, puis installez les paquets. Ne lancez pas un installateur Panel tout-en-un non vérifié.

Les ports de conteneur publiés par Docker peuvent contourner UFW. Utilisez le pare-feu du fournisseur pour le filtrage public et vérifiez la politique réseau Docker avant de publier RCON. Ne supposez pas qu’une règle UFW deny suffit à protéger un port de conteneur.

install -m 0755 -d /etc/apt/keyrings
curl -fsSLo /etc/apt/keyrings/docker.asc https://download.docker.com/linux/ubuntu/gpg
chmod a+r /etc/apt/keyrings/docker.asc
nano /etc/apt/sources.list.d/docker.sources

Types: deb
URIs: https://download.docker.com/linux/ubuntu
Suites: noble
Components: stable
Architectures: amd64
Signed-By: /etc/apt/keyrings/docker.asc

apt update
apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
systemctl enable --now docker
docker info

Résultat attendudocker info renvoie les informations serveur sans erreur de connexion au daemon.

10Créer le node et installer Wings

Connectez-vous comme administrateur Panel et ouvrez l’administration. Le node représente ce dédié ; Wings y exécute les conteneurs de jeu. Les ports API et SFTP sont des ports de service, pas les ports de jeu Rust.

• Dans Locations, créez une localisation. Ouvrez Nodes → Create New et sélectionnez-la.
• Renseignez votre domaine node.example.com comme FQDN, activez SSL et choisissez aucun proxy inverse.
• Pour ce parcours, mettez le port API Wings sur 8080 et SFTP sur 2022.
• Réservez mémoire et disque pour OS, Panel et sauvegardes. Fixez les limites du node sous la capacité du dédié et la surallocation à 0.
• Utilisez /var/lib/pterodactyl/volumes comme dossier de données seulement si son système de fichiers a assez d’espace libre.
• Avec les blocs ci-dessous, téléchargez et vérifiez Wings amd64. Installez-le seulement après une somme indiquée OK.
• Ouvrez Configuration du node. Quand nano ouvre /etc/pterodactyl/config.yml, collez le YAML privé complet ; conservez URL, UUID et token générés.
• Mettez api.ssl.enabled sur true et api.ssl.cert / api.ssl.key sur les chemins de certificat ci-dessous, en remplaçant le domaine. Protégez le fichier et contrôlez le démarrage.

Attention : Le YAML du node contient un token d’authentification. Ne le publiez pas dans un chat de support ou une capture. Ne le remplacez pas par un exemple générique.

cd /tmp
curl -fL -o wings_linux_amd64 https://github.com/pterodactyl/wings/releases/download/v1.13.3/wings_linux_amd64
printf '%s  wings_linux_amd64\n' '010d894a895fe4f914e3f1c1e75fb2fda4ebe50cc249e7e456887ea5b422c8fa' | sha256sum -c -

install -m 0755 /tmp/wings_linux_amd64 /usr/local/bin/wings
mkdir -p /etc/pterodactyl
nano /etc/pterodactyl/config.yml

/etc/letsencrypt/live/panel.example.com/fullchain.pem
/etc/letsencrypt/live/panel.example.com/privkey.pem

chmod 600 /etc/pterodactyl/config.yml
wings --debug

Résultat attenduWings démarre sans erreur de configuration/TLS et atteint votre Panel. Arrêtez ce processus de contrôle avec Ctrl+C avant activation du service.

11Maintenir Wings actif et recharger les certificats renouvelés

Créez /etc/systemd/system/wings.service avec l’unité ci-dessous et activez-la. Autorisez TCP Wings 8080 au Panel et aux navigateurs qui l’utiliseront ; restreignez TCP SFTP 2022 aux administrateurs prévus lorsque possible.

Créez le hook de déploiement Certbot pour que Nginx et Wings relisent un certificat renouvelé avec succès. Gardez le webroot ACME joignable sur TCP 80.

nano /etc/systemd/system/wings.service

[Unit]
Description=Pterodactyl Wings
After=docker.service
Requires=docker.service
PartOf=docker.service

[Service]
User=root
WorkingDirectory=/etc/pterodactyl
LimitNOFILE=4096
ExecStart=/usr/local/bin/wings
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target

systemctl daemon-reload
systemctl enable --now wings
systemctl is-active wings
mkdir -p /etc/letsencrypt/renewal-hooks/deploy
nano /etc/letsencrypt/renewal-hooks/deploy/pterodactyl

#!/bin/sh
/usr/sbin/nginx -t && /usr/bin/systemctl reload nginx
/usr/bin/systemctl try-restart wings

chmod 750 /etc/letsencrypt/renewal-hooks/deploy/pterodactyl
systemctl list-timers certbot.timer
journalctl -u wings -n 30 --no-pager

Résultat attenduLe node indique une connexion saine dans le Panel, Wings est actif et le renouvellement possède timer activé et hook de déploiement.

12Attribuer les ports Rust exacts avant création

Les contrôles en lecture seule ci-dessous indiquent l’IP d’interface du dédié et les ports déjà utilisés. Le queryport 27017 vient de l’egg Rust choisi.

• Ouvrez Admin → Nodes → votre node → Allocation et utilisez l’IP réelle de l’interface réseau, jamais 127.0.0.1.
• Créez quatre allocations de ports libres : 28015/UDP jeu, 27017/UDP query, 28016/TCP RCON et 28082/TCP Rust+.
• À la création du serveur Rust, étape suivante, attribuez les quatre et choisissez 28015 comme port primaire. Les variables de démarrage doivent leur correspondre.
• Dans le pare-feu fournisseur, autorisez jeu/query aux joueurs et Rust+ si souhaité. Vérifiez aussi le filtrage Docker.
• Gardez RCON fermé au public : le pont console local n’a pas besoin d’accès public. Pour un RCON externe, autorisez seulement les IP d’administrateurs de confiance.

Attention : Si un port d’exemple est occupé, choisissez-en un libre et modifiez ensemble allocation, variable de démarrage et règle pare-feu. Ne changez pas un seul des trois.

ip -4 address
ss -lntup

Résultat attenduLe node possède des allocations correspondantes libres et une politique pare-feu documentée ; les ports jeu et query sont distincts.

13Créer le serveur avec l’egg Rust officiel

Un egg indique à Pterodactyl comment installer et démarrer un jeu. Ce parcours utilise l’egg Rust officiel lié ci-dessous. Un plafond CPU 400 % autorise jusqu’à quatre équivalents-cœurs ; il ne réserve pas de cœurs physiques et ne garantit pas les performances.

• Dans Admin → Nests, trouvez l’egg Rust initialisé et comparez-le au JSON officiel. S’il manque ou n’a pas Modding Framework, téléchargez ce JSON et utilisez Import Egg dans un nest adapté.
• Ouvrez Admin → Servers → Create New, mettez votre compte comme propriétaire et décochez Start Server when Installed. Vous démarrerez Rust manuellement après avoir contrôlé ses réglages.
• Sélectionnez le node, l’allocation jeu primaire et les trois allocations supplémentaires.
• Choisissez l’egg Rust et l’image ghcr.io/pterodactyl/games:rust. Laissez l’installation active : elle télécharge Rust Dedicated avec SteamCMD.
• Attribuez au moins 12288 MiB de RAM pour cet exemple (12 GiB). Ne surallouez pas le node.
• Prévoyez au moins 15360 MiB de disque pour les fichiers Rust, avec une marge pour croissance du monde et des journaux.
• Mettez la limite de sauvegardes à au moins 1 si vous utilisez celles du Panel.
• Avant validation, ouvrez Service Variables : mettez Modding Framework sur vanilla, World Size sur 3000, World Seed sur 12345 et Max Players sur 10. Alignez Query Port, RCON Port et App Port sur les allocations précédentes.
• Renseignez maintenant RCON Password : générez 32 lettres et chiffres aléatoires et conservez ce mot de passe unique en privé. Ce champ obligatoire ne peut pas rester vide à la création.
• Cliquez sur Create Server et attendez la fin de l’installation. Gardez le serveur arrêté pour le contrôle suivant.

Attention : Gardez le modèle de démarrage officiel. Son identité est rust ; le chemin monde/configuration est donc server/rust.

Résultat attenduL’installation termine et Rust reste arrêté. Les réglages affichent l’image officielle, les limites de ressources et les variables renseignées.

14Contrôler les réglages avant le premier démarrage

Ouvrez Startup et comparez les valeurs saisies à la création avec cette liste. Ces réglages servent à un test de connexion limité ; certains ports ne sont modifiables que par un administrateur Panel.

Gardez les ports dans les variables de démarrage : un server/rust/cfg/server.cfg contradictoire peut les remplacer.

• Modding Framework / FRAMEWORK : vanilla. Level : Procedural Map.
• World Size : 3000. World Seed : une valeur fixe comme 12345. Max Players : 10.
• Query Port : 27017. RCON Port : 28016. App Port : 28082. Alignez-les sur les allocations choisies précédemment.
• RCON Password : vérifiez la présence de votre mot de passe privé. Gardez le secret unique saisi à la création ; ne le remplacez pas par un exemple de capture.
• Save Interval : 60 secondes, réglage de l’egg choisi.
• Laissez Custom Map URL et Additional Arguments vides pour le premier test.

Attention : L’image peut afficher la commande de démarrage complète, avec les identifiants RCON. Gardez console/journaux privés et masquez les captures avant partage.

Résultat attenduTous les ports de démarrage correspondent aux allocations, vanilla est choisi et le secret RCON est renseigné sans publication.

15Démarrer vanilla, se connecter et attribuer le rôle natif

Ouvrez la Console du serveur et cliquez sur Start. Attendez Server startup complete. Le pont console de l’image attend le WebRCON local ; Waiting for RCON to come up ne prouve pas la fin de génération de carte.

Dans F1 du client Rust, rejoignez l’IPv4 publique et le port jeu primaire. Après connexion, utilisez la console serveur du Panel pour attribuer owner à votre Steam64 ID et vérifiez l’accès natif en jeu. Reconnectez-vous seulement si le client affiche l’ancien rôle. Ne saisissez pas la commande owner dans SSH ou SteamCMD.

connect <SERVER_IP>:<GAME_PORT>

ownerid <STEAM64_ID> "Server owner"

Résultat attenduVous entrez dans le bon monde et avez l’accès owner ; les rôles sont enregistrés automatiquement par Rust actuel. Un autre client ordinaire peut se connecter par le port de jeu.

16Facultatif : activer Oxide et installer un plugin

Restez vanilla sans besoin de plugins. Pour Oxide, sauvegardez le monde, arrêtez proprement et préparez une copie téléchargeable. Dans Startup, passez Modding Framework / FRAMEWORK sur oxide, puis démarrez normalement. L’image officielle met Rust à jour et applique le framework choisi ; n’envoyez pas manuellement des DLL de framework.

Dans la console serveur Panel, vérifiez oxide.version. Téléchargez Vanish.cs chez son auteur sur uMod et envoyez-le avec Files dans oxide/plugins. Contrôlez compilation et oxide.plugins, puis modifiez le oxide/config/Vanish.json généré en conservant toutes les clés. Pour un test manuel, désactivez vanish automatique et noclip ; n’accordez pas vanish.permanent.

Rechargez seulement Vanish, accordez vanish.allow au Steam64 ID prévu et testez /vanish activé/désactivé dans le chat avec un joueur ordinaire proche. Envoi de fichiers/export JSON n’accordent pas de permissions. Pour Carbon, choisissez séparément son framework et ses dossiers/commandes ; ne superposez pas les deux et ne supposez pas tous les plugins compatibles.

oxide.version

oxide.plugins

oxide.reload Vanish

oxide.grant user <STEAM64_ID> vanish.allow

/vanish

Résultat attenduOxide et Vanish se chargent sans erreur ; seul le joueur prévu peut basculer la fonction. Vanilla reste une fin valable de ce tutoriel.

17Sauvegarder Rust et le Panel, puis contrôler la persistance

Pour Rust, lancez server.save, attendez la fin et arrêtez proprement. Dans Backups du serveur, cliquez sur Create backup, nommez la copie, laissez les exclusions vides pour cette copie complète et attendez sa réussite. Ouvrez le menu de la sauvegarde → Download et gardez une copie séparée. Incluez server/rust et plugins/config/data/lang/permissions du framework. Gardez le companion.id Rust+ privé si utilisé ; ce n’est pas un identifiant à partager.

Pour le Panel, gardez une copie chiffrée hors machine de .env/APP_KEY, du dump ci-dessous, de /etc/pterodactyl/config.yml, des configurations services/web et des versions notées. Les sauvegardes d’un jeu par le Panel ne sauvegardent pas sa base. La commande dump demande le mot de passe sans le placer dans sa ligne de commande.

Redémarrez Rust normalement. Vérifiez même monde, rôle natif, connexion externe directe et liste query ; si moddé, versions framework/plugins et comportements autorisé/refusé. Pour un retour arrière volontaire sur ce serveur, arrêtez-le, ouvrez le menu de la copie choisie → Restore et lisez la confirmation. Cochez Delete all files before restoring backup seulement pour remplacer toute la cible. Testez la récupération séparément avant de faire confiance à la copie ; un wipe Rust forcé peut rendre un ancien monde incompatible.

Avant un prochain redémarrage/mise à jour Rust, sauvegardez et vérifiez la compatibilité framework : l’image officielle met à jour par défaut. Mettez Panel/Wings à niveau selon leur procédure propre à la version, pas en répétant cette première installation ou en générant une nouvelle APP_KEY.

Attention : Ne publiez ni dump, ni .env, ni YAML node, ni journaux de démarrage complets. Ne supprimez pas tous les .db comme raccourci de mise à jour ou wipe.

server.save

install -m 0700 -d /root/pterodactyl-backups
umask 077
mariadb-dump --single-transaction --no-tablespaces -h 127.0.0.1 -u pterodactyl -p panel > /root/pterodactyl-backups/panel-$(date -u +%Y%m%dT%H%M%SZ).sql

Résultat attenduLe serveur conserve monde et accès prévus après redémarrage normal ; Rust et Panel ont des sauvegardes séparées récupérables hors machine.