---
title: "Cómo instalar Redmine en Ubuntu 24.04 con MySQL y Nginx"
description: "Instala Redmine 6.1 en Ubuntu 24.04 con Ruby 3.2, MySQL 8 y Puma como servicio systemd detrás de Nginx con HTTPS, y configura correo SMTP y copias de seguridad."
category: "Hosting de Aplicaciones Web"
language: es
source: https://cubepath.com/es/docs/hosting-de-aplicaciones-web/instalacion-del-sistema-de-gestion-de-proyectos-redmine
updated: 2026-09-25
---

# Cómo instalar Redmine en Ubuntu 24.04 con MySQL y Nginx

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.

> Nota: Redmine 6.1 admite Ruby 3.2, 3.3 y 3.4. Ubuntu 24.04 incluye Ruby 3.2, así que no hace falta un gestor de versiones como RVM o rbenv. Esta guía usa Redmine 6.1.4; consulta la [página de descargas de Redmine](https://www.redmine.org/projects/redmine/wiki/Download) por si hay una versión más reciente de la rama 6.1.

## 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:

```bash
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:

```bash
sudo gem install bundler
```

Comprueba las versiones:

```bash
ruby --version
bundle --version
```

```output
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:

```bash
sudo mysql_secure_installation
```

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

```bash
sudo mysql
```

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

```sql
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:

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

```output
+--------------------+
| 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:

```bash
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`:

```bash
sudo -iu redmine
```

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

```bash
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
```

```output
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:

```bash
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:

```yaml
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:

```bash
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:

```bash
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:

```bash
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:

```output
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:

```bash
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
```

```output
Default configuration data loaded.
```

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

```bash
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:

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

```ini
[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:

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

```output
● 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:

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

```output
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:

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

```nginx
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:

```bash
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:

```bash
sudo ufw allow 'Nginx Full'
```

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

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

Comprueba que la renovación automática funciona:

```bash
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`:

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

Pega un bloque `production` con los datos de tu proveedor:

```yaml
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:

```bash
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`:

```bash
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:

```bash
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:

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

```bash
#!/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:

```bash
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
```

```output
-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`.