Host a Rust Dedicated Server

The only aim in Rust is to survive. To do this you will need to overcome struggles such as hunger, thirst and cold. Build a fire. Build a shelter. Kill animals for meat. Protect yourself from other players, and kill them for meat. Create alliances with other players and form a town. Do whatever it takes to survive.

Skip the Setup — Deploy Now or read the full guide below

Requirements Setup Guide Installation

Hardware Requirements

Here's what you need to run a Rust dedicated server.

Economy

Small server, 1-40 players

CPU0.5 cores

RAM4 GB

Storage10 GB SSD

Standard

Community server, 40-150 players

CPU1 core

RAM8 GB

Storage10 GB SSD

Pro

Large public server, 150-500 players

CPU2 cores

RAM16 GB

Storage10 GB SSD

Start hosting from your own computer

Run a Rust server on your desktop, laptop, VPS, or dedicated machine — GameCP automates Docker setup, resource allocation, and Rust configuration instantly. Automatic port forwarding means your friends can connect without touching your router. Start local, scale to a VPS when you're ready.

Get Started FreeNo credit card required

Setup in 4 Steps

Skip the manual SteamCMD installation, port forwarding, and systemd configuration. Install on your own computer and start hosting instantly.

Step 01

Create a GameCP Account

GameCP gives you a full control panel with Docker containerization, file management, automatic port forwarding, and automatic updates — all built in.

Step 02

Connect Your Hardware

Install GameCP on your own desktop, laptop, VPS, or dedicated machine. One-line install — no SSH expertise needed.

GameCP installs Docker, configures networking, and sets up automatic port forwarding so your friends can connect instantly. Start hosting from your own PC and scale to a VPS later. Supports Windows, macOS, and Linux.

Step 03

Deploy Rust

Select "Rust" from the template library and hit deploy. GameCP handles SteamCMD (App ID: 258550), ports, startup commands, and all configuration automatically.

Uses the aioegg:production image. Everything is configured out of the box. ~10 GB storage.

Step 04

Start Playing

Hit start and share your server address. Automatic port forwarding handles the rest — no router config needed.

GameCP provides live SOURCE console access from your browser. Your friends connect using the address GameCP gives you.

The Manual Way vs. GameCP

Manual Setup

✗Install SteamCMD manually
✗Configure 4+ firewall ports and router settings
✗Write systemd service files
✗SSH into server to edit configs
✗Requires a VPS or dedicated server
✗30-60 minutes if experienced

With GameCP

One-click SteamCMD install
Automatic port forwarding — no router config
Host from your own PC, VPS, or dedicated server
Docker container with auto-restart
Visual config editor in browser
Under 5 minutes total

Under the Hood

The full manual process to host a Rust dedicated server on a VPS. Or install GameCP on your own computer and skip all of this.

Step 1

Configure & Prepare

Set your server settings, then install Docker, SteamCMD, and pull the Rust container image.

Server ConfigurationEdit values to update all commands

Server NameServer name displayed in the server browser

DescriptionServer description shown in browser. Use \n for ne...

Server URLThe URL for your server. Shown when clicking the "...

Server ImageThe header image for the top of your server listin...

Server LogoThe circular server logo for the Rust+ app.

LevelThe world file for Rust to use.

World SizeThe world size for a procedural map.

World SeedThe seed for a procedural map.

Custom Map URLOverwrites the map with the one from the direct do...

Game ModeThe game mode for the server.

Server TagsComma-separated tags for server categorization (e....

RCON PasswordRCON access password.

Modding FrameworkThe modding framework to use.

Modding Root DirectoryRoot directory of the modding framework. Set to 'c...

Save IntervalAuto-save interval in seconds.

Additional ArgumentsAdditional startup parameters to pass to the serve...

terminal

# Update system and install Docker
sudo apt update && sudo apt install -y docker.io
sudo systemctl enable --now docker

# Create game server directory
sudo mkdir -p /opt/gameserver

# Install SteamCMD
sudo mkdir -p /opt/steamcmd
curl -sqL "https://steamcdn-a.akamaihd.net/client/installer/steamcmd_linux.tar.gz" | sudo tar zxvf - -C /opt/steamcmd

# Server configuration
export LEVEL="Procedural Map"
export WORLD_SIZE="3000"
export WORLD_SEED="0"
export GAMEMODE="vanilla"
export FRAMEWORK="vanilla"
export MODDING_ROOT="carbon"
export SAVEINTERVAL="60"

# Pull the container image
docker pull ghcr.io/sturdystubs/aioegg:production

Step 2

Install Server Files via SteamCMD

Download the Rust dedicated server using Steam App ID 258550.

terminal

# Download Rust server files (App ID: 258550)
/opt/steamcmd/steamcmd.sh \
  +force_install_dir /opt/gameserver \
  +login anonymous \
  +app_update 258550 validate \
  +quit

Step 3

Open Firewall Ports

Rust requires 4 ports to be open for game traffic and queries.

terminal

sudo ufw allow 2302/both
sudo ufw allow 28016/both
sudo ufw allow 28017/both
sudo ufw allow 28082/both

2302/BOTH(PORT)28016/BOTH(RCON_PORT)28017/BOTH(QUERY_PORT)28082/BOTH(APP_PORT)

Step 4

Launch the Server

Start the Rust server using the configuration from Step 1.

Create the startup script

terminal

# Create the startup script
cat > /opt/gameserver/start.sh << 'EOF'
#!/bin/bash
# Build startup arguments
ARGS=(-batchmode)
ARGS+=(+server.port 2302)
ARGS+=(+server.queryport 28017)
ARGS+=(+server.identity "rust")
ARGS+=(+rcon.ip 0.0.0.0)
ARGS+=(+rcon.port 28016)
ARGS+=(+rcon.web true)
ARGS+=(+server.hostname "")
ARGS+=(+server.level "Procedural Map")
ARGS+=(+server.maxplayers )
ARGS+=(+app.port 28082)
ARGS+=(+server.saveinterval 60)
ARGS+=(+server.gamemode "vanilla")
# Modding framework
if [ "vanilla" == "oxide" ]; then
ARGS+=(+oxide.directory carbon)
elif [ "vanilla" != "vanilla" ]; then
ARGS+=(-carbon.rootdir carbon)
fi
# Optional fields - only include if value is non-empty
[ -n "" ] && ARGS+=(+server.description "")
[ -n "" ] && ARGS+=(+server.url "")
[ -n "" ] && ARGS+=(+server.headerimage "")
[ -n "" ] && ARGS+=(+server.logoimage "")
[ -n "" ] && ARGS+=(+rcon.password "")
[ -n "" ] && ARGS+=(+server.tags "")
# Map configuration
if [ -z "" ]; then
ARGS+=(+server.worldsize "3000")
ARGS+=(+server.seed "0")
else
ARGS+=(+server.levelurl "")
fi
# Execute
exec ./RustDedicated "[@]}"
EOF
chmod +x /opt/gameserver/start.sh

Run the container

terminal

docker run -d \
  --name rust-server \
  -p 2302:2302/both \
  -p 28016:28016/both \
  -p 28017:28017/both \
  -p 28082:28082/both \
  -e LEVEL="Procedural Map" \
  -e WORLD_SIZE="3000" \
  -e WORLD_SEED="0" \
  -e GAMEMODE="vanilla" \
  -e FRAMEWORK="vanilla" \
  -e MODDING_ROOT="carbon" \
  -e SAVEINTERVAL="60" \
  -v /opt/gameserver:/opt/gameserver \
  -w /opt/gameserver \
  ghcr.io/sturdystubs/aioegg:production \
  ./start.sh

Or skip all of this

GameCP automates every step above: Docker, SteamCMD, port forwarding, startup, and config. Install on your own PC and deploy a Rust server in under 5 minutes.

Deploy with GameCP