Cómo instalar Rocket.Chat en Ubuntu 24.04 con Docker

Rocket.Chat es una plataforma de mensajería de código abierto y autohospedada con canales, mensajes directos, hilos, integraciones y aplicaciones móviles. En este tutorial desplegarás Rocket.Chat en Ubuntu 24.04 con Docker Compose, que es el método de instalación que mantiene el propio proyecto, junto con MongoDB en modo replica set. Después lo publicarás detrás de Nginx con HTTPS de Let's Encrypt y programarás copias de seguridad de la base de datos.

Requisitos previos

• Un servidor con Ubuntu 24.04 LTS, por ejemplo un VPS de CubePath, con al menos 2 vCPU y 4 GB de RAM.
• Un usuario no root con privilegios sudo.
• Docker Engine y el plugin Docker Compose instalados desde el repositorio oficial de Docker, y tu usuario en el grupo docker.
• Un subdominio (en esta guía, chat.your_domain) con un registro DNS A que apunte a la IP pública del servidor.
• Los puertos 80 y 443 accesibles desde Internet.

Comprueba que Docker y Compose están disponibles:

docker --version
docker compose version

Docker version X.Y.Z, build ...
Docker Compose version vX.Y.Z

Paso 1: Crear el proyecto de Docker Compose

Crea un directorio para el despliegue:

sudo mkdir -p /opt/rocketchat
sudo chown "$USER": /opt/rocketchat
cd /opt/rocketchat

Rocket.Chat se configura mediante variables de entorno. Guarda la versión y la URL pública en un archivo .env, que Docker Compose lee automáticamente:

nano /opt/rocketchat/.env

Consulta la última versión estable en las notas de versión de Rocket.Chat (https://github.com/RocketChat/Rocket.Chat/releases) y sustituye X.Y.Z por ella. Fija siempre una versión concreta en lugar de latest, para que una recreación del contenedor no te actualice sin querer:

RELEASE=X.Y.Z
ROOT_URL=https://chat.your_domain

Paso 2: Definir MongoDB y Rocket.Chat

Rocket.Chat usa MongoDB y necesita que funcione como replica set, porque depende de los change streams para enviar los mensajes en tiempo real. Con un solo nodo basta: el replica set tiene un único miembro.

Crea el archivo de Compose:

nano /opt/rocketchat/compose.yml

services:
  mongodb:
    image: mongo:7.0
    restart: unless-stopped
    command: ["--replSet", "rs0", "--bind_ip_all"]
    volumes:
      - mongodb_data:/data/db
    healthcheck:
      test: ["CMD-SHELL", "mongosh --quiet --eval \"try { rs.status().ok } catch (e) { rs.initiate({_id: 'rs0', members: [{_id: 0, host: 'mongodb:27017'}]}).ok }\""]
      interval: 10s
      timeout: 10s
      retries: 10
      start_period: 20s

  rocketchat:
    image: registry.rocket.chat/rocketchat/rocket.chat:${RELEASE}
    restart: unless-stopped
    depends_on:
      mongodb:
        condition: service_healthy
    environment:
      MONGO_URL: mongodb://mongodb:27017/rocketchat?replicaSet=rs0
      ROOT_URL: ${ROOT_URL}
      PORT: 3000
      DEPLOY_METHOD: docker
    ports:
      - "127.0.0.1:3000:3000"

volumes:
  mongodb_data:

Algunos detalles de esta configuración:

• El healthcheck de MongoDB inicializa el replica set la primera vez (rs.initiate) y, a partir de ahí, solo comprueba su estado. Rocket.Chat no arranca hasta que MongoDB está sano.
• MongoDB no publica ningún puerto: solo es accesible desde la red interna de Compose, por eso puede funcionar sin autenticación.
• Rocket.Chat publica el puerto 3000 solo en 127.0.0.1. Esto es importante porque Docker añade sus propias reglas de iptables y los puertos publicados en todas las interfaces quedarían accesibles aunque UFW los bloquee.
• mongo:7.0 es una versión compatible con las versiones actuales de Rocket.Chat. Antes de actualizar Rocket.Chat, comprueba en sus notas de versión qué versiones de MongoDB admite.

Valida el archivo:

docker compose config --quiet && echo "compose.yml OK"

compose.yml OK

Paso 3: Arrancar Rocket.Chat

Descarga las imágenes y arranca los contenedores en segundo plano:

docker compose up -d

El primer arranque tarda uno o dos minutos, mientras Rocket.Chat crea sus colecciones en MongoDB. Comprueba el estado:

docker compose ps

NAME                     IMAGE                                                COMMAND                  SERVICE      STATUS                    PORTS
rocketchat-mongodb-1     mongo:7.0                                            "docker-entrypoint.s…"   mongodb      Up 2 minutes (healthy)    27017/tcp
rocketchat-rocketchat-1  registry.rocket.chat/rocketchat/rocket.chat:X.Y.Z   "docker-entrypoint.s…"   rocketchat   Up 2 minutes              127.0.0.1:3000->3000/tcp

Cuando Rocket.Chat está listo, lo indica en el registro:

docker compose logs rocketchat | grep "SERVER RUNNING"

rocketchat-1  | |                      SERVER RUNNING                      |

Y responde en el puerto local:

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

HTTP/1.1 200 OK

Si no aparece el mensaje tras unos minutos, revisa el registro completo con docker compose logs rocketchat --tail 50.

Paso 4: Configurar Nginx como proxy inverso

Instala Nginx y Certbot, y abre los puertos en el cortafuegos. Permite SSH antes de activar UFW para no perder la conexión:

sudo apt update
sudo apt install nginx certbot python3-certbot-nginx
sudo ufw allow OpenSSH
sudo ufw allow "Nginx Full"
sudo ufw enable

Crea el sitio de Rocket.Chat:

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

Rocket.Chat mantiene una conexión WebSocket abierta con cada cliente, así que el proxy debe reenviar las cabeceras Upgrade y Connection:

server {
    listen 80;
    listen [::]:80;
    server_name chat.your_domain;

    client_max_body_size 200M;

    location / {
        proxy_pass http://127.0.0.1:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        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;
        proxy_set_header X-Nginx-Proxy true;
        proxy_redirect off;
        proxy_read_timeout 300s;
    }
}

client_max_body_size limita el tamaño de los archivos que se pueden subir al chat.

Activa el sitio, desactiva el sitio por defecto y recarga Nginx:

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

nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Paso 5: Activar HTTPS con Let's Encrypt

Solicita el certificado. Certbot añade la configuración TLS al sitio y la redirección de HTTP a HTTPS:

sudo certbot --nginx -d chat.your_domain

Comprueba que la renovación automática funcionará:

sudo certbot renew --dry-run

Congratulations, all simulated renewals succeeded:
  /etc/letsencrypt/live/chat.your_domain/fullchain.pem (success)

Y que el sitio responde por HTTPS:

curl -sI https://chat.your_domain | head -n 1

HTTP/1.1 200 OK

Paso 6: Completar el asistente de configuración

Abre https://chat.your_domain en el navegador. El asistente inicial te pedirá, en este orden:

1. Información del administrador: nombre, usuario, correo y contraseña de la cuenta de administrador.
2. Información de la organización: nombre, tipo, sector, tamaño y país.
3. Registro del espacio de trabajo: Rocket.Chat pide un correo para registrar el servidor en Rocket.Chat Cloud, necesario para las notificaciones push de las aplicaciones móviles y el Marketplace de aplicaciones. Recibirás un correo de confirmación.

Al terminar entrarás en el canal #general. Revisa después estos ajustes en Administración > Espacio de trabajo > Ajustes:

• Cuentas > Registro: elige quién puede crear cuentas. Para un servidor privado, configúralo para que solo se entre por invitación o con una URL secreta.
• Correo electrónico > SMTP: configura un servidor de correo para que funcionen las invitaciones, la verificación de correo y el restablecimiento de contraseñas.
• General > URL del sitio: debe ser https://chat.your_domain, el mismo valor que ROOT_URL.

Para verificar que el tiempo real funciona, abre Rocket.Chat con dos usuarios en dos navegadores y envía un mensaje directo: debe aparecer al instante sin recargar la página.

Paso 7: Programar copias de seguridad

Los mensajes, usuarios, ajustes y, por defecto, los archivos subidos se guardan en MongoDB (en GridFS). Una copia de la base de datos cubre por tanto todo el contenido. Crea un script de copia:

sudo nano /usr/local/bin/rocketchat-backup

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

BACKUP_DIR="/var/backups/rocketchat"
STAMP="$(date +%F_%H%M)"

mkdir -p "$BACKUP_DIR"
cd /opt/rocketchat
docker compose exec -T mongodb mongodump --db rocketchat --archive --gzip \
  > "$BACKUP_DIR/rocketchat_${STAMP}.archive.gz"

# Conserva solo las copias de los últimos 7 días
find "$BACKUP_DIR" -name 'rocketchat_*.archive.gz' -mtime +7 -delete

Hazlo ejecutable y pruébalo:

sudo chmod 750 /usr/local/bin/rocketchat-backup
sudo /usr/local/bin/rocketchat-backup
sudo ls -lh /var/backups/rocketchat

-rw-r--r-- 1 root root 4.2M ... rocketchat_2026-09-25_0300.archive.gz

Programa la copia cada noche a las 03:00 con el crontab de root:

sudo crontab -e

0 3 * * * /usr/local/bin/rocketchat-backup

Para restaurar una copia, con los contenedores en marcha:

cd /opt/rocketchat
docker compose exec -T mongodb mongorestore --archive --gzip --drop < /var/backups/rocketchat/rocketchat_FECHA.archive.gz
docker compose restart rocketchat

Envía las copias fuera del servidor para que sirvan si este se pierde.

Paso 8: Actualizar Rocket.Chat

Para actualizar, haz una copia, cambia RELEASE en /opt/rocketchat/.env por la nueva versión y recrea el contenedor:

sudo /usr/local/bin/rocketchat-backup
cd /opt/rocketchat
nano .env
docker compose pull
docker compose up -d

Rocket.Chat aplica las migraciones de base de datos al arrancar. Lee las notas de versión antes de saltar entre versiones mayores: suelen cambiar los requisitos de MongoDB y a veces exigen pasar por una versión intermedia.

Solución de problemas

• El contenedor de Rocket.Chat no arranca y MongoDB aparece como unhealthy: revisa docker compose logs mongodb. Puedes comprobar el replica set con docker compose exec mongodb mongosh --quiet --eval "rs.status().members[0].stateStr", que debe devolver PRIMARY.
• Error 502 Bad Gateway en Nginx: Rocket.Chat aún está arrancando o se ha detenido. Comprueba docker compose ps y espera al mensaje SERVER RUNNING.
• Los mensajes solo aparecen al recargar la página: falla el WebSocket. Revisa que el sitio de Nginx incluye las cabeceras Upgrade y Connection.
• Enlaces o avatares rotos: ROOT_URL no coincide con la URL real. Corrige .env, ejecuta docker compose up -d y revisa General > URL del sitio.

Conclusión

Ya tienes Rocket.Chat funcionando en Ubuntu 24.04 con Docker Compose, MongoDB, Nginx y HTTPS, con copias de seguridad diarias. Como siguientes pasos, configura el SMTP para las invitaciones, conecta tus aplicaciones del móvil y del escritorio a https://chat.your_domain y crea webhooks entrantes en Administración > Espacio de trabajo > Integraciones para recibir avisos de tus sistemas en un canal.