---
title: "Cómo instalar Rocket.Chat en Ubuntu 24.04 con Docker"
description: "Despliega Rocket.Chat en Ubuntu 24.04 con Docker Compose y MongoDB, publícalo con Nginx y HTTPS de Let's Encrypt y programa copias de seguridad diarias."
category: "Hosting de Aplicaciones Web"
language: es
source: https://cubepath.com/es/docs/hosting-de-aplicaciones-web/instalacion-y-configuracion-de-rocketchat
updated: 2026-09-25
---

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

```bash
docker --version
docker compose version
```

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

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

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

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

```bash
nano /opt/rocketchat/compose.yml
```

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

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

```output
compose.yml OK
```

## Paso 3: Arrancar Rocket.Chat

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

```bash
docker compose up -d
```

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

```bash
docker compose ps
```

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

```bash
docker compose logs rocketchat | grep "SERVER RUNNING"
```

```output
rocketchat-1  | |                      SERVER RUNNING                      |
```

Y responde en el puerto local:

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

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

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

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

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

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

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

```bash
sudo certbot --nginx -d chat.your_domain
```

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

```bash
sudo certbot renew --dry-run
```

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

Y que el sitio responde por HTTPS:

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

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

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

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

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

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

```bash
sudo crontab -e
```

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

Para restaurar una copia, con los contenedores en marcha:

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

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