Deploying a Vanilla Rust Server via LinuxGSM

Rust is one of the most demanding survival sandboxes in the Unity ecosystem. A 4000 unit procedural map can spend several minutes generating on first boot, and a populated wipe night can push the server process well past 8 GB of resident memory. LinuxGSM (Linux Game Server Manager) wraps every painful step of that lifecycle behind a single curated shell wrapper, so you can focus on tuning the experience instead of fighting SteamCMD.

This guide walks through a complete vanilla Rust deployment on Ubuntu 24.04 LTS using LinuxGSM. We will create a hardened service user, install the server, configure RCON for remote administration, and finish with a cron driven weekly wipe so your community always logs into a fresh map every Thursday evening.

Prerequisites

• Ubuntu 24.04 LTS, freshly provisioned, with at least 16 GB of RAM (Rust will use most of it).
• 4 dedicated vCPU cores or better. Map generation is single threaded and benefits from high clock speed.
• 40 GB of SSD storage. A populated wipe with maps and backups easily consumes 25 GB.
• Root or sudo access for the initial package installation.
• UDP port 28015 and TCP port 28016 (RCON) open at the firewall.

Step 1: Create a Dedicated Service User

Running game servers as root is a non starter for production. LinuxGSM is built around a per game system user, which keeps file ownership, cron jobs, and process isolation clean.

$adduser --system --shell /bin/bash --group --disabled-password --home /home/rustserver rustserver
$usermod -aG sudo rustserver
$su - rustserver

Step 2: Install LinuxGSM Dependencies

Rust requires SteamCMD plus a fairly large set of 32 bit support libraries, even on a 64 bit host. The LinuxGSM project maintains an authoritative dependency list, but you can install everything in one apt invocation.

$dpkg --add-architecture i386
$apt update
$apt install -y curl wget file tar bzip2 gzip unzip bsdmainutils python3 \
$  util-linux ca-certificates binutils bc jq tmux netcat-openbsd lib32gcc-s1 \
$  lib32stdc++6 libsdl2-2.0-0:i386 steamcmd

Step 3: Fetch LinuxGSM and Install Rust

Drop back into the rustserver user and pull the LinuxGSM bootstrap script. The rustserver binary is a thin alias the installer creates for the linuxgsm.sh dispatcher.

$cd ~
$wget -O linuxgsm.sh https://linuxgsm.sh
$chmod +x linuxgsm.sh
$bash linuxgsm.sh rustserver
$./rustserver auto-install

The auto installer downloads roughly 6 GB of Rust server binaries from Steam, generates a default config under lgsm/config-lgsm/rustserver/, and writes the procedural seed to disk. Expect this to take 10 to 20 minutes depending on your network throughput.

Step 4: Core Configuration and RCON

LinuxGSM keeps overrides in ~/lgsm/config-lgsm/rustserver/rustserver.cfg. Anything you put in that file beats the defaults shipped with the script. The most important values for a public vanilla server are the hostname, the world size, the seed, and the RCON password.

$servername="My Vanilla Rust Server"
$serverdescription="Weekly wipe every Thursday at 19:00 UTC"
$serverhostname="rustkings.example.com"
$rconpassword="REPLACE_WITH_A_LONG_RANDOM_STRING"
$servermaxplayers=150
$serverworldsize=4000
$serverseed=1337
$servertickrate=30
$saveinterval=300
$gamemode="vanilla"

Start the server with ./rustserver start. Tail the live console output with ./rustserver console (detach with Ctrl b then d because LinuxGSM hosts the server inside tmux). Once the boot completes you can attach a remote admin tool such as RustAdmin or Rcon.io to tcp://your.ip:28016 using the password set above.

Step 5: Automated Weekly Wipes via Cron

Rust convention is to wipe procedural maps weekly, on Thursday, to keep the loot economy fresh. A wipe is simply the deletion of the map file plus the player blueprint database before the next boot, which forces a brand new world generation. LinuxGSM ships a wipe hook out of the box, but we want predictable behavior, so we will scrub the files explicitly.

$crontab -e
$# Stop server, wipe map and blueprints, restart, every Thursday at 19:00 UTC
$0 19 * * 4 /home/rustserver/rustserver stop && \
$  find /home/rustserver/serverfiles/server/rustserver -maxdepth 1 \
$    -type f \( -name "*.map" -o -name "*.sav" -o -name "*.sav.*" \) -delete && \
$  /home/rustserver/rustserver start

For a full BP wipe (blueprints reset alongside the map), add the player.blueprints file to the find expression. Keep the find command anchored with -maxdepth 1 so a typo can never cascade into deleting unrelated host data.

Performance and Tuning

• Pin the server to performance CPU cores with taskset if the host is shared. Rust is extremely sensitive to scheduler jitter.
• Bump servertickrate from 10 to 30 only if your hardware can sustain it without spiking server frame time above 50 ms.
• Run ./rustserver mods-install to enable the Oxide modding framework if you plan to add quality of life plugins later.
• Configure ./rustserver backup on a daily timer and ship the resulting archive offsite. The procedural seed plus your wipe schedule is enough to reproduce the world, but player saves are irreplaceable.

Conclusion

You now have a fully vanilla Rust server running under a dedicated system user, administered over RCON, and automatically refreshed every Thursday night. Because LinuxGSM normalizes every Steam call and configuration path, future patches reduce to ./rustserver update, and disaster recovery is a single ./rustserver backup away. Layer Oxide on top later if your community wants quality of life plugins, but resist the urge to add plugins on launch day. Get the vanilla baseline stable first, then iterate.