--- title: "Cómo instalar un servidor de Factorio en Ubuntu 24.04" description: "Instala el servidor headless de Factorio en Ubuntu 24.04, configura server-settings.json, crea el mapa y gestiona mods, RCON y copias con systemd." category: "Servidores de Juegos" language: es source: https://cubepath.com/es/docs/servidores-de-juegos/servidor-factorio-sin-interfaz-grafica-en-linux updated: 2026-09-25 --- # Cómo instalar un servidor de Factorio en Ubuntu 24.04 Factorio publica una versión headless de su servidor para Linux: un binario sin interfaz gráfica que se descarga gratis desde la web oficial, sin necesidad de SteamCMD. Es ligero y estable, ideal para mantener una fábrica cooperativa en marcha día y noche. En este tutorial instalarás el servidor headless de Factorio en Ubuntu 24.04, crearás un mapa, configurarás `server-settings.json`, lo ejecutarás como servicio systemd y verás cómo gestionar mods, RCON y copias de seguridad. ## Requisitos previos Para seguir esta guía necesitas: - Un servidor con Ubuntu 24.04 LTS (x86_64), por ejemplo un VPS de CubePath. Para un grupo pequeño bastan 2 núcleos de CPU y 2 GB de RAM; las fábricas muy grandes o con Space Age necesitan más memoria y, sobre todo, una CPU con buena frecuencia, porque la simulación usa principalmente un núcleo. - Unos 5 GB libres en disco. - Un usuario no root con privilegios `sudo`. - Una copia de Factorio en el ordenador desde el que vas a jugar, en la misma versión que el servidor. ## Paso 1: Crear un usuario dedicado El servidor debe ejecutarse con un usuario sin privilegios y sin shell de acceso. Crea el usuario de sistema `factorio`: ```bash sudo useradd -r -m -d /opt/factorio -s /usr/sbin/nologin factorio ``` Instala `xz-utils` para descomprimir el paquete del servidor (suele estar ya instalado): ```bash sudo apt update sudo apt install xz-utils curl ``` ## Paso 2: Descargar el servidor headless La web de Factorio ofrece un enlace estable que siempre apunta a la última versión estable del servidor headless. Descárgalo y extráelo en `/opt`, de modo que los archivos queden en `/opt/factorio`: ```bash curl -fL -o /tmp/factorio-headless.tar.xz https://factorio.com/get-download/stable/headless/linux64 sudo tar -xJf /tmp/factorio-headless.tar.xz -C /opt sudo chown -R factorio:factorio /opt/factorio ``` Comprueba la versión instalada: ```bash sudo -u factorio /opt/factorio/bin/x64/factorio --version ``` ```output Version: 2.0.x (build ..., linux64, headless) ... ``` ## Paso 3: Configurar server-settings.json El servidor incluye una plantilla con todas las opciones en `data/server-settings.example.json`. Cópiala a un archivo propio fuera del directorio `data`, que se sobrescribe al actualizar: ```bash sudo -u factorio mkdir -p /opt/factorio/config sudo -u factorio cp /opt/factorio/data/server-settings.example.json /opt/factorio/config/server-settings.json sudo -u factorio nano /opt/factorio/config/server-settings.json ``` Cambia al menos estas claves: ```json { "name": "CubePath Factorio", "description": "Fábrica cooperativa", "max_players": 10, "visibility": { "public": false, "lan": false }, "username": "", "token": "", "game_password": "tu_contraseña_servidor", "require_user_verification": true, "autosave_interval": 10, "autosave_slots": 5, "auto_pause": true } ``` Qué hace cada una: - `name` y `description`: lo que ven los jugadores al conectar o en la lista pública. - `visibility.public`: publica el servidor en la lista de partidas en línea. Si lo pones a `true`, debes rellenar `username` y `token` con tu usuario de factorio.com y el token que aparece en tu perfil de [factorio.com](https://factorio.com/profile). - `game_password`: la contraseña para entrar. Sustituye `tu_contraseña_servidor` por la tuya. - `require_user_verification`: exige que los jugadores tengan una cuenta de Factorio válida. - `autosave_interval` y `autosave_slots`: guarda automáticamente cada 10 minutos y rota entre 5 archivos de autoguardado. - `auto_pause`: pausa la partida cuando no hay nadie conectado. Deja el resto de claves de la plantilla como están. Valida que el JSON es correcto: ```bash python3 -m json.tool /opt/factorio/config/server-settings.json > /dev/null && echo "JSON válido" ``` Como el archivo puede contener tu token, limita quién puede leerlo: ```bash sudo chmod 600 /opt/factorio/config/server-settings.json ``` ## Paso 4: Crear el mapa El servidor no genera un mapa automáticamente: necesitas crear un archivo de partida primero. Opcionalmente, puedes personalizar la generación del mapa copiando `data/map-gen-settings.example.json` a `config/map-gen-settings.json` y cambiando valores como `seed` (una semilla fija para reproducir el mapa) o la frecuencia y tamaño de los recursos. Crea la partida con los valores por defecto: ```bash sudo -u factorio mkdir -p /opt/factorio/saves sudo -u factorio /opt/factorio/bin/x64/factorio --create /opt/factorio/saves/fabrica.zip ``` Si creaste un archivo de generación de mapa, añade `--map-gen-settings /opt/factorio/config/map-gen-settings.json` al comando. Comprueba que la partida existe: ```bash ls -lh /opt/factorio/saves/ ``` Si prefieres continuar una partida que ya tienes, copia su archivo `.zip` desde la carpeta `saves` de tu ordenador a `/opt/factorio/saves/` y asígnalo al usuario `factorio` con `chown`. ## Paso 5: Crear el servicio systemd La opción `--start-server-load-latest` carga la partida más reciente de `saves/`, incluidos los autoguardados, así que tras un reinicio el servidor continúa desde el último guardado. Crea la unidad: ```bash sudo nano /etc/systemd/system/factorio.service ``` ```ini [Unit] Description=Factorio headless server Wants=network-online.target After=network-online.target [Service] Type=simple User=factorio Group=factorio WorkingDirectory=/opt/factorio ExecStart=/opt/factorio/bin/x64/factorio --start-server-load-latest --server-settings /opt/factorio/config/server-settings.json --port 34197 KillSignal=SIGINT TimeoutStopSec=60 Restart=on-failure RestartSec=10 [Install] WantedBy=multi-user.target ``` `KillSignal=SIGINT` hace que `systemctl stop` detenga el servidor igual que `CTRL+C`, de forma ordenada. Recarga systemd y arranca el servidor: ```bash sudo systemctl daemon-reload sudo systemctl enable --now factorio ``` ## Paso 6: Comprobar el servidor y abrir el cortafuegos Revisa el log. Cuando la partida está cargada y el servidor acepta conexiones verás que cambia al estado `InGame`: ```bash sudo journalctl -u factorio -f ``` ```output ... Info ServerMultiplayerManager.cpp: ... changing state from(CreatingGame) to(InGame) ``` Pulsa `CTRL+C` para salir del log. Factorio usa un único puerto, 34197 UDP. Comprueba que escucha y ábrelo en UFW: ```bash sudo ss -ulpn | grep 34197 sudo ufw allow 34197/udp sudo ufw status ``` Para conectarte, abre Factorio, entra en **Multijugador > Conectar a dirección**, escribe `ip_de_tu_servidor:34197` y la contraseña. ## Paso 7: Añadir administradores Los administradores pueden expulsar y banear jugadores y usar comandos como `/promote` desde el chat. El servidor lee la lista de administradores de `server-adminlist.json` en su directorio de datos. Créalo con los nombres de usuario de Factorio: ```bash sudo -u factorio nano /opt/factorio/server-adminlist.json ``` ```json [ "tu_usuario_factorio" ] ``` Reinicia el servidor para aplicarlo: ```bash sudo systemctl restart factorio ``` Desde el juego, un administrador puede promover a otros con `/promote nombre` y consultar la lista con `/admins`. ## Paso 8: Activar RCON (opcional) RCON permite enviar comandos de consola al servidor desde fuera del juego, por ejemplo para forzar un guardado desde un script. Se activa añadiendo dos opciones a `ExecStart` en la unidad: ```text --rcon-port 27015 --rcon-password tu_contraseña_rcon ``` Después ejecuta `sudo systemctl daemon-reload` y `sudo systemctl restart factorio`. Usa una contraseña larga y no abras el puerto 27015 en el cortafuegos salvo para tu IP de administración: ```bash sudo ufw allow from tu_ip_de_administracion to any port 27015 proto tcp ``` Con cualquier cliente RCON compatible con el protocolo de Source (por ejemplo `rcon-cli` o `mcrcon`) puedes ejecutar comandos como `/server-save` o `/players`. ## Paso 9: Usar mods Los mods van en el directorio `mods/` del servidor, y los jugadores deben tener exactamente los mismos mods y versiones. La forma más sencilla de sincronizarlos es copiar los archivos `.zip` de los mods y el archivo `mod-list.json` desde la carpeta `mods` de tu instalación de Factorio: ```bash sudo -u factorio mkdir -p /opt/factorio/mods ``` Sube los archivos con `scp` o `rsync` a `/opt/factorio/mods/`, asigna la propiedad al usuario `factorio` y reinicia el servidor. Al conectar, el cliente ofrece descargar automáticamente los mods que le falten. Factorio 2.0 incluye los datos de la expansión Space Age (`space-age`, `quality` y `elevated-rails`) también en el servidor headless. Si ningún jugador tiene la expansión, desactiva esos tres mods en `/opt/factorio/mods/mod-list.json` poniendo `"enabled": false`. Una partida creada con Space Age activado la necesita para cargarse, así que haz este cambio con el servidor detenido y vuelve a crear la partida del paso 4 con otro nombre: ```json { "mods": [ { "name": "base", "enabled": true }, { "name": "elevated-rails", "enabled": false }, { "name": "quality", "enabled": false }, { "name": "space-age", "enabled": false } ] } ``` ## Paso 10: Actualizar el servidor El cliente y el servidor deben tener la misma versión. Para actualizar, detén el servicio, descarga la nueva versión y extráela sobre la instalación existente. Las partidas, la configuración y los mods no se tocan porque están en sus propios directorios: ```bash sudo systemctl stop factorio curl -fL -o /tmp/factorio-headless.tar.xz https://factorio.com/get-download/stable/headless/linux64 sudo tar -xJf /tmp/factorio-headless.tar.xz -C /opt sudo chown -R factorio:factorio /opt/factorio sudo systemctl start factorio ``` Comprueba la nueva versión con `sudo -u factorio /opt/factorio/bin/x64/factorio --version`. ## Paso 11: Hacer copias de seguridad Los autoguardados rotan y se sobrescriben, así que conviene archivar las partidas en otro sitio. Crea un directorio de copias y una tarea cron que las guarde cada noche y borre las de más de 14 días: ```bash sudo mkdir -p /var/backups/factorio sudo crontab -e ``` ```text 0 5 * * * tar -czf /var/backups/factorio/factorio-$(date +\%F).tar.gz -C /opt/factorio saves config mods server-adminlist.json && find /var/backups/factorio -name 'factorio-*.tar.gz' -mtime +14 -delete ``` Los `%` van escapados porque cron interpreta un `%` sin escapar como salto de línea. Si no usas mods o lista de administradores, quita esas rutas del comando para que `tar` no falle. ## Solución de problemas - **El servicio se detiene con un error de mods.** El servidor no puede cargar la partida si faltan mods que usa o si hay versiones incompatibles. Revisa `sudo journalctl -u factorio -n 50` y ajusta `mods/`. - **Los jugadores no pueden entrar por versión distinta.** El cliente se actualizó antes que el servidor. Actualiza como en el paso 10. - **El servidor no aparece en la lista pública.** Comprueba que `visibility.public` es `true` y que `username` y `token` son correctos. Conectar por IP funciona siempre. - **Nadie puede conectarse.** Asegúrate de que el puerto 34197/udp está abierto en UFW y en cualquier cortafuegos externo. ## Conclusión Tu servidor headless de Factorio ya funciona en Ubuntu 24.04 como servicio systemd, carga siempre el último guardado y tiene copias nocturnas. Como siguientes pasos puedes publicarlo en la lista de partidas en línea, automatizar guardados con RCON o probar mods de rendimiento para fábricas grandes.