Installing a Rust server on Linux

This builds a Rust server from nothing on a 64-bit Linux VPS: SteamCMD, a dedicated non-root user, a start script you can read, and a systemd unit that survives a reboot. Commands are for Debian 12 and Ubuntu 22.04 or newer, with the RHEL family equivalents given where they differ.

You need root or sudo on the server, and a way in. See Connecting to your server if you do not have an SSH session yet.

Install it

1. Create a user for the server

   Rust does not need root and should not have it. A game server that runs as root turns any plugin flaw into a whole-machine problem.

   ShellCopy

   sudo useradd -m -s /bin/bash rust

   Everything below happens inside that account's home directory, /home/rust.

2. Install the SteamCMD prerequisites

   SteamCMD is a 32-bit binary, so a 64-bit host needs the 32-bit C and C++ runtimes even though the Rust server itself is 64-bit.

   On Debian and Ubuntu:

   ShellCopy

   sudo dpkg --add-architecture i386
   sudo apt update
   sudo apt install -y curl tar ca-certificates lib32gcc-s1 lib32stdc++6

   On RHEL, AlmaLinux, and Rocky:

   ShellCopy

   sudo dnf install -y curl tar glibc.i686 libstdc++.i686

3. Install SteamCMD

   Switch to the rust user and unpack it into its own directory:

   ShellCopy

   sudo -u rust -i
   mkdir -p ~/steamcmd && cd ~/steamcmd
   curl -sSL https://steamcdn-a.akamaihd.net/client/installer/steamcmd_linux.tar.gz | tar zx

   Run it once on its own so it can self-update before you ask it for anything:

   ShellCopy

   ~/steamcmd/steamcmd.sh +quit

4. Download the Rust server

   The Rust dedicated server is Steam app 258550 and installs anonymously, with no account and no licence:

   ShellCopy

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

   It is a large download. The same command is how you update later, so keep it somewhere you can copy it from.

5. Link steamclient.so

   The server looks for the Steam client library in a fixed location and fails to start cleanly if it is missing:

   ShellCopy

   mkdir -p ~/.steam/sdk64
   ln -s ~/steamcmd/linux64/steamclient.so ~/.steam/sdk64/steamclient.so

6. Write the start script

   Create /home/rust/server/start.sh:

   ShellCopy

   #!/usr/bin/env bash
   set -euo pipefail
   cd /home/rust/server
    
   exec ./RustDedicated -batchmode -nographics \
     +server.identity "myserver" \
     +server.hostname "My Rust server" \
     +server.description "Weekly wipes. Monthly BP wipe." \
     +server.port 28015 \
     +server.queryport 28017 \
     +rcon.port 28016 \
     +rcon.password "a-long-random-password" \
     +rcon.web 1 \
     +server.maxplayers 100 \
     +server.worldsize 3000 \
     +server.seed 1500000 \
     +server.saveinterval 300 \
     +server.level "Procedural Map"

   Make it executable, and keep it readable only by the server's own user, because the RCON password is sitting in it:

   ShellCopy

   chmod 700 /home/rust/server/start.sh

7. Start it by hand once

   Before wiring up systemd, run it in your own terminal so you can watch it:

   ShellCopy

   /home/rust/server/start.sh

   The first boot generates the map, which takes several minutes and pins a core while it runs. Nothing answers on any port until it finishes, so a server that looks dead in the first few minutes is usually working normally. Wait for the console to report that startup is complete, then press Ctrl+C once and let it save and exit.

The launch arguments that matter

Rust takes its configuration as console variables on the command line, each prefixed with +. These are the ones you will actually set:

World size and seed decide the map

The map is not stored as a design, it is generated. The seed and the world size together are the map: the same pair always produces the same terrain, monuments, and roads, and any other pair produces a different world.

That is why the save file is named after them. Look in your server's identity directory and you will see something in the shape of proceduralmap.<worldsize>.<seed>.<version>.sav.

Size is a direct trade. A larger world takes longer to generate on first boot, holds more monuments and more players comfortably, costs more memory, and takes players longer to cross. Most servers sit in the 3000 to 4500 band, and smaller maps are a legitimate way to make a low-population server feel busy. Pick a size you can afford at the end of a wipe cycle, not one that only fits on wipe day.

If you have no seed preference, any integer works. Once you have one you like, record the seed and size together, because that pair is the only way back to that map.

After the first boot

Starting the server once creates its configuration, under /home/rust/server/server/myserver/cfg/ if your identity is myserver. The doubled server in that path is correct: the first is your install directory, the second is where Rust keeps per-identity data.

Three files there are worth knowing:

• server.cfg, console variables run at startup.
• users.cfg, which holds ownerid and moderatorid lines. This is how you give yourself admin, using your own 17-digit Steam ID.
• bans.cfg.

Edit them while the server is stopped. A running server rewrites users.cfg and bans.cfg itself, so changes made underneath it get overwritten.

Run it under systemd

The remaining commands are run as yourself, not as rust. Type exit to leave the server account first.

Create /etc/systemd/system/rust.service:

[Unit]
Description=Rust dedicated server
After=network-online.target
Wants=network-online.target
 
[Service]
Type=simple
User=rust
Group=rust
WorkingDirectory=/home/rust/server
ExecStart=/home/rust/server/start.sh
Restart=on-failure
RestartSec=15
KillSignal=SIGINT
TimeoutStopSec=180
 
[Install]
WantedBy=multi-user.target

Then:

sudo systemctl daemon-reload
sudo systemctl enable --now rust
sudo systemctl status rust
journalctl -u rust -f

Two lines in that unit are doing real work. KillSignal=SIGINT is what lets Rust save and shut down properly, because it handles an interrupt the way the console does; stopping it with the default signal loses up to one save interval. TimeoutStopSec=180 gives that save time to finish before systemd kills the process outright. The start script deliberately does not pass -logfile, so output goes to the journal where journalctl can follow it.

The manual update, which is also what you run on the first Thursday of each month:

sudo systemctl stop rust
sudo -u rust /home/rust/steamcmd/steamcmd.sh \
  +force_install_dir /home/rust/server \
  +login anonymous \
  +app_update 258550 validate \
  +quit

Update Oxide or Carbon at this point, while the server is still stopped, then start it:

sudo systemctl start rust

Open the ports

The server is running, but nothing reaches it until the ports are open at the network edge. For the start script above that is UDP 28015, UDP 28017, and TCP 28016. Add a rule per port and protocol under Port rules, or apply the Rust entry in Game presets and add the query port yourself.

If the server runs but players cannot reach it, work through When players cannot connect.

Related