Come creare il tuo server Rust

Questa guida spiega come installare e configurare un server dedicato Rust sul tuo VPS o server dedicato Linux, con la possibilità di aggiungere plugin grazie a Oxide (uMod).

Ordina un Server

Per ospitare il tuo server Rust, HostMyServers offre diverse soluzioni adatte al gaming. Rust è un gioco molto esigente: privilegia un processore veloce e molta RAM (8 GB come minimo, di più per un server pubblico).

• VPS Performance - Risorse dedicate e processori veloci, ideale per Rust
• VPS NVMe - Per un piccolo server o un server di test
• Server Dedicati Eco - Per server con molti giocatori
• Server Dedicati Performance - Prestazioni massime

Prerequisiti

Risorse

Le risorse indicate di seguito corrispondono alle esigenze del server e non tengono conto delle risorse già utilizzate dal sistema operativo, dai software installati o dagli altri servizi presenti sulla macchina. Calcola 200 Mbps per 100 giocatori a tickrate 30 (stima della community). La configurazione richiesta si basa su un server vanilla (senza estensioni né plugin).

• Accesso SSH come root o utente con privilegi sudo
• Sistema Linux a 64 bit (Debian 12/13 o Ubuntu 22.04/24.04 consigliati)
• Firewall attivo: nftables (consigliato), iptables o ufw (usa un solo strumento firewall alla volta)
• Minimo 8 GB di RAM (32 GB consigliati)
• Circa 20 GB di spazio disco libero (SSD NVMe consigliato)
• Porte 28015 UDP, 28017 UDP e 28082 TCP accessibili, e porta 28016 TCP (RCON) accessibile solo dal tuo indirizzo IP fisso

Configurazione richiesta

Componente	Minimo	Consigliato
RAM	8 GB	32 GB e oltre
CPU	2 core	4 core o più, frequenza elevata
Archiviazione	20 GB SSD	40 GB SSD NVMe
Rete	300 Mbps	1 Gbps

Prestazioni

Il motore di Rust dipende soprattutto dalle prestazioni di un singolo core: un processore ad alta frequenza è più importante di un gran numero di core.

Aggiornamento del sistema

sudo apt update && sudo apt upgrade -y

Installazione delle dipendenze

Installa i pacchetti necessari:

sudo apt install -y wget tar unzip screen lib32gcc-s1

Creazione di un utente dedicato

Per motivi di sicurezza, crea un utente dedicato:

sudo adduser --disabled-password --gecos "" rust

Porte utilizzate

Porta	Protocollo	Utilizzo
28015	UDP	Gioco
28017	UDP	Query (lista dei server)
28016	TCP	RCON (amministrazione remota), da limitare ai tuoi indirizzi IP
28082	TCP	Rust+ (app mobile)

Configurazione del firewall

Apri le porte necessarie. La porta RCON (28016 in TCP) deve essere limitata al tuo indirizzo IP fisso: sostituisci TUO_IP.

Con UFW

sudo ufw allow 28015/udp
sudo ufw allow 28017/udp
sudo ufw allow from TUO_IP to any port 28016 proto tcp
sudo ufw allow 28082/tcp
sudo ufw reload

Con 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 TUO_IP --dport 28016 -j ACCEPT
sudo iptables -A INPUT -p tcp --dport 28082 -j ACCEPT
sudo iptables-save | sudo tee /etc/iptables/rules.v4

Il salvataggio delle regole al riavvio richiede il pacchetto iptables-persistent.

Con nftables

Questi comandi usano la tabella inet filter e la catena input, presenti per impostazione predefinita in /etc/nftables.conf su 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 TUO_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

Sicurezza dell'RCON

La porta RCON (28016) permette di amministrare il server: non aprirla mai a tutti. Senza un indirizzo IP fisso, non aprire questa porta e passa da un tunnel SSH.

Installazione di SteamCMD

Connettiti come utente rust:

sudo -u rust bash
cd ~

Crea le directory e scarica 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

Download del server Rust

Avvia l'installazione del server (ID applicazione 258550):

./steamcmd.sh +force_install_dir /home/rust/rust-server +login anonymous +app_update 258550 validate +quit

Consiglio

Se l'installazione si interrompe con un errore, rilancia semplicemente lo stesso comando: SteamCMD riprende da dove si era fermato.

Al termine viene visualizzato il messaggio Success! App '258550' fully installed.

Script di avvio

Lo script di avvio dipende dal tipo di mappa. Scegli una delle due versioni qui sotto.

Mappa generata (predefinita)

Crea lo script di avvio:

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 "Il mio Server Rust" \
    +server.description "Benvenuto sul mio server Rust" \
    +server.saveinterval 300 \
    +rcon.port 28016 \
    +rcon.password "CambiaMi" \
    +rcon.web 1 \
    +app.port 28082

Mappa personalizzata

Per usare una mappa personalizzata ospitata online, sostituisci i parametri di generazione della mappa con +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://il_tuo_dominio.it/mia_mappa.map" \
    +server.maxplayers 100 \
    +server.hostname "Il mio Server Rust" \
    +server.description "Benvenuto sul mio server Rust" \
    +server.saveinterval 300 \
    +rcon.port 28016 \
    +rcon.password "CambiaMi" \
    +rcon.web 1 \
    +app.port 28082

Rendere lo script eseguibile

Qualunque sia la versione scelta, rendi lo script eseguibile:

chmod +x ~/rust-server/start.sh

Sicurezza

Scegli una password rcon.password lunga e unica. Chiunque la conosca può amministrare il tuo server.

Parametri principali

Parametro	Descrizione
server.identity	Nome della cartella di salvataggio del server (in server/)
server.level	Tipo di mappa (Procedural Map per una mappa generata)
server.seed	Seed di generazione della mappa
server.worldsize	Dimensione della mappa (da 1000 a 6000)
server.levelurl	Indirizzo di download di una mappa personalizzata (se definito, server.worldsize e server.seed devono essere rimossi)
server.maxplayers	Numero massimo di giocatori
server.hostname	Nome pubblico del server
server.description	Descrizione mostrata nella lista dei server
server.saveinterval	Intervallo di salvataggio automatico (secondi)
rcon.port	Porta dell'RCON
rcon.password	Password dell'RCON
rcon.web	1 = RCON WebSocket (usato dagli strumenti di amministrazione)
app.port	Porta di Rust+

Primo avvio

Al primo avvio, la generazione della mappa richiede diversi minuti. Il server è pronto quando i log mostrano Server startup complete.

Primo avvio

~/rust-server/start.sh

Per arrestare il server, usa Ctrl+C o il comando quit dall'RCON.

Installazione di Oxide (uMod)

Oxide permette di aggiungere plugin al tuo server. Arresta il server, poi:

cd ~/rust-server
wget https://github.com/OxideMod/Oxide.Rust/releases/latest/download/Oxide.Rust-linux.zip
unzip -o Oxide.Rust-linux.zip

Al prossimo avvio viene creata la cartella oxide/. I plugin vanno inseriti in oxide/plugins/.

Aggiornamenti

Ogni aggiornamento di Rust sovrascrive i file di Oxide. Dopo ogni aggiornamento del server, reinstalla Oxide con il comando unzip -o indicato sopra.

Configurazione delle dimensioni del server

Memoria consigliata

Dimensione server	Giocatori	Dimensione mappa	RAM consigliata
Piccolo	1-50	2500-3000	8 GB
Medio	50-100	3500	12-16 GB
Grande	100-200	4000 e oltre	16-32 GB

Questi valori sono indicativi: il consumo reale aumenta con il numero di plugin e con la durata del wipe.

Struttura dei file

Percorso	Descrizione
RustDedicated	Eseguibile del server
server/server1/	Dati del server (mappa, salvataggi, configurazione)
server/server1/cfg/server.cfg	Configurazione del server
oxide/plugins/	Plugin Oxide
oxide/config/	Configurazione dei plugin
oxide/data/	Dati dei plugin
oxide/logs/	Log di Oxide

Aggiungere emoji personalizzate

Crea la cartella serveremoji nella cartella del server (il nome server1 corrisponde a server.identity):

mkdir -p /home/rust/rust-server/server/server1/serveremoji

Poi inserisci al suo interno le tue immagini.

Requisiti delle immagini

• L'immagine non deve superare 256x256 pixel.
• Solo formato .jpg o .png (i PNG a 8 o 16 bit non funzionano).
• Il peso dell'immagine deve essere inferiore a 250 KB.
• Il nome del file diventa il nome dell'emoji: poop.png si usa con :poop:.

Le emoji possono essere aggiornate con il comando seguente, da eseguire tramite l'RCON:

server.resetserveremoji

I giocatori devono riconnettersi per vedere le nuove emoji.

Contenuti

Facepunch può rimuovere dalla lista dei server quelli che usano emoji offensive o inappropriate.

Configurazione come servizio systemd

Creare il file di servizio

Esci dalla sessione dell'utente rust (exit) per tornare al tuo account amministratore, poi crea il file di servizio:

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

Contenuto del file:

[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

Attivare e avviare il servizio

sudo systemctl daemon-reload
sudo systemctl enable rust.service
sudo systemctl start rust.service

Comandi di gestione

# Verificare lo stato
sudo systemctl status rust.service

# Fermare il server
sudo systemctl stop rust.service

# Riavviare il server
sudo systemctl restart rust.service

# Vedere i log
sudo journalctl -u rust.service -f

Consiglio

Prima di arrestare o riavviare il server, invia il comando server.save tramite l'RCON per essere sicuro che i progressi dei giocatori vengano salvati.

Avvio con screen (alternativa)

Una sola modalità di avvio

Se il servizio systemd è avviato, arrestalo prima (sudo systemctl stop rust.service): due server non possono usare le stesse porte.

sudo -u rust bash
screen -S rust
~/rust-server/start.sh

Per staccare: Ctrl+A poi D

Per tornare: screen -r rust

Avviare in background con un log

sudo -u rust bash
cd ~/rust-server
screen -AdmSL rust ./start.sh

Opzione	Descrizione
-A	Adatta la finestra alla dimensione del terminale
-d -m	Avvia la sessione staccata, in background
-S rust	Nome della sessione
-L	Registra l'output del server in un file di log

Il file screenlog.0 viene creato nella cartella in cui viene lanciato il comando (~/rust-server) e contiene tutto l'output lato server. Per seguirlo in tempo reale:

tail -f ~/rust-server/screenlog.0

In caso di errore all'avvio, è il primo file da consultare. Per tornare alla console del server: screen -r rust

Consiglio

Il file screenlog.0 cresce a ogni avvio. Ricorda di svuotarlo o eliminarlo regolarmente.

Aggiornamento del server

Fermare il server

sudo systemctl stop rust.service

Scaricare la nuova versione

sudo -u rust bash
cd ~/steamcmd
./steamcmd.sh +force_install_dir /home/rust/rust-server +login anonymous +app_update 258550 validate +quit

Aggiornare / reinstallare Oxide

Se usi Oxide, reinstallalo (sempre con l'utente rust), poi esci dalla sessione:

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

Senza Oxide, digita semplicemente exit per uscire dalla sessione dell'utente rust.

Riavviare il server

sudo systemctl start rust.service

Wipe del server

Un wipe azzera la mappa. Arresta il server, poi elimina i file della mappa con l'utente rust:

sudo systemctl stop rust.service
sudo -u rust bash
cd ~/rust-server/server/server1
rm -f *.*.map *.*.sav*

Per un wipe completo che includa i blueprint dei giocatori, elimina anche:

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*

Esci poi dalla sessione dell'utente rust:

exit

File	Contenuto	Effetto dell'eliminazione
clans.*.db	Clan (membri, ruoli)	I clan scompaiono
player.blueprints*.db	Blueprint appresi dai giocatori	Blueprint azzerati
player.deaths*.db	Cronologia delle morti	Cronologia cancellata
player.identities*.db	Identità del giocatore (nome, aspetto del personaggio)	I giocatori ripartono con un personaggio nuovo
player.states*.db	Stato persistente dei giocatori	Progressi azzerati
player.tokens*	Dati specifici di ogni giocatore (marcatori sulla mappa, timer)	Dati reimpostati
relationship*	Relazioni tra giocatori	Relazioni cancellate
sv.files*	File memorizzati dal server (immagini dei cartelli, dipinti)	Immagini dei cartelli e dipinti eliminati

Modifica poi +server.seed in start.sh (o l'indirizzo +server.levelurl per una mappa personalizzata) per generare una nuova mappa, quindi riavvia il server.

Wipe forzato

Facepunch impone un wipe della mappa il primo giovedì di ogni mese, con l'aggiornamento del gioco.

Comandi della console

Questi comandi si usano tramite l'RCON (strumento di amministrazione o console di gioco).

Comando	Descrizione
status	Mostra i giocatori connessi
server.save	Salvare il mondo
say <messaggio>	Inviare un messaggio a tutti i giocatori
kick <giocatore>	Espellere un giocatore
ban <giocatore>	Bannare un giocatore
unban <steamid>	Sbannare un giocatore
ownerid <steamid> "nome" "motivo"	Assegnare i diritti di proprietario
moderatorid <steamid> "nome" "motivo"	Assegnare i diritti di moderatore
server.writecfg	Salvare la configurazione e i permessi
oxide.plugins	Elencare i plugin caricati
oxide.reload <plugin>	Ricaricare un plugin
quit	Arrestare il server

Backup automatico

Script di backup

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

# Backup dei dati del server e di Oxide
# (rimuovi le cartelle oxide/... se non usi Oxide)
tar -czf $BACKUP_DIR/rust_$DATE.tar.gz -C $SERVER_DIR server/server1 oxide/data oxide/config oxide/plugins

# Eliminare i backup più vecchi di 7 giorni
find $BACKUP_DIR -name "rust_*.tar.gz" -mtime +7 -delete

echo "Backup completato: rust_$DATE.tar.gz"

sudo chown rust:rust /home/rust/backup.sh
sudo chmod +x /home/rust/backup.sh

Pianificare il backup

sudo crontab -u rust -e

Aggiungi:

# Backup ogni 6 ore
0 */6 * * * /home/rust/backup.sh

Connessione al server

I giocatori possono connettersi tramite:

1. Avviare Rust
2. Aprire la console con il tasto F1
3. Digitare: client.connect IP_DEL_SERVER:28015

Puoi anche aggiungere il server ai preferiti di Steam (menu Visualizza, Server, scheda Preferiti).

In caso di problemi

Il server non si avvia

• Controlla i log: sudo journalctl -u rust.service -n 100
• Verifica che lo script sia eseguibile: ls -l ~/rust-server/start.sh
• Verifica lo spazio disco disponibile: df -h
• Verifica la memoria disponibile: free -h

Errore steamclient.so

Se i log segnalano un errore relativo a steamclient.so, connettiti come utente rust, poi crea il collegamento al file a 64 bit di SteamCMD:

sudo -u rust bash
mkdir -p ~/.steam/sdk64
ln -sf ~/steamcmd/linux64/steamclient.so ~/.steam/sdk64/steamclient.so
exit

I giocatori non riescono a connettersi

• Verifica che la porta 28015 sia aperta in UDP:

  sudo ufw status
  sudo iptables -L INPUT -n --line-numbers | grep 28015
  sudo nft list ruleset | grep 28015

• Verifica che il server sia in ascolto: ss -ulnp | grep 28015

• Attendi la fine dell'avvio (Server startup complete nei log)

Il server non appare nella lista

• Verifica che la porta 28017 UDP sia aperta
• Attendi qualche minuto dopo l'avvio
• Verifica che il server abbia accesso a Internet

Oxide non carica i plugin

• Reinstalla Oxide dopo ogni aggiornamento di Rust
• Verifica la versione di Oxide con il comando oxide.version
• Consulta i log in oxide/logs/

Problemi di prestazioni

• Riduci server.worldsize e server.maxplayers
• Disattiva i plugin più esigenti
• Aumenta la RAM della tua istanza
• Pianifica uno o due riavvii giornalieri
• Come ultima risorsa, passa all'offerta superiore

FAQ

Quali porte vanno aperte?

Oltre alle porte del server (vedi la tabella "Porte utilizzate"), queste porte sono necessarie a Steam. Permettono al server di ricevere le risposte dei server Steam quando il tuo firewall blocca per impostazione predefinita il traffico in entrata:

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

Ottengo "Permesso negato" eseguendo ./steamcmd.sh

Applica un chmod:

chmod +x /home/rust/steamcmd/linux32/steamcmd && chmod +x /home/rust/steamcmd/steamcmd.sh

Ottengo il messaggio "WARNING: setlocale('en_US.UTF-8') failed, using locale: 'C'"

Non è un vero problema: solo alcuni caratteri internazionali potrebbero essere visualizzati in modo errato. Per correggerlo:

sudo locale-gen en_US.UTF-8
sudo update-locale LANG=en_US.UTF-8

Se il comando locale-gen non viene trovato, installa prima il pacchetto locales con sudo apt install -y locales.