---
title: "Cómo instalar y asegurar MongoDB 8.0 en Ubuntu 24.04"
description: "Instala MongoDB 8.0 Community desde el repositorio oficial en Ubuntu 24.04, activa la autenticación, limita el acceso por red y programa copias con mongodump."
category: "Gestión de Bases de Datos"
language: es
source: https://cubepath.com/es/docs/gestión-de-bases-de-datos/instalacion-y-configuracion-de-mongodb
updated: 2026-09-25
---

# Cómo instalar y asegurar MongoDB 8.0 en Ubuntu 24.04

MongoDB es una base de datos NoSQL orientada a documentos que guarda los datos en formato BSON, parecido a JSON, y permite cambiar el esquema sin migraciones. En este tutorial instalarás MongoDB 8.0 Community Edition desde el repositorio oficial en Ubuntu 24.04, crearás un usuario administrador, activarás la autenticación, abrirás el acceso solo a los servidores de tu aplicación y programarás copias de seguridad diarias con `mongodump`.

## Requisitos previos

Para seguir esta guía necesitas:

- Un servidor con Ubuntu 24.04 LTS de 64 bits (x86_64 o arm64), por ejemplo un VPS de CubePath.
- Un usuario no root con privilegios `sudo`.
- Al menos 2 GB de RAM. MongoDB usa por defecto la mitad de la RAM menos 1 GB para su caché (WiredTiger), así que con menos memoria funcionará, pero con poco margen.
- UFW activo con el acceso SSH permitido.

> Nota: Ubuntu no incluye MongoDB en sus repositorios por motivos de licencia. No instales el paquete `mongodb` de repositorios antiguos ni imágenes de terceros: usa siempre el repositorio de `repo.mongodb.org`.

## Paso 1: Añadir el repositorio oficial de MongoDB

Instala las herramientas necesarias para descargar y verificar la clave del repositorio:

```bash
sudo apt update
sudo apt install gnupg curl
```

Descarga la clave pública de MongoDB 8.0 y guárdala en `/etc/apt/keyrings`:

```bash
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://www.mongodb.org/static/pgp/server-8.0.asc | sudo gpg --dearmor -o /etc/apt/keyrings/mongodb-server-8.0.gpg
```

Añade el repositorio para Ubuntu 24.04 (`noble`), firmado con esa clave:

```bash
echo "deb [ arch=amd64,arm64 signed-by=/etc/apt/keyrings/mongodb-server-8.0.gpg ] https://repo.mongodb.org/apt/ubuntu noble/mongodb-org/8.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-8.0.list
```

Actualiza el índice de paquetes y comprueba que apt ve la versión del repositorio de MongoDB:

```bash
sudo apt update
apt policy mongodb-org
```

```output
mongodb-org:
  Installed: (none)
  Candidate: 8.0.x
  Version table:
     8.0.x 500
        500 https://repo.mongodb.org/apt/ubuntu noble/mongodb-org/8.0/multiverse amd64 Packages
```

## Paso 2: Instalar MongoDB y arrancar el servicio

El metapaquete `mongodb-org` instala el servidor (`mongod`), la shell `mongosh` y las herramientas de base de datos (`mongodump`, `mongorestore`):

```bash
sudo apt install mongodb-org
```

El paquete no arranca el servicio automáticamente. Actívalo y arráncalo con systemd:

```bash
sudo systemctl enable --now mongod
```

Comprueba que está en ejecución:

```bash
sudo systemctl status mongod
```

```output
● mongod.service - MongoDB Database Server
     Loaded: loaded (/usr/lib/systemd/system/mongod.service; enabled; preset: enabled)
     Active: active (running) since ...
       Docs: https://docs.mongodb.org/manual
   Main PID: 4211 (mongod)
```

Conéctate con `mongosh` y lanza un `ping` para confirmar que el servidor responde:

```bash
mongosh --eval 'db.runCommand({ ping: 1 })'
```

```output
{ ok: 1 }
```

Los archivos que vas a usar en el resto de la guía son:

| Ruta | Contenido |
|------|-----------|
| `/etc/mongod.conf` | Configuración del servidor (YAML) |
| `/var/lib/mongodb` | Directorio de datos |
| `/var/log/mongodb/mongod.log` | Log del servidor |

## Paso 3: Crear el usuario administrador

Recién instalado, MongoDB acepta conexiones locales sin contraseña. Antes de activar la autenticación tienes que crear un usuario administrador; si la activas primero, te quedarás sin forma de gestionar usuarios.

Abre la shell:

```bash
mongosh
```

Cambia a la base de datos `admin` y crea el usuario. `passwordPrompt()` pide la contraseña de forma interactiva para que no quede en el historial de la shell:

```javascript
use admin
db.createUser({
  user: "admin",
  pwd: passwordPrompt(),
  roles: [
    { role: "userAdminAnyDatabase", db: "admin" },
    { role: "readWriteAnyDatabase", db: "admin" }
  ]
})
```

```output
Enter password
************{ ok: 1 }
```

Sal de la shell con `exit`.

## Paso 4: Activar la autenticación

Edita el archivo de configuración:

```bash
sudo nano /etc/mongod.conf
```

Busca la sección `#security:` (comentada por defecto) y sustitúyela por este bloque. Respeta la indentación de dos espacios, porque el archivo es YAML:

```yaml
security:
  authorization: enabled
```

Reinicia MongoDB para aplicar el cambio:

```bash
sudo systemctl restart mongod
```

Comprueba que ahora las operaciones sin credenciales se rechazan:

```bash
mongosh --quiet --eval 'db.getSiblingDB("admin").getUsers()'
```

```output
MongoServerError: Command usersInfo requires authentication
```

Conéctate de nuevo, esta vez como administrador. `-p` sin valor hace que `mongosh` pida la contraseña:

```bash
mongosh -u admin -p --authenticationDatabase admin
```

Dentro de la shell, `db.runCommand({ connectionStatus: 1 })` debe mostrar el usuario `admin` en `authenticatedUsers`.

## Paso 5: Crear un usuario para tu aplicación

La aplicación no debe usar el usuario administrador. Crea uno con permisos de lectura y escritura solo sobre su base de datos. Estando conectado como `admin`, ejecuta (sustituye `miapp` por el nombre de tu base de datos):

```javascript
use miapp
db.createUser({
  user: "miapp_user",
  pwd: passwordPrompt(),
  roles: [ { role: "readWrite", db: "miapp" } ]
})
```

Comprueba que el usuario funciona insertando y leyendo un documento:

```bash
mongosh "mongodb://miapp_user@127.0.0.1:27017/miapp?authSource=miapp" --eval 'db.test.insertOne({ ok: true }); db.test.countDocuments()'
```

```output
1
```

La cadena de conexión que usará tu aplicación tiene esta forma:

```text
mongodb://miapp_user:tu_contraseña@your_server_ip:27017/miapp?authSource=miapp
```

## Paso 6: Permitir conexiones remotas de forma controlada

Por defecto `mongod` solo escucha en `127.0.0.1`. Si tu aplicación corre en el mismo servidor, no cambies nada y pasa al paso 7.

Si la aplicación está en otro servidor, añade la IP privada o pública de este servidor a `bindIp` en `/etc/mongod.conf`:

```bash
sudo nano /etc/mongod.conf
```

```yaml
net:
  port: 27017
  bindIp: 127.0.0.1,your_server_ip
```

Reinicia el servicio y comprueba en qué direcciones escucha:

```bash
sudo systemctl restart mongod
sudo ss -tlnp | grep 27017
```

```output
LISTEN 0  4096  your_server_ip:27017  0.0.0.0:*  users:(("mongod",pid=4630,fd=15))
LISTEN 0  4096       127.0.0.1:27017  0.0.0.0:*  users:(("mongod",pid=4630,fd=14))
```

Abre el puerto 27017 solo para la IP de tu servidor de aplicación (`app_server_ip`), nunca para todo Internet:

```bash
sudo ufw allow from app_server_ip to any port 27017 proto tcp
sudo ufw status
```

> Advertencia: una instancia de MongoDB expuesta en Internet con `bindIp: 0.0.0.0` y sin autenticación es uno de los orígenes más habituales de filtraciones de datos. Mantén siempre la autenticación activa y el puerto filtrado por IP. Si el tráfico pasa por redes que no controlas, configura también TLS.

Desde el servidor de aplicación, prueba la conexión con `mongosh` o con el driver de tu lenguaje usando la cadena del paso anterior.

## Paso 7: Programar copias de seguridad con mongodump

`mongodump` exporta las bases de datos a un archivo comprimido que luego puedes restaurar con `mongorestore`. Crea un usuario dedicado con el rol integrado `backup`. Conéctate como administrador y ejecuta:

```javascript
use admin
db.createUser({
  user: "backup",
  pwd: passwordPrompt(),
  roles: [ { role: "backup", db: "admin" } ]
})
```

Guarda la contraseña en un archivo de configuración legible solo por root, para no ponerla en la línea de comandos (donde la vería cualquier usuario con `ps`):

```bash
sudo install -m 0700 -d /var/backups/mongodb
sudo nano /etc/mongodump.yaml
```

```yaml
password: tu_contraseña_de_backup
```

```bash
sudo chmod 600 /etc/mongodump.yaml
```

Crea el script de copia:

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

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

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

mongodump \
  --uri="mongodb://backup@127.0.0.1:27017/?authSource=admin" \
  --config=/etc/mongodump.yaml \
  --archive="${BACKUP_DIR}/mongodb_${STAMP}.archive.gz" \
  --gzip

find "${BACKUP_DIR}" -name 'mongodb_*.archive.gz' -mtime +"${RETENTION_DAYS}" -delete
```

Hazlo ejecutable y pruébalo:

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

```output
-rw-r--r-- 1 root root 1.2K ... mongodb_2026-09-25_0300.archive.gz
```

Prográmalo cada día a las 03:00 con cron:

```bash
echo '0 3 * * * root /usr/local/bin/mongodb-backup' | sudo tee /etc/cron.d/mongodb-backup
```

Para restaurar una copia sobre el servidor (por ejemplo, en un entorno de pruebas), usa el usuario administrador:

```bash
mongorestore -u admin -p --authenticationDatabase admin --gzip --archive=/var/backups/mongodb/mongodb_2026-09-25_0300.archive.gz
```

> Importante: una copia que solo vive en el mismo servidor no te protege si el disco falla. Copia los archivos a otro almacenamiento (otro servidor, almacenamiento de objetos) y prueba la restauración de vez en cuando.

## Solución de problemas

**`mongod` no arranca y el estado muestra `status=14`.** Suele ser un problema de permisos, normalmente tras lanzar `mongod` a mano como root. Revisa el log y corrige el propietario de los archivos:

```bash
sudo tail -n 50 /var/log/mongodb/mongod.log
sudo chown -R mongodb:mongodb /var/lib/mongodb /var/log/mongodb
sudo rm -f /tmp/mongodb-27017.sock
sudo systemctl start mongod
```

**`mongod` no arranca después de editar `/etc/mongod.conf`.** Casi siempre es un error de indentación YAML (tabuladores o espacios de más). `journalctl -u mongod -n 50` muestra la línea que falla.

**`Authentication failed` desde la aplicación.** Comprueba que `authSource` apunta a la base de datos donde creaste el usuario (`miapp` en el paso 5, `admin` para el administrador).

**Conexión remota rechazada o con timeout.** Verifica que `ss -tlnp` muestra la IP correcta en el puerto 27017 y que `sudo ufw status` permite la IP de origen.

## Conclusión

Tienes MongoDB 8.0 instalado desde el repositorio oficial, con autenticación obligatoria, un usuario con permisos mínimos para tu aplicación, el puerto limitado a las IP que lo necesitan y copias diarias con rotación. Como siguientes pasos, puedes configurar TLS en la sección `net.tls` de `mongod.conf`, montar un replica set de tres nodos para tener alta disponibilidad, y crear índices sobre los campos que más consultas, revisando los planes con `explain()`.