RedM Dedicated Server on Ubuntu 24.04 — VORP, RSG Core & txAdmin

A production-quality walkthrough for a RedM (Red Dead Redemption 2 multiplayer) dedicated server on Ubuntu 24.04 LTS. Covers the CFX license workflow, MariaDB, txAdmin, a comparison of the four major roleplay frameworks (VORP, RSG Core, RedEM:RP, Vanilla), server.cfg tuning, systemd integration, security hardening, and real-world troubleshooting. Written from actually running RedM servers — not copy-pasted from the Cfx docs.

01 // Requirements

• VPS — Ubuntu 24.04 LTS (22.04 also works). 4 GB RAM minimum for vanilla, 8 GB for a framework + 30 players, 16 GB for serious roleplay with 50+ scripts.
• CFX license key — free from keymaster.fivem.net. One key per server IP. Required or sv_licenseKey returns "invalid" on boot.
• MariaDB 10.11+ or MySQL 8.0+ — all serious RedM frameworks (VORP, RSG Core, RedEM:RP) store player data in SQL. Vanilla servers can skip this.
• Ports — 30120/tcp and 30120/udp for the game, 40120/tcp for txAdmin panel (bind to localhost + reverse proxy for production).
• Non-root user — never run the server as root. Create a dedicated redm user in section 02.
• RDR2 on Steam, Epic, or Rockstar — RedM requires players own a legitimate copy. Anti-piracy enforcement is real (see section 13).

02 // System Prep & Dedicated User

Fresh Ubuntu 24.04 install. Update, install baseline packages, and create a non-root user for the server process.

# Update the system
apt update && apt upgrade -y

# Baseline packages
apt install -y curl wget xz-utils unzip git screen \
    build-essential pkg-config libssl-dev \
    ufw fail2ban

# Create the redm user with a home directory
adduser --disabled-password --gecos "" redm

# Allow redm user to write to /opt/redm for the server files
mkdir -p /opt/redm
chown redm:redm /opt/redm

Enable the firewall with the ports RedM needs:

ufw allow OpenSSH
ufw allow 30120/tcp
ufw allow 30120/udp
# txAdmin — bind to localhost only in production, see section 11
# ufw allow 40120/tcp   # only if you must reach it from outside
ufw enable
ufw status verbose

03 // CFX License from Keymaster

Every RedM server needs a license key from Cfx.re's keymaster. Keys are free, tied to your Cfx forum account, and scoped to a specific server IP.

1. Go to https://keymaster.fivem.net (yes, even for RedM — Cfx uses the same keymaster for both).
2. Log in with your Cfx forum account (create one if needed).
3. Click "+ New" and fill in the form:
   • Server IP: the public IPv4 of your VPS. Use 0.0.0.0 only if you know your IP will change — 0.0.0.0 keys have harder rate limits and worse ranking in the server browser.
   • Server Type: pick RedM (not FiveM).
   • Label: something you'll recognize later, like prod-rp-main.
4. Generate the key. It looks like cfxk_xxxxxxxxxxxxxxxxxxx_yyyyy. Save it — you'll paste it into server.cfg as sv_licenseKey in section 07.

04 // MariaDB Install & Database

Every serious framework (VORP, RSG Core, RedEM:RP) needs MariaDB for player data, inventory, characters, and jobs. Skip this section only if you are running pure vanilla with no persistence.

# Install MariaDB
apt install -y mariadb-server

# Secure the install — set a root password, remove anon users, disallow remote root
mysql_secure_installation

# Log in as root to create the redm database
mariadb -u root -p

Inside the MariaDB prompt:

CREATE DATABASE redm CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
CREATE USER 'redm'@'localhost' IDENTIFIED BY 'CHANGE_THIS_TO_A_LONG_RANDOM_PASSWORD';
GRANT ALL PRIVILEGES ON redm.* TO 'redm'@'localhost';
FLUSH PRIVILEGES;
EXIT;

Quick sanity test the credentials work before you bake them into server.cfg:

mariadb -u redm -p redm -e "SELECT VERSION();"

05 // Download the RedM Server Artifact

The server binary is distributed as a Linux artifact from Cfx.re. Artifacts update frequently — always grab the current recommended build from the artifacts page, not a random "latest" one.

# Switch to the redm user
su - redm
cd /opt/redm

# Grab the latest recommended Linux artifact URL from:
#   https://runtime.fivem.net/artifacts/fivem/build_proot_linux/master/
# Copy the link to the most recent "recommended" build (not bleeding-edge).
# Example — replace VERSION and HASH with the current values:
mkdir -p server alpine && cd alpine
wget https://runtime.fivem.net/artifacts/fivem/build_proot_linux/master/VERSION-HASH/fx.tar.xz
tar xf fx.tar.xz
rm fx.tar.xz

Grab the cfx-server-data repository — this is the resource scaffolding every server builds on:

cd /opt/redm
git clone https://github.com/citizenfx/cfx-server-data.git server-data

Your layout should now look like:

/opt/redm/
├── alpine/           # server artifact (run.sh, FXServer, etc.)
└── server-data/      # resources/, server.cfg (we'll create this)

06 // txAdmin Setup Wizard

txAdmin is the official Cfx management layer — a web panel that runs in front of FXServer and handles the wizard-style initial setup, player moderation, deployment, scheduled restarts, live console, and monitoring. It ships inside the artifact, so you already have it.

# As the redm user, start the artifact — first run launches txAdmin
cd /opt/redm
./alpine/opt/cfx-server/run.sh

On first boot txAdmin prints a URL and a PIN in the console, something like:

[txAdmin] Access this URL to enter the setup:
  http://<your-server-ip>:40120/addMaster/pin?pin=1234

Open that URL in your browser and follow the wizard:

1. Create master account — links your Cfx forum account as the txAdmin owner. Use a strong password.
2. Pick deployment mode:
   • Popular Recipe — one-click install of a framework (VORP, RSG Core, RedEM:RP). Fastest path to a working RP server.
   • Remote URL — deploy any git repo recipe URL.
   • Existing folder — point at /opt/redm/server-data for a from-scratch vanilla build.
3. Paste your CFX license key (from section 03).
4. Paste DB credentials — hostname localhost, port 3306, user redm, password from section 04, database redm.
5. Set server name, max clients, locale — standard stuff. Max clients of 32 is a sensible start; scale up when you know the box handles it.

07 // Framework Comparison — VORP vs RSG Core vs RedEM:RP vs Vanilla

Picking the right framework upfront saves weeks of rework. Here is the 2026 state of the four serious options:

08 // server.cfg Tuning

Your server.cfg lives in /opt/redm/server-data/server.cfg. Here's a production-ready starting point. The lines marked CRITICAL are non-negotiable.

# ---- CRITICAL: this MUST be rdr3 or your server will not appear in the RedM browser
sv_gametypeName "Red Dead Redemption 2"
sv_projectName "My RedM Server"
sv_projectDesc "Western roleplay — VORP framework"

# ---- CRITICAL: tells the server it's RedM, not FiveM
setr gameName "rdr3"

# ---- CRITICAL: your keymaster license key (section 03)
sv_licenseKey "cfxk_xxxxxxxxxxxxxxxxxxx_yyyyy"

# Networking
sv_endpointprivacy true
sv_maxclients 32
sv_hostname "ˆ6[ˆ1EUˆ6] My RedM Server ˆ0| VORP | Whitelist"

# OneSync (required for RedM, keep on)
onesync on
set onesync_population true
set onesync_enableInfinity true    # only needed for 64+ slots

# Steam Web API key (optional but useful for steam identifiers)
set steam_webApiKey ""

# txAdmin convars
set txAdminServerMode "true"

# Resources — load order matters. Framework first, then its dependencies, then content.
ensure mapmanager
ensure chat
ensure spawnmanager
ensure sessionmanager-rdr3
ensure basic-gamemode

# ---- Framework resources (example for VORP — uncomment after install)
# ensure oxmysql
# ensure vorp_metadata
# ensure vorp_core
# ensure vorp_inventory
# ensure vorp_character

# ---- Your content resources load last
# ensure my-custom-jobs
# ensure my-custom-shops

09 // First Connect & Framework Install

Start the server manually to verify it boots cleanly before wiring up systemd:

cd /opt/redm/server-data
bash ../alpine/opt/cfx-server/run.sh +exec server.cfg

Watch the console for the boot sequence. Healthy output looks like:

[  script:svadhesive] Authenticated with license server.
[       c-scripting-core] Started resource sessionmanager-rdr3
[       c-scripting-core] Started resource chat
...
Server is now listening on port 30120

Launch RedM on your PC, open the console (F8), and run:

connect your.server.ip.here:30120

If you chose a txAdmin recipe (VORP / RSG Core / RedEM:RP), the framework is already installed and configured. If you went the vanilla route and plan to add a framework now, here's the VORP install outline:

1. Clone the VORP Core repo into server-data/resources/[vorp]/vorp_core/ per the VORP install docs.
2. Install oxmysql into resources/[standalone]/oxmysql/.
3. Import the VORP SQL schema: mariadb -u redm -p redm < vorp_schema.sql.
4. Uncomment the VORP ensure lines in server.cfg.
5. Restart. Check the console for any Failed to start resource errors — each one points at a missing dependency or SQL connection issue.

10 // Systemd Service

Running the server in a screen session works for testing, but production needs systemd — auto-restart on crash, boot-time startup, and clean log integration with journalctl.

Create /etc/systemd/system/redm.service as root:

[Unit]
Description=RedM Dedicated Server
After=network.target mariadb.service
Requires=mariadb.service

[Service]
Type=simple
User=redm
Group=redm
WorkingDirectory=/opt/redm/server-data
ExecStart=/bin/bash /opt/redm/alpine/opt/cfx-server/run.sh +exec server.cfg
Restart=on-failure
RestartSec=10
LimitNOFILE=65536

# Hardening
NoNewPrivileges=true
PrivateTmp=true
ProtectSystem=full
ProtectHome=true

[Install]
WantedBy=multi-user.target

Enable and start:

systemctl daemon-reload
systemctl enable redm
systemctl start redm

# Check it came up cleanly
systemctl status redm
journalctl -u redm -f    # tail live logs (Ctrl+C to exit)

11 // Backups — Database + Resources

Two things need backing up on a RedM server: the MariaDB database (player characters, inventory, bank balances — the stuff players will rage about if it's gone) and the resources directory (your custom scripts, configs, assets).

Create /usr/local/bin/redm-backup.sh:

#!/bin/bash
set -euo pipefail

BACKUP_DIR="/var/backups/redm"
STAMP=$(date +%Y%m%d-%H%M%S)
DB_USER="redm"
DB_PASS="your-db-password-here"
DB_NAME="redm"

mkdir -p "$BACKUP_DIR"

# SQL dump — compressed
mariadb-dump -u "$DB_USER" -p"$DB_PASS" --single-transaction --quick \
    "$DB_NAME" | gzip > "$BACKUP_DIR/db-$STAMP.sql.gz"

# Resources tarball (excludes the artifact, we only back up server-data)
tar czf "$BACKUP_DIR/resources-$STAMP.tar.gz" \
    -C /opt/redm server-data

# Keep last 14 days
find "$BACKUP_DIR" -type f -mtime +14 -delete

Make executable, test once manually, then schedule:

chmod 700 /usr/local/bin/redm-backup.sh
/usr/local/bin/redm-backup.sh              # test run
ls -lh /var/backups/redm                   # confirm files written

# Cron — daily at 04:30 local time
echo "30 4 * * * root /usr/local/bin/redm-backup.sh" > /etc/cron.d/redm-backup

12 // Custom Resources & Anti-Piracy

RedM's resource ecosystem is split between free community scripts (GitHub, Cfx forums) and paid scripts (Tebex stores). Two hard rules will save you pain:

1. Never download from "leaked" script sites or Discord leak servers. Cfx.re actively monitors for pirated paid resources — when they detect a known leaked script fingerprint, the server gets an anti-piracy flag. Flagged servers are silently removed from the public server browser, stop receiving asset updates, and in some cases get their CFX license revoked. There is no appeal process worth the risk.
2. Always buy from the original author's Tebex or official store. Yes, good scripts cost €15–€50. That's cheap insurance against losing your whole server's server-browser visibility and community.

Installing a custom resource is mechanically trivial:

# Drop the resource folder into server-data/resources/
cp -r my-custom-job /opt/redm/server-data/resources/

# Add it to server.cfg
echo 'ensure my-custom-job' >> /opt/redm/server-data/server.cfg

# Restart just that resource without a full server restart:
# In txAdmin console or live console:
restart my-custom-job

13 // Security Hardening

The RedM server process itself is reasonably sandboxed, but the VPS around it is where attackers actually get in. Here's the standard hardening pass that applies to any game server box:

• SSH key auth only. Disable password login in /etc/ssh/sshd_config: set PasswordAuthentication no, PermitRootLogin no. Restart sshd. Test from a second terminal before you close the first.
• fail2ban. Already installed in section 02. Default config blocks brute-force SSH. Check with fail2ban-client status sshd.
• UFW minimal surface. Only 22 (SSH), 30120 tcp+udp (RedM) should be publicly reachable. Everything else — txAdmin, MariaDB, nginx reverse proxy — should be localhost-only or IP-whitelisted.
• Unattended security upgrades. apt install unattended-upgrades then dpkg-reconfigure unattended-upgrades. Applies security patches automatically so you don't forget.
• Rotate the CFX license if compromised. If you ever suspect the license leaked (shared a backup publicly, hired a dev who turned out shady), regenerate on keymaster immediately.
• Database isolation. MariaDB in section 04 is already bound to localhost by default. Verify with ss -tlnp | grep 3306 — should only show 127.0.0.1:3306, never 0.0.0.0:3306.
• Resource audit. Periodically grep -r "http://" resources/ looking for plaintext callbacks to sketchy URLs. Compromised paid scripts sometimes phone home or open reverse shells.

14 // Interactive VPS Sizer for RedM

How much VPS do you actually need? Plug your server profile into the calculator:

15 // Troubleshooting — The 12 Most Common RedM Server Issues

16 // Next Steps

• FiveM sibling guide — our full FiveM dedicated server walkthrough. If you ever want to run both a FiveM and a RedM server, the patterns here translate 1:1 — just flip gameName.
• Reverse proxy txAdmin — once your server is stable, put nginx + Let's Encrypt in front of 127.0.0.1:40120 with basic auth. Same pattern as the FastDL nginx vhost, just pointing at a different upstream.
• Pick a managed panel — if txAdmin's UI doesn't fit your workflow, Pterodactyl has community eggs for RedM. More config work up front, much nicer multi-server dashboard.
• Monitor performance — install htop and keep an eye on per-process CPU. RedM's FXServer process should idle under 10% with no players and peak around 40% with a full 32-slot server on a well-tuned framework. Sustained high CPU = a resource leak, not a hardware shortage.
• Join the framework Discord — VORP and RSG Core both have active Discords where breaking-change warnings drop hours before you'd discover them via a broken artifact update. Free early-warning system.

17 // Frequently Asked Questions