How to Run a Rust Dedicated Server on Linux (SteamCMD, Ports, and Persistent Configuration)

iTechGuides is reader-supported. When you buy through links on our site, we may earn an affiliate commission. As an Amazon Associate I earn from qualifying purchases. Learn more

Playing with friends? Godlike.Host runs hosted Rust servers from 10 data-center locations, with free DDoS protection.

You can host a Rust dedicated server on Linux with SteamCMD and the Rust server application (App ID 258550). Install the files in a stable directory, launch RustDedicated with a unique identity and separate UDP game and query ports, and put durable settings in rust/server/<server.identity>/cfg/server.cfg. Forward the ports only when you intend to allow Internet players; for unattended operation, run the launch script under a service manager rather than leaving a terminal open.

The official Facepunch procedure, including Linux installation, startup options, Screen usage, configuration precedence, and networking requirements, is documented at Facepunch’s Rust server guide.

#	Preview	Product	Price
1		Rust Key Cards, Rust Red Key Card, Cobalt Restricted Access Cards, Rust Gift For Gamers, Blue Key...	$25.00	Buy on Amazon
2		Rust Video Game Notebook	$15.00	Buy on Amazon
3		Rust Game Props Large Furnace (S)	$14.99	Buy on Amazon

What the Linux Rust server consists of

A Rust server installation has three practical parts:

• SteamCMD downloads and updates the dedicated-server files.
• RustDedicated is the server process that loads the world and accepts players.
• Your identity directory stores the persistent configuration and world data for one instance.

The identity is supplied with +server.identity. If you run more than one instance on the same host, give each instance a different identity and a different set of ports. Keep the installation in a persistent path such as /home/youruser/rust, not in a temporary directory that may be cleaned during a reboot.

#1 Best Overall

Rust Key Cards, Rust Red Key Card, Cobalt Restricted Access Cards, Rust Gift For Gamers, Blue Key Card, Green Key Card (ALL THREE)

• Inspired by the Rust Video Game – These cards replicate the iconic keycards found in Rust (Red, Blue, Green).
• High Quality PVC Plastic – Printed on both sides, durable and water-resistant. Not a sticker.
• Great Rust Gift Idea – Perfect for fans of Rust, whether for cosplay, loot-themed gifts, or collection.
• Wallet-Size Replica – Standard 3.375x2.125 inches, 30 mil thick—fits in any wallet.
• NOT a sticker*

$25.00

Buy on Amazon

Facepunch does not publish a universal CPU, RAM, storage-performance, or player-capacity baseline in the cited documentation. Actual capacity depends on the map, settings, concurrent players, plugins, and the host’s single- and multi-core performance, so choose resources conservatively and observe CPU, memory, disk, and network use under your expected load.

Prepare a safe Linux layout

Use a dedicated account

Create an unprivileged Linux account for the server and keep its files in that account’s home directory. Do not run RustDedicated as root. A dedicated account limits the damage if a plugin, script, or exposed management interface is compromised.

Choose persistent directories

A simple layout is:

• /home/rust/steamcmd for the SteamCMD script and support files
• /home/rust/rust for the Rust server installation
• /home/rust/runds.sh for your launch script

The names are examples; the important points are that the path is stable, the account owns it, and backups include the server identity directory.

Install RustDedicated with SteamCMD

1. Create the directories

Log in as the dedicated account (or create the directories with that account as owner), then create separate locations for SteamCMD and the Rust files:

mkdir -p /home/rust/steamcmd /home/rust/rust
cd /home/rust/steamcmd

2. Download and unpack Linux SteamCMD

Download the Linux SteamCMD archive from Valve’s official distribution, unpack it in /home/rust/steamcmd, and make the launcher executable:

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

Run SteamCMD from its own directory. Keeping it separate from the Rust destination makes updates easier to reason about and avoids mixing SteamCMD support files with the server data.

3. Install the Rust application

From the SteamCMD directory, install App ID 258550 into the Rust directory with anonymous login:

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

+force_install_dir ../rust makes the destination the sibling /home/rust/rust directory. +login anonymous is the documented installation method, and +app_update 258550 validate installs or verifies the Rust dedicated-server files before SteamCMD exits.

When the command completes, check that the Rust directory contains the downloaded server files and the RustDedicated executable. The exact binary behavior can change with a current build, so use the files delivered by SteamCMD rather than copying an old binary from another installation.

Create an explicit launch script

Start the server from a script rather than typing a long command by hand. The script fixes the working directory, documents the identity and ports, and gives a service manager one stable command to run.

Minimal launch script

Create /home/rust/runds.sh with this pattern:

#!/usr/bin/env bash
set -euo pipefail
cd /home/rust/rust
exec ./RustDedicated -batchmode 
  +server.identity rustserver 
  +server.port 28015 
  +server.queryport 28016 
  +rcon.port 28017 
  +rcon.password 'CHANGE_THIS_LONG_RANDOM_PASSWORD' 
  +rcon.web 1 
  -logfile rustserver.log

Make it executable:

chmod 750 /home/rust/runds.sh

What each startup value does

Use a unique identity for every instance. If you clone this script for a second server, change the identity and all conflicting ports. Keep the command line focused on identity, networking, RCON, and logging; put gameplay and presentation values in the configuration file described next.

Rank #2

Rust Video Game Notebook

$15.00

Buy on Amazon

Put persistent settings in server.cfg

Use the identity-specific path

For the example identity, create:

/home/rust/rust/server/rustserver/cfg/server.cfg

The general pattern is rust/server/<server.identity>/cfg/server.cfg. The file is read at startup and takes priority over command-line values, so it is the durable place for settings you want to survive a restart.

Use plain variable names

Inside server.cfg, do not include the command-line + prefix. A basic file can look like this:

server.hostname "My Linux Rust Server"
server.description "A private community server"
server.maxplayers 20
server.level "Procedural Map"
server.worldsize 3500
server.seed 12345

Quotes are useful for names and descriptions containing spaces. Keep the file readable by the dedicated account and back it up with the identity directory.

Know what server.cfg cannot guarantee

Not every console variable is necessarily applied from server.cfg. Facepunch specifically notes that some values, including certain weather-chance variables, must be set after startup or through RCON. If a value appears in the file but has no effect, check the startup log and apply it after the server is running instead of assuming the file was ignored wholesale.

Open the correct network paths

Game and query ports are separate

For an Internet-accessible server, forward the game port and query port from the router to the Linux host and allow both through the host firewall.

The query port is not an interchangeable second game port. A server can be running and reachable from the local machine while remaining absent from public listings if the query path is blocked. The two UDP ports must be reachable from outside the host and cannot be the same number.

LAN-only versus public hosting

For a LAN-only server, bind and firewall the service for your private network and do not expose router ports to the Internet. Players on the same network can connect without public forwarding, subject to your local firewall rules.

For public hosting, give the Linux machine a stable local address or a DHCP reservation. Otherwise, a reboot can assign a new address and silently invalidate the router’s forwarding rules. Forward only the ports you intend to use. If RCON is enabled, restrict its exposure with firewall rules and use a long, unique password; do not open an administrative interface broadly just because the game ports are public.

Check the host firewall and router together

Both layers must permit traffic: a router rule pointing at the wrong private address fails even when the Linux firewall is correct, and a correct forwarding rule still fails if the host firewall drops the packets. Test from a network outside your LAN rather than relying only on a local connection.

Start and verify the first run

1. Confirm that server.cfg exists under the identity selected by +server.identity.
2. Run /home/rust/runds.sh as the dedicated account.
3. Watch the console and /home/rust/rust/rustserver.log for startup errors, binding failures, or configuration warnings.
4. From the same host, verify that the process remains running after initialization.
5. From a client on the LAN or an external test network, try the server’s address and game port.
6. For public listing, verify the query port separately; a successful local game connection does not prove that browser discovery works.

If a port-binding error appears, look for another Rust instance or service using the same number and change the conflicting configuration. If the process exits immediately, run the script interactively so the final console message is visible, then inspect the log before changing multiple settings at once.

Keep the server running after you disconnect

Screen for an interactive session

GNU Screen is convenient when you want to see a live console and reconnect later. Facepunch documents this invocation:

Rank #3

Rust Game Props Large Furnace (S)

• Acrylic Painting Pla Plastic

$14.99

Buy on Amazon

screen -S rust_server ./runds.sh

Detach without stopping Rust with Ctrl-A, then D. Reconnect with:

screen -x rust_server

Screen is useful for administration and troubleshooting, but it depends on a user session and does not by itself provide a boot-time policy or crash recovery.

Use a service manager for unattended hosting

For a production or community server, place the launch script under systemd (or another supervisor) so it starts after boot and can restart after a crash. A minimal systemd unit, adapted to your chosen paths and account, is:

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

[Service]
User=rust
WorkingDirectory=/home/rust/rust
ExecStart=/home/rust/runds.sh
Restart=on-failure
RestartSec=10

[Install]
WantedBy=multi-user.target

Save it as a system service, reload the manager, enable it for boot, and start it. Keep the launch script as the single source of startup arguments so Screen, systemd, and manual maintenance all use the same identity and ports. Test a controlled stop and restart before relying on automatic recovery.

Control log growth

The -logfile option is valuable for diagnosing crashes and plugin errors, but a continuously growing file can consume the disk. Configure log rotation appropriate to your Linux distribution and retain enough history to investigate a failed update without allowing unbounded growth.

Update safely with SteamCMD

1. Announce a maintenance window and stop the server cleanly through your service manager or running session.
2. From the SteamCMD directory, run the same update command used for installation:

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

3. Start RustDedicated again with /home/rust/runds.sh or your service manager.
4. Read the log for protocol, startup, or plugin errors before declaring the update complete.
5. Confirm that the identity directory and configuration are still present, then test a client connection and browser listing.

SteamCMD is the installation and update mechanism. Do not hide an update inside the startup script unless you intentionally want every boot to update first. Facepunch warns that doing so keeps the installation vanilla; that is suitable for an unmodded server but can overwrite or conflict with Oxide/uMod or other extensions.

Modded-server considerations

Separate the Rust update step from the launch step when you run plugins or other extensions. Stop the server, update the vanilla files during a maintenance window, then verify that every extension supports the new Rust build before allowing players back in. Keep a copy of the identity directory and any extension-specific files before major updates or wipes so you can recover configuration and world data.

A clean vanilla launch is a useful diagnostic baseline. If the vanilla server starts and accepts connections but the modded launch fails, compare the post-update log for plugin loading, protocol, and missing-file errors rather than changing ports or deleting the identity directory immediately.

Backups, security, and routine operations

• Back up the identity directory: include rust/server/rustserver (or the identity you chose) before wipes and major updates.
• Protect credentials: keep RCON passwords long and unique, limit file permissions, and firewall the RCON port to trusted administration networks.
• Use least privilege: run SteamCMD, RustDedicated, and the supervisor as the dedicated unprivileged account.
• Preserve a stable address: use a DHCP reservation or equivalent local-address reservation for public forwarding.
• Monitor disk space: logs and world data grow over time; rotation and free-space alerts prevent an avoidable outage.
• Schedule maintenance: update during a window when players are not expecting uninterrupted access, and check the log after every restart.
• Document each instance: record its identity, game port, query port, RCON policy, and backup location so a second server cannot accidentally reuse the first server’s values.

Self-hosting or managed infrastructure?

The official documentation explains how the software, ports, and configuration work, but it does not establish a price, performance guarantee, or player-capacity limit. If you are deciding between your own Linux machine and managed infrastructure, compare the following concrete responsibilities:

• Monthly cost: include the host, storage, bandwidth, backups, and any management fee.
• Compute and storage: ask which CPU resources, RAM, and disk performance are reserved rather than shared.
• Network protection: check DDoS mitigation, bandwidth limits, and whether you can control firewall and forwarding rules.
• Control: confirm support for custom ports, server identities, plugins, RCON policy, and scheduled maintenance.
• Backups: determine retention, restore procedure, and whether you can download an identity-directory backup.
• Geography and latency: choose a location close to the intended player base and test routes from their regions.
• Automation and support: evaluate update controls, reboot behavior, log access, and the response time for an outage.

Self-hosting gives you direct control over Linux, ports, files, and update timing, but you also own firewalling, backups, monitoring, and recovery. Managed infrastructure can reduce those operational tasks, while the provider’s controls and policies determine how much access you retain.

Quick Recap

Bestseller No. 1

Rust Key Cards, Rust Red Key Card, Cobalt Restricted Access Cards, Rust Gift For Gamers, Blue Key Card, Green Key Card (ALL THREE)

Wallet-Size Replica – Standard 3.375x2.125 inches, 30 mil thick—fits in any wallet.; NOT a sticker*

$25.00

Bestseller No. 2

Rust Video Game Notebook

$15.00

Bestseller No. 3

Rust Game Props Large Furnace (S)

Acrylic Painting Pla Plastic

$14.99

Troubleshooting by symptom

The server starts but is not listed

• Confirm that server.queryport is set and is different from server.port.
• Allow the query port as UDP in the Linux firewall and forward it to the correct private address.
• Test from outside the LAN; local success does not prove public query reachability.
• Read the startup log for binding errors or a different identity than the one you configured.

Players cannot connect from outside the LAN

• Verify the game port is forwarded as UDP to the host’s current stable address.
• Check the host firewall and router rule together.
• Make sure no second process is already using the configured port.
• For a LAN-only design, do not expect an Internet connection to work without deliberately exposing the service.

Settings revert after a restart

• Check that the file is exactly rust/server/<server.identity>/cfg/server.cfg.
• Ensure the identity in the path matches +server.identity in the launch script.
• Remove the + prefix from variable names inside the file.
• Remember that some console variables must be applied after startup or through RCON.

An update breaks plugins

• Stop the server and preserve a backup of the identity directory.
• Review the log for protocol and plugin-loading errors.
• Check extension compatibility before restoring public access.
• Keep future SteamCMD updates separate from the launch command so you can control when compatibility checks occur.

Final pre-launch checklist

1. SteamCMD is installed in its own directory and App ID 258550 is present in the Rust directory.
2. The launch script is executable, uses an explicit identity, and starts from the correct working directory.
3. server.port and server.queryport are distinct UDP ports.
4. Router forwarding and host-firewall rules match the intended LAN-only or public design.
5. server.cfg is under the selected identity and contains plain variable names.
6. RCON is disabled when unnecessary or protected by a strong secret and restricted firewall rules.
7. The server runs under Screen for a quick interactive session or under a tested service manager for unattended operation.
8. Logs are retained and rotated, and the identity directory is included in backups.
9. After each update, the log, a client connection, and (for public servers) browser visibility are checked.

Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.