Rust server hosting on your own VPS: SteamCMD, ports, wipes and how much RAM

Short answer: to host a Rust server on your own VPS, install SteamCMD, download the Rust Dedicated Server (Steam app 258550) with an anonymous login and start RustDedicated with your ports, map seed, map size and an RCON password. Open UDP 28015 for the game, the UDP query port (28017 in this guide) so the server shows up in the browser, and TCP 28082 for the Rust+ app. Budget at least 16 GB of RAM: Facepunch asks for 12 GB free for the server process alone, before the operating system and anything else on the box.

This guide does that on Debian 12/13 or Ubuntu 24.04, runs the server as its own user under systemd, and covers the parts that trip people up later: the monthly forced wipe, Oxide and Carbon surviving updates, and how much machine you really need.

How much RAM and CPU does a Rust server need?

Rust is one of the heavier games to host. Facepunch’s own server guide lists 12 GB of free RAM and 15 GB of free disk as the baseline, notes that a 6000 map uses more, and says more players need a faster CPU. Memory also climbs during a wipe as players build, so a server that starts at 8 GB on day one can sit far higher by day five. Treat these as starting points and check free -h in the middle of a wipe, not right after one:

On the CPU side, Facepunch only says that more players need a faster processor. In practice a handful of fast cores does more for a Rust server than many slow ones. Disk needs are modest by comparison. The server files are about 6 GB today, and saves, logs and plugin data grow from there, so 40 GB or more leaves room for backups. Add a few gigabytes of swap as a safety net against the out-of-memory killer, but do not plan on using it: a Rust server that swaps lags for everyone.

Which ports does a Rust server use?

A Rust server uses four ports. Only the game port is needed to join; the others put the server in the browser, enable admin tools and power the Rust+ phone app.

The query port and the game port must be different. Set every port explicitly on the command line, as below, so a changed RCON port never moves your query port without you noticing.

How do I install SteamCMD and the Rust server?

1. 1Create a user and install the 32-bit libraries

   SteamCMD is a 32-bit program, so it needs the 32-bit C and C++ runtime. These packages exist on Debian 12, Debian 13 and Ubuntu 24.04 without enabling i386:

   sudo apt update
   sudo apt install -y curl ca-certificates tar unzip lib32gcc-s1 lib32stdc++6 lib32z1
   sudo useradd --system --create-home --home-dir /opt/rust --shell /usr/sbin/nologin rust
   sudo -u rust -H mkdir -p /opt/rust/steamcmd /opt/rust/server /opt/rust/logs

2. 2Download SteamCMD

   sudo -u rust -H curl -fsSLo /opt/rust/steamcmd/steamcmd_linux.tar.gz \
     https://steamcdn-a.akamaihd.net/client/installer/steamcmd_linux.tar.gz
   sudo -u rust -H tar -xzf /opt/rust/steamcmd/steamcmd_linux.tar.gz -C /opt/rust/steamcmd

3. 3Install the server, app 258550

   No Steam account is needed to download the server, but the login must be anonymous; without it SteamCMD fails with No subscription. Put +force_install_dir before +login:

   sudo -u rust -H /opt/rust/steamcmd/steamcmd.sh +force_install_dir /opt/rust/server \
     +login anonymous +app_update 258550 validate +quit

   The first run updates SteamCMD itself, then downloads several gigabytes. When it prints Success! App '258550' fully installed., the server is in /opt/rust/server.

How do I start the server with the right parameters?

Put the launch line in a script. It updates the server first, so a restart after Facepunch’s monthly patch picks up the new build, and then replaces itself with the server process so systemd can watch it:

#!/bin/bash
cd /opt/rust/server

# 1. update (keep going on the old build if Steam is unreachable)
/opt/rust/steamcmd/steamcmd.sh +force_install_dir /opt/rust/server \
  +login anonymous +app_update 258550 +quit || echo "update failed, starting current build"

# 2. Oxide only: re-apply it, because the update above restores vanilla files
# curl -fsSLo /tmp/oxide.zip https://github.com/OxideMod/Oxide.Rust/releases/latest/download/Oxide.Rust-linux.zip \
#   && unzip -oq /tmp/oxide.zip -d /opt/rust/server

export LD_LIBRARY_PATH="/opt/rust/server:/opt/rust/server/RustDedicated_Data/Plugins/x86_64"

# 3. Carbon only: load its environment before the server starts
# source /opt/rust/server/carbon/tools/environment.sh

exec ./RustDedicated -batchmode \
  +server.identity "main" \
  +server.port 28015 +server.queryport 28017 \
  +rcon.port 28016 +rcon.web 1 +rcon.password "change-me-to-a-long-random-string" \
  +app.port 28082 \
  +server.level "Procedural Map" +server.seed 12345 +server.worldsize 3500 \
  +server.maxplayers 50 \
  +server.hostname "My Rust Server" \
  +server.saveinterval 300 \
  -logfile /opt/rust/logs/rust.log

sudo nano /opt/rust/start.sh          # paste the script, set your own RCON password
sudo chown rust:rust /opt/rust/start.sh
sudo chmod 750 /opt/rust/start.sh

• server.identity names the save folder: everything for this server lands in /opt/rust/server/server/main/, including its cfg folder.
• server.seed (any whole number) and server.worldsize (1000–6000) decide the procedural map. The same pair always gives the same map; bigger maps need more RAM and disk.
• server.saveinterval is the autosave interval in seconds.
• The LD_LIBRARY_PATH line lets the server find the libraries it ships with. Without it some installs stop at start with [Raknet] Server Shutting Down.

Keep ports and RCON on the command line and everything else in /opt/rust/server/server/main/cfg/server.cfg, without the leading +, for example server.description "Weekly wipe, EU". Per Facepunch’s guide, a value in this file wins over the same setting on the command line, and the server never edits the file itself.

How do I keep it running with systemd?

A unit starts the server on boot and brings it back whenever the process ends. Rust shuts down on Ctrl+C, which is SIGINT, and that is how LinuxGSM stops it too. So tell systemd to send SIGINT instead of its default SIGTERM, and give it time to finish:

[Unit]
Description=Rust dedicated server
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
User=rust
Group=rust
WorkingDirectory=/opt/rust/server
ExecStart=/opt/rust/start.sh
KillSignal=SIGINT
TimeoutStopSec=120
Restart=always
RestartSec=15

[Install]
WantedBy=multi-user.target

sudo systemctl daemon-reload
sudo systemctl enable --now rust
sudo tail -f /opt/rust/logs/rust.log      # wait for "Server startup complete"

The first start generates the map and takes several minutes. Until the log says Server startup complete, players cannot join. Use sudo systemctl status rust to see whether the service itself is running, and the log file for what the game is doing.

Restart=always means a crash, or a restart or quit sent over RCON, starts the server again through start.sh, so it picks up any pending update on the way. Only systemctl stop rust keeps it down. Before a planned stop, run server.save over RCON so nothing since the last autosave is lost.

How do I open the firewall?

Open the game, query and Rust+ ports to everyone, and RCON only to your own address. Allow SSH before you enable ufw, as the ufw guide explains, or you lock yourself out:

sudo ufw allow OpenSSH                    # first, if ufw is not active yet
sudo ufw allow 28015/udp comment 'Rust game'
sudo ufw allow 28017/udp comment 'Rust query'
sudo ufw allow 28082/tcp comment 'Rust+'
sudo ufw allow from 203.0.113.7 to any port 28016 proto tcp comment 'Rust RCON, my IP'
sudo ufw enable
sudo ufw status numbered

Replace 203.0.113.7 with your own public IP address.

How do I make myself admin and use RCON?

The Linux server console is not interactive, so admin commands go through RCON. With rcon.web 1, RCON is a WebSocket on port 28016, and Facepunch’s browser console and most desktop RCON tools speak it. The connection is not encrypted, sotunnel it over SSH rather than opening the port wider:

ssh -L 28016:127.0.0.1:28016 you@203.0.113.10
# then point your RCON client at 127.0.0.1:28016 with the RCON password

In the RCON console, run users while you are connected in game to see your SteamID64, then ownerid 7656119XXXXXXXXXX "YourName". Reconnect to get the auth level. The same line can go into server/main/cfg/users.cfg while the server is stopped.

When do Rust servers wipe, and how do I wipe mine?

Facepunch ships its monthly update on the first Thursday of every month, and that update forces a map wipe on every server. Blueprints are not forced each month: they reset only when you delete them, or in the occasional month when Facepunch announces a forced blueprint wipe. Between forced wipes, your schedule is your own; weekly and biweekly map wipes are common on busy servers.

After a forced update the server normally writes its save under a new file name, because the name carries a save version number, and ignores the old one. The map then resets on its own once you restart on the new build. For a wipe of your own, stop the server and move the files out of the identity folder. Moving instead of deleting gives you a way back:

sudo systemctl stop rust
sudo -u rust -H bash                       # a shell as the rust user
cd /opt/rust/server/server/main
shopt -s nullglob                          # patterns with no match expand to nothing
ls -lh                                     # look before you move anything
mkdir -p /opt/rust/wipes/$(date +%F)
mv -- *.map *.sav *.sav.* /opt/rust/wipes/$(date +%F)/        # map wipe
mv -- player.blueprints.*.db /opt/rust/wipes/$(date +%F)/      # blueprint wipe, optional
exit
sudo systemctl start rust

Change server.seed in start.sh before the restart if you want a different map; keep it to regenerate the same one. Leave the other files alone: the identity folder also holds cfg/ and companion.id, the file that ties your server to Rust+. Deleting that one forces every player to pair again.

Should I use Oxide or Carbon for plugins?

Use one, never both. Oxide (uMod) is the long-standing framework and most plugins are written for it. Carbon is a newer framework built to run most Oxide plugins as they are. The practical difference on a VPS is what happens when Rust updates:

• Oxide replaces files inside the server, so every SteamCMD update puts the vanilla files back. Re-extract the latest Oxide.Rust-linux.zip after each update, which is what the commented lines in start.sh do. Plugins go in oxide/plugins.
• Carbon is unpacked once from Carbon.Linux.Release.tar.gz on top of the server folder, and its carbon/tools/environment.sh must be sourced before RustDedicated starts. Plugins go in carbon/plugins.

sudo systemctl stop rust
sudo -u rust -H curl -fsSLo /tmp/carbon.tar.gz \
  https://github.com/CarbonCommunity/Carbon/releases/download/production_build/Carbon.Linux.Release.tar.gz
sudo -u rust -H tar -xzf /tmp/carbon.tar.gz -C /opt/rust/server
# now uncomment the "source .../environment.sh" line in /opt/rust/start.sh
sudo systemctl start rust

Why can’t players find or join my server?

• Not in the server browser: the query port is closed or wrong. Check that UDP 28017 is open and that the log shows the server finished starting. Joining by address still works without it: press F1 in game and run connect 203.0.113.10:28015.
• Timeouts when joining: UDP 28015 is blocked, or the server is still generating the map. sudo ss -ulpn | grep Rust shows which UDP ports the process really listens on.
• Rust+ says the server is offline: the log shows Rust+ companion server connectivity test failed. Open TCP 28082 and keep app.port at 10000 or higher.
• The process dies with Killed: the machine ran out of memory. Check sudo dmesg -T | grep -i oom, then see why Linux kills a process. The real fix is more RAM, a smaller map or fewer plugins.
• Wrong country in the browser: Facepunch uses MaxMind’s location data. Their wiki links a correction request form.

Which VPS plan fits a Rust server?

Pick the plan by memory first and cores second. Our Hi-CPU KVM line runs on AMD EPYC with ECC memory in Amsterdam and is built for game servers that lean on a few busy threads; its plans range from 2 to 28 GB of RAM, so a Rust server belongs at the 16 GB end or above. If you need more memory per euro, or a large-map server past 28 GB, Standard KVM goes up to 64 GB on Intel. Both include always-on DDoS mitigation at no extra cost, which matters for a public game server (more in DDoS-protected VPS), and the panel gives you a browser VNC console for when SSH is gone and backups to take before a big update. To size Rust against eight other games on both lines, see gaming VPS.

For a smaller game first, the same pattern of service user, systemd unit and firewall is in our Minecraft server guide.

Frequently asked