--- title: "Cómo instalar un servidor de Rust en Ubuntu 24.04" description: "Instala un servidor de Rust en Ubuntu 24.04 con SteamCMD, ejecútalo con systemd, abre los puertos, añade plugins con Oxide y aprende a hacer el wipe del mapa." category: "Servidores de Juegos" language: es source: https://cubepath.com/es/docs/servidores-de-juegos/instalacion-del-servidor-de-juego-rust-en-linux updated: 2026-09-25 --- # Cómo instalar un servidor de Rust en Ubuntu 24.04 Rust incluye un servidor dedicado para Linux, `RustDedicated`, que se descarga de forma anónima con SteamCMD. Tener tu propio servidor te permite elegir el tamaño del mapa, el número de jugadores, la frecuencia de los wipes y los plugins que se usan. En este tutorial instalarás el servidor de Rust en Ubuntu 24.04, lo ejecutarás como servicio systemd con su propio usuario, abrirás los puertos, añadirás el framework de plugins Oxide y verás cómo hacer un wipe del mapa. ## Requisitos previos Para seguir esta guía necesitas: - Un servidor con Ubuntu 24.04 LTS (x86_64), por ejemplo un VPS de CubePath. Rust es exigente: calcula al menos 4 núcleos de CPU con buena frecuencia y 12 GB de RAM para un mapa de tamaño 4000 y unas decenas de jugadores. La memoria crece con el tiempo a medida que los jugadores construyen. - Unos 30 GB libres en disco, preferiblemente SSD o NVMe. - Un usuario no root con privilegios `sudo`. - Una copia de Rust en Steam en el ordenador desde el que vas a jugar. ## Paso 1: Instalar SteamCMD SteamCMD está en el repositorio `multiverse` de Ubuntu y necesita bibliotecas de 32 bits, así que activa ambos primero: ```bash sudo add-apt-repository multiverse sudo dpkg --add-architecture i386 sudo apt update ``` Instala SteamCMD y `unzip`, que necesitarás para Oxide. Durante la instalación se te pedirá aceptar la licencia de Steam; selecciona **I AGREE**: ```bash sudo apt install steamcmd unzip ``` Comprueba que el binario existe: ```bash ls -l /usr/games/steamcmd ``` ## Paso 2: Crear un usuario dedicado El servidor debe ejecutarse con un usuario sin privilegios. Crea el usuario `steam`: ```bash sudo useradd -m -s /bin/bash steam ``` Cambia a ese usuario para descargar el servidor: ```bash sudo -iu steam ``` ## Paso 3: Descargar el servidor de Rust El servidor dedicado de Rust es la aplicación de Steam `258550`. Recuerda que `+force_install_dir` debe ir antes de `+login`: ```bash /usr/games/steamcmd +force_install_dir /home/steam/rust +login anonymous +app_update 258550 validate +quit ``` La descarga ocupa varios GB. Al terminar verás: ```output Success! App '258550' fully installed. ``` Comprueba que el binario existe y vuelve a tu usuario con sudo: ```bash ls -l /home/steam/rust/RustDedicated exit ``` ## Paso 4: Crear el servicio systemd Rust se configura sobre todo con parámetros de arranque que empiezan por `+`. Decide los valores antes de crear la unidad: - `server.hostname`: el nombre que aparece en la lista de servidores. - `server.identity`: el nombre del directorio donde se guardan mapa, jugadores y configuración, dentro de `/home/steam/rust/server/`. - `server.worldsize` y `server.seed`: el tamaño del mapa (entre 1000 y 6000; 3500 a 4000 es habitual) y la semilla que lo genera. La misma semilla y tamaño producen siempre el mismo mapa. - `server.maxplayers`: el número máximo de jugadores. - `rcon.password`: la contraseña de la consola remota. Usa una contraseña larga y única. Guarda la contraseña RCON en un archivo de entorno que solo pueda leer root: ```bash sudo install -m 600 /dev/null /etc/rust-server.env sudo nano /etc/rust-server.env ``` ```ini RUST_RCON_PASSWORD=tu_contraseña_rcon ``` Crea la unidad: ```bash sudo nano /etc/systemd/system/rust.service ``` ```ini [Unit] Description=Rust dedicated server Wants=network-online.target After=network-online.target [Service] Type=simple User=steam Group=steam WorkingDirectory=/home/steam/rust EnvironmentFile=/etc/rust-server.env Environment=LD_LIBRARY_PATH=/home/steam/rust/RustDedicated_Data/Plugins/x86_64 ExecStart=/home/steam/rust/RustDedicated -batchmode -nographics \ +server.port 28015 \ +server.queryport 28017 \ +server.hostname "CubePath Rust" \ +server.identity main \ +server.level "Procedural Map" \ +server.worldsize 4000 \ +server.seed 12345 \ +server.maxplayers 50 \ +rcon.port 28016 \ +rcon.password ${RUST_RCON_PASSWORD} \ +rcon.web 1 \ +app.port 28082 TimeoutStartSec=900 Restart=on-failure RestartSec=15 [Install] WantedBy=multi-user.target ``` La variable `LD_LIBRARY_PATH` apunta a las bibliotecas que trae el propio servidor, incluida la de Steam, igual que hace el script de arranque oficial. `rcon.web 1` activa RCON por WebSocket, que es lo que usan las herramientas de administración actuales, y `app.port` habilita la aplicación Rust+ para móvil. Esta unidad no actualiza el servidor al arrancar porque, si usas Oxide, cada actualización de Rust lo sobrescribe y hay que reinstalarlo (lo verás en el paso 7). Recarga systemd y arranca el servidor: ```bash sudo systemctl daemon-reload sudo systemctl enable --now rust ``` ## Paso 5: Comprobar que el servidor funciona La primera vez el servidor genera el mapa, lo que puede tardar varios minutos. Sigue el log: ```bash sudo journalctl -u rust -f ``` Cuando esté listo para aceptar jugadores verás una línea como esta: ```output ... Server startup complete ``` Pulsa `CTRL+C` para salir del log y comprueba los puertos: ```bash sudo ss -tulpn | grep RustDedicated ``` ```output udp UNCONN 0 0 0.0.0.0:28015 0.0.0.0:* users:(("RustDedicated",pid=6210,fd=...)) udp UNCONN 0 0 0.0.0.0:28017 0.0.0.0:* users:(("RustDedicated",pid=6210,fd=...)) tcp LISTEN 0 ... 0.0.0.0:28016 0.0.0.0:* users:(("RustDedicated",pid=6210,fd=...)) tcp LISTEN 0 ... 0.0.0.0:28082 0.0.0.0:* users:(("RustDedicated",pid=6210,fd=...)) ``` ## Paso 6: Abrir el cortafuegos Estos son los puertos que usa la configuración anterior: | Puerto | Protocolo | Uso | |--------|-----------|-----| | 28015 | UDP | Juego | | 28017 | UDP | Consultas de Steam (lista de servidores) | | 28016 | TCP | RCON | | 28082 | TCP | Aplicación Rust+ | Abre los puertos públicos con UFW. Para RCON, permite solo la IP desde la que administras, porque quien acierte la contraseña controla el servidor por completo: ```bash sudo ufw allow 28015/udp sudo ufw allow 28017/udp sudo ufw allow 28082/tcp sudo ufw allow from tu_ip_de_administracion to any port 28016 proto tcp sudo ufw status ``` Conéctate desde el juego pulsando `F1` para abrir la consola y escribiendo: ```text client.connect ip_de_tu_servidor:28015 ``` El servidor aparecerá también en la pestaña **Community** del navegador de servidores al cabo de unos minutos. ## Paso 7: Instalar Oxide para usar plugins Oxide (uMod) es el framework de plugins más usado en Rust. Se instala extrayendo sus archivos sobre los del servidor, así que detén el servicio primero: ```bash sudo systemctl stop rust ``` Descarga la última versión para Linux desde las releases oficiales en GitHub y extráela en el directorio del servidor: ```bash sudo -u steam curl -fL -o /home/steam/oxide-linux.zip https://github.com/OxideMod/Oxide.Rust/releases/latest/download/Oxide.Rust-linux.zip sudo -u steam unzip -o /home/steam/oxide-linux.zip -d /home/steam/rust sudo systemctl start rust ``` En el arranque verás líneas de Oxide en el log y se creará el directorio `/home/steam/rust/oxide/`: ```bash sudo journalctl -u rust --since "5 min ago" | grep -i oxide ``` Los plugins son archivos `.cs` que se descargan de [umod.org](https://umod.org/plugins) y se copian en `oxide/plugins/`. Oxide los compila y carga en caliente, sin reiniciar: ```bash sudo -u steam cp NombrePlugin.cs /home/steam/rust/oxide/plugins/ ``` La configuración de cada plugin se genera en `oxide/config/` la primera vez que se carga. > Importante: cada actualización de Rust sobrescribe los archivos de Oxide. Después de actualizar el servidor, repite la descarga y extracción de Oxide antes de arrancarlo, o los plugins no se cargarán. ## Paso 8: Actualizar el servidor y hacer un wipe Facepunch publica una actualización obligatoria el primer jueves de cada mes, que obliga a actualizar el servidor y normalmente a hacer un wipe del mapa. Para actualizar: ```bash sudo systemctl stop rust sudo -u steam /usr/games/steamcmd +force_install_dir /home/steam/rust +login anonymous +app_update 258550 validate +quit ``` Reinstala Oxide si lo usas (paso 7) y arranca de nuevo con `sudo systemctl start rust`. Un wipe de mapa borra construcciones y objetos pero conserva los planos aprendidos. Consiste en eliminar los archivos del mapa y de la partida de la identidad del servidor con el servicio detenido: ```bash sudo systemctl stop rust sudo -u steam find /home/steam/rust/server/main -maxdepth 1 -type f \( -name '*.map' -o -name '*.sav*' \) -print -delete ``` Para un wipe completo, que también reinicia los planos, borra además los archivos `player.blueprints.*.db` del mismo directorio. Si quieres un mapa distinto tras el wipe, cambia `server.seed` en la unidad y ejecuta `sudo systemctl daemon-reload`. Después arranca el servidor: ```bash sudo systemctl start rust ``` ## Paso 9: Hacer copias de seguridad Todo el estado del servidor está en `/home/steam/rust/server/main`, y los plugins y su configuración en `/home/steam/rust/oxide`. Una tarea cron para el usuario `steam` puede archivarlos cada noche y borrar las copias de más de 7 días: ```bash sudo -u steam mkdir -p /home/steam/backups sudo -u steam crontab -e ``` ```text 30 5 * * * tar -czf /home/steam/backups/rust-$(date +\%F).tar.gz -C /home/steam/rust server/main oxide && find /home/steam/backups -name 'rust-*.tar.gz' -mtime +7 -delete ``` Los `%` van escapados porque cron interpreta un `%` sin escapar como salto de línea. Si no usas Oxide, quita `oxide` del comando. Copia el directorio `backups` fuera del servidor con regularidad. ## Solución de problemas - **El servicio se reinicia sin parar.** Revisa `sudo journalctl -u rust -n 100`. Suele ser falta de memoria durante la generación del mapa; prueba con un `server.worldsize` más pequeño o añade RAM. - **El servidor no aparece en la lista.** El puerto de consultas 28017/udp debe estar abierto. Conectar con `client.connect` funciona aunque no aparezca. - **Los plugins dejaron de funcionar tras una actualización.** Rust sobrescribió Oxide. Vuelve a instalarlo como en el paso 7. - **Los jugadores no pueden entrar tras el primer jueves del mes.** El cliente se actualizó y el servidor no. Actualiza como en el paso 8. ## Conclusión Tu servidor de Rust ya funciona en Ubuntu 24.04 como servicio systemd, con RCON restringido a tu IP, soporte de plugins con Oxide y copias nocturnas. Como siguientes pasos puedes conectar una herramienta de administración RCON por WebSocket, programar los wipes con un temporizador de systemd para el primer jueves del mes o probar mapas personalizados con `server.levelurl`.