Redmine es una aplicación de gestión de proyectos y seguimiento de incidencias escrita en Ruby on Rails, con diagramas de Gantt, wiki y control de tiempos por proyecto. En este tutorial instalarás Redmine 6.1 en Ubuntu 24.04 usando el Ruby de la distribución y MySQL 8, lo ejecutarás con Puma como servicio de systemd bajo un usuario propio y lo publicarás detrás de Nginx con HTTPS.

Requisitos previos

Para seguir esta guía necesitas:

  • Un servidor con Ubuntu 24.04 LTS, por ejemplo un VPS de CubePath, con al menos 2 GB de RAM y 15 GB de disco.
  • Un usuario no root con privilegios sudo.
  • Un dominio o subdominio (en esta guía, redmine.example.com) con un registro DNS A que apunte a la IP del servidor. Sustituye redmine.example.com por tu dominio en todos los pasos.
  • Los puertos 80 y 443 abiertos.

Paso 1: Instalar Ruby, MySQL y las dependencias de compilación

Algunas gemas de Redmine, como mysql2, compilan extensiones nativas, por lo que necesitas las herramientas de compilación y las cabeceras de las bibliotecas:

sudo apt update
sudo apt install -y ruby-full build-essential libmysqlclient-dev libyaml-dev zlib1g-dev imagemagick git mysql-server nginx

Instala Bundler, el gestor de dependencias de Ruby, desde RubyGems:

sudo gem install bundler

Comprueba las versiones:

ruby --version
bundle --version

ruby 3.2.3 (2024-01-18 revision 52bb2ac0a6) [x86_64-linux-gnu]
Bundler version 2.7.2

Paso 2: Crear la base de datos

Ejecuta el script de seguridad de MySQL para eliminar usuarios anónimos y la base de datos de pruebas:

sudo mysql_secure_installation

En Ubuntu, root se autentica por socket, así que puedes entrar en la consola sin contraseña con sudo:

sudo mysql

Crea la base de datos y un usuario exclusivo. Sustituye your_strong_password por una contraseña robusta:

CREATE DATABASE redmine CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci;
CREATE USER 'redmine'@'localhost' IDENTIFIED BY 'your_strong_password';
GRANT ALL PRIVILEGES ON redmine.* TO 'redmine'@'localhost';
FLUSH PRIVILEGES;
EXIT;

Comprueba que el usuario puede conectarse:

mysql -u redmine -p -e "SHOW DATABASES;"

+--------------------+
| Database           |
+--------------------+
| information_schema |
| performance_schema |
| redmine            |
+--------------------+

Paso 3: Crear el usuario del sistema y descargar Redmine

Redmine se ejecutará con un usuario sin privilegios llamado redmine, cuyo directorio personal será la instalación:

sudo useradd --system --create-home --home-dir /opt/redmine --shell /bin/bash redmine

Cambia a ese usuario. Todos los comandos hasta el paso 5 se ejecutan como redmine:

sudo -iu redmine

Descarga Redmine y extráelo en /opt/redmine:

wget https://www.redmine.org/releases/redmine-6.1.4.tar.gz
tar -xzf redmine-6.1.4.tar.gz --strip-components=1
rm redmine-6.1.4.tar.gz
ls

CONTRIBUTING.md  Gemfile  LICENSE.txt  README.rdoc  Rakefile  app  bin  config  config.ru  db  doc  extra  files  lib  log  package.json  plugins  public  test  themes  tmp  vendor  yarn.lock

Paso 4: Configurar la conexión a la base de datos

Copia la plantilla de configuración:

cp config/database.yml.example config/database.yml
nano config/database.yml

Sustituye el bloque production por el siguiente, con la contraseña del paso 2. La variable transaction_isolation es la recomendada por Redmine para MySQL y evita problemas de concurrencia:

production:
  adapter: mysql2
  database: redmine
  host: localhost
  username: redmine
  password: "your_strong_password"
  encoding: utf8mb4
  variables:
    transaction_isolation: "READ-COMMITTED"

Protege el archivo, que contiene la contraseña:

chmod 600 config/database.yml

Paso 5: Instalar las gemas e inicializar Redmine

Redmine no incluye un servidor de aplicaciones para producción. El mecanismo oficial para añadir gemas propias es el archivo Gemfile.local; añade Puma en él:

echo "gem 'puma'" > Gemfile.local

Configura Bundler para instalar las gemas dentro del proyecto (en vendor/bundle, sin necesidad de root) y sin los grupos de desarrollo y pruebas:

bundle config set --local path 'vendor/bundle'
bundle config set --local without 'development test'
bundle install

La instalación tarda unos minutos. Al final verás:

Bundle complete! ...
Gems in the groups 'development' and 'test' were not installed.
Bundled gems are installed into `./vendor/bundle`

Es posible que Bundler avise de que puma aparece más de una vez en el Gemfile; es esperado y no impide la instalación.

Genera la clave secreta de sesiones, crea las tablas y carga los datos por defecto (roles, tipos de incidencia, estados) en español:

bundle exec rake generate_secret_token
RAILS_ENV=production bundle exec rake db:migrate
RAILS_ENV=production REDMINE_LANG=es bundle exec rake redmine:load_default_data

Default configuration data loaded.

Crea los directorios de trabajo que Redmine necesita y vuelve a tu usuario:

mkdir -p tmp/pdf public/assets
exit

Paso 6: Ejecutar Redmine con systemd

Crea una unidad de systemd para que Puma arranque con el sistema y se reinicie si falla:

sudo nano /etc/systemd/system/redmine.service

[Unit]
Description=Redmine (Puma)
After=network.target mysql.service
Requires=mysql.service

[Service]
Type=simple
User=redmine
Group=redmine
WorkingDirectory=/opt/redmine
Environment=RAILS_ENV=production
ExecStart=/usr/local/bin/bundle exec rails server -e production -b 127.0.0.1 -p 3000
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target

Puma escucha solo en 127.0.0.1:3000; el acceso desde fuera pasará por Nginx. Activa e inicia el servicio:

sudo systemctl daemon-reload
sudo systemctl enable --now redmine
sudo systemctl status redmine

● redmine.service - Redmine (Puma)
     Loaded: loaded (/etc/systemd/system/redmine.service; enabled; preset: enabled)
     Active: active (running) since Fri 2026-09-25 10:20:14 UTC; 6s ago

El primer arranque compila los assets y puede tardar unos segundos. Comprueba que responde en local:

curl -sI http://127.0.0.1:3000/login | head -n 1

HTTP/1.1 200 OK

Si no responde, revisa el registro con sudo journalctl -u redmine -n 50.

Paso 7: Configurar Nginx como proxy inverso con HTTPS

Crea el bloque de servidor:

sudo nano /etc/nginx/sites-available/redmine

server {
    listen 80;
    listen [::]:80;
    server_name redmine.example.com;

    client_max_body_size 20M;

    location / {
        proxy_pass http://127.0.0.1:3000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

client_max_body_size debe coincidir con el tamaño máximo de adjunto que configures en Redmine. Activa el sitio, desactiva el de por defecto y recarga Nginx:

sudo ln -s /etc/nginx/sites-available/redmine /etc/nginx/sites-enabled/
sudo rm /etc/nginx/sites-enabled/default
sudo nginx -t
sudo systemctl reload nginx

Si usas UFW, abre HTTP y HTTPS:

sudo ufw allow 'Nginx Full'

Solicita el certificado de Let's Encrypt. Certbot añade el bloque HTTPS y la redirección desde HTTP:

sudo apt install -y certbot python3-certbot-nginx
sudo certbot --nginx -d redmine.example.com

Comprueba que la renovación automática funciona:

sudo certbot renew --dry-run

Paso 8: Primer acceso y ajustes básicos

Abre https://redmine.example.com e inicia sesión con el usuario admin y la contraseña admin. Redmine te obliga a cambiarla en el primer acceso; elige una contraseña robusta.

Después ve a Administración > Configuración > General y ajusta:

  • Nombre y ruta del servidor: redmine.example.com.
  • Protocolo: HTTPS.

Estos valores se usan para generar los enlaces de los correos. En Administración > Información puedes comprobar que el directorio de archivos, tmp y log tienen permisos de escritura y ver la versión de Redmine, Ruby y la base de datos.

Paso 9: Configurar el envío de correo

Redmine envía notificaciones de incidencias por correo. La configuración SMTP va en config/configuration.yml, que no existe por defecto (configuration.yml.example solo sirve de referencia). Créalo como usuario redmine:

sudo -u redmine nano /opt/redmine/config/configuration.yml

Pega un bloque production con los datos de tu proveedor:

production:
  email_delivery:
    delivery_method: :smtp
    smtp_settings:
      address: "smtp.your_provider.com"
      port: 587
      domain: "example.com"
      authentication: :login
      user_name: "your_smtp_user"
      password: "your_smtp_password"
      enable_starttls_auto: true

Protege el archivo y reinicia Redmine:

sudo chmod 600 /opt/redmine/config/configuration.yml
sudo systemctl restart redmine

En Administración > Configuración > Notificaciones por correo define el remitente y pulsa Enviar un correo de prueba para comprobar que llega.

Paso 10: Instalar plugins

Los plugins se copian en /opt/redmine/plugins/<nombre>, con el nombre de directorio que indique su documentación. Comprueba siempre que el plugin declara compatibilidad con Redmine 6.1. El procedimiento general, como usuario redmine:

sudo -iu redmine
git clone https://github.com/your_org/your_plugin.git plugins/your_plugin
bundle install
RAILS_ENV=production bundle exec rake redmine:plugins:migrate
exit

Reinicia el servicio para cargarlo:

sudo systemctl restart redmine

El plugin aparecerá en Administración > Plugins.

Paso 11: Programar copias de seguridad

Una copia de Redmine consiste en la base de datos y el directorio files, donde se guardan los adjuntos. Crea un script:

sudo nano /usr/local/sbin/redmine-backup

#!/usr/bin/env bash
set -euo pipefail

backup_dir="/var/backups/redmine"
stamp="$(date +%Y%m%d-%H%M%S)"

mkdir -p "$backup_dir"

# root se autentica por socket, sin contraseña en el script
mysqldump --single-transaction --default-character-set=utf8mb4 redmine \
  | gzip > "$backup_dir/redmine-db-$stamp.sql.gz"

tar -czf "$backup_dir/redmine-files-$stamp.tar.gz" -C /opt/redmine files config/database.yml config/configuration.yml

# Conservar 14 días
find "$backup_dir" -type f -name 'redmine-*' -mtime +14 -delete

Hazlo ejecutable, pruébalo y prográmalo cada noche:

sudo chmod 750 /usr/local/sbin/redmine-backup
sudo /usr/local/sbin/redmine-backup
sudo ls -lh /var/backups/redmine
echo '30 2 * * * root /usr/local/sbin/redmine-backup' | sudo tee /etc/cron.d/redmine-backup

-rw-r--r-- 1 root root 412K Sep 25 10:40 redmine-db-20260925-104012.sql.gz
-rw-r--r-- 1 root root 2.1M Sep 25 10:40 redmine-files-20260925-104012.tar.gz

Copia /var/backups/redmine a otro servidor con regularidad.

Solución de problemas

bundle install falla al compilar mysql2 o psych. Faltan cabeceras de desarrollo. Asegúrate de tener instalados libmysqlclient-dev y libyaml-dev y repite bundle install.

Nginx devuelve 502 Bad Gateway. Puma no está escuchando. Comprueba el servicio con sudo systemctl status redmine y el registro con sudo journalctl -u redmine -n 50; un error habitual es una contraseña incorrecta en config/database.yml.

Los enlaces de los correos apuntan a http:// o a localhost. Revisa el nombre del servidor y el protocolo en Administración > Configuración > General.

Conclusión

Tienes Redmine 6.1 funcionando en Ubuntu 24.04 con MySQL 8, Puma gestionado por systemd y Nginx con HTTPS delante, con correo y copias de seguridad configurados. Como siguientes pasos, crea tus proyectos y define los roles y flujos de trabajo en Administración > Roles y permisos y Flujo de trabajo, y valora activar la API REST para integrar Redmine con otras herramientas. Para actualizar a una nueva versión, sigue la guía oficial de actualización de Redmine: descarga la nueva versión, conserva config/database.yml, config/configuration.yml y files, y ejecuta de nuevo bundle install y rake db:migrate.