Instalación y Configuración de MongoDB: Guía Completa de Base de Datos NoSQL

Introducción

MongoDB es una base de datos de documentos NoSQL líder que ha revolucionado la forma en que las aplicaciones modernas almacenan y gestionan datos. A diferencia de las bases de datos relacionales tradicionales que usan tablas y filas, MongoDB almacena datos en documentos flexibles similares a JSON, haciéndola ideal para aplicaciones que requieren desarrollo rápido, escalabilidad y la capacidad de manejar tipos de datos diversos.

Desde su introducción en 2009, MongoDB se ha convertido en la base de datos NoSQL más popular, impulsando aplicaciones para empresas como Adobe, eBay, Google y Forbes. Su enfoque orientado a documentos proporciona a los desarrolladores flexibilidad mientras mantiene capacidades poderosas de consulta, escalabilidad horizontal y alto rendimiento.

Esta guía completa te guía a través de la instalación, configuración, endurecimiento de seguridad, optimización de rendimiento y mejores prácticas de MongoDB para ambientes de producción en diversas distribuciones de Linux.

¿Por Qué Elegir MongoDB?

MongoDB sobresale en escenarios que requieren:

Flexibilidad:

  • Diseño sin esquema permite iteración rápida
  • Los documentos pueden tener estructuras variables
  • Fácil de evolucionar modelos de datos sin migraciones
  • Formato de datos nativo JSON/BSON

Escalabilidad:

  • Escalamiento horizontal a través de sharding
  • Replicación integrada para alta disponibilidad
  • Capacidades de failover automático
  • Arquitectura distribuida

Rendimiento:

  • Motor de almacenamiento con mapeo de memoria
  • Indexación flexible incluyendo índices compuestos, geoespaciales y de texto
  • Framework de agregación para procesamiento complejo de datos
  • Optimizado para cargas de trabajo intensivas en lectura y escritura

Productividad del Desarrollador:

  • Lenguaje de consulta intuitivo
  • Rico ecosistema de drivers y herramientas
  • GridFS para almacenar archivos grandes
  • Pipeline de agregación integrado

Requisitos Previos

Antes de instalar MongoDB, asegúrate de que tu sistema cumpla con estos requisitos:

Requisitos del Sistema

Requisitos Mínimos:

  • Servidor Linux (Ubuntu 20.04+, Debian 11+, CentOS 8+, Rocky Linux 8+)
  • Acceso root o sudo
  • 2GB de RAM mínimo
  • 10GB de espacio en disco disponible
  • Arquitectura de 64 bits (requerida)

Recomendado para Producción:

  • 4+ núcleos de CPU
  • 16GB+ de RAM
  • Almacenamiento SSD con 100GB+ de espacio
  • Motor de almacenamiento WiredTiger (predeterminado en MongoDB 3.2+)
  • Sistema de archivos XFS o ext4
  • Servidor dedicado para base de datos

Verificación de Requisitos Previos

# Verificar arquitectura del sistema (debe ser 64-bit)
uname -m

# Verificar memoria disponible
free -h

# Verificar espacio en disco
df -h

# Verificar tipo de sistema de archivos
df -T

# Deshabilitar transparent huge pages (recomendado para MongoDB)
cat /sys/kernel/mm/transparent_hugepage/enabled

Instalación

Instalando MongoDB en Ubuntu/Debian

MongoDB proporciona repositorios oficiales para sistemas basados en Debian:

# Importar clave GPG pública de MongoDB
curl -fsSL https://pgp.mongodb.com/server-7.0.asc | \
   sudo gpg -o /usr/share/keyrings/mongodb-server-7.0.gpg \
   --dearmor

# Crear archivo de lista de repositorio de MongoDB (Ubuntu)
echo "deb [ arch=amd64,arm64 signed-by=/usr/share/keyrings/mongodb-server-7.0.gpg ] https://repo.mongodb.org/apt/ubuntu $(lsb_release -cs)/mongodb-org/7.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-7.0.list

# Para Debian
echo "deb [ signed-by=/usr/share/keyrings/mongodb-server-7.0.gpg ] http://repo.mongodb.org/apt/debian $(lsb_release -cs)/mongodb-org/7.0 main" | sudo tee /etc/apt/sources.list.d/mongodb-org-7.0.list

# Actualizar índice de paquetes
sudo apt update

# Instalar MongoDB
sudo apt install -y mongodb-org

# Fijar versión de MongoDB para prevenir actualizaciones no deseadas
echo "mongodb-org hold" | sudo dpkg --set-selections
echo "mongodb-org-database hold" | sudo dpkg --set-selections
echo "mongodb-org-server hold" | sudo dpkg --set-selections
echo "mongodb-mongosh hold" | sudo dpkg --set-selections
echo "mongodb-org-mongos hold" | sudo dpkg --set-selections
echo "mongodb-org-tools hold" | sudo dpkg --set-selections

# Iniciar MongoDB
sudo systemctl start mongod

# Habilitar MongoDB para iniciar en el arranque
sudo systemctl enable mongod

# Verificar instalación
sudo systemctl status mongod

Instalando MongoDB en CentOS/Rocky Linux

Para distribuciones basadas en Red Hat:

# Crear archivo de repositorio de MongoDB
sudo tee /etc/yum.repos.d/mongodb-org-7.0.repo << EOF
[mongodb-org-7.0]
name=MongoDB Repository
baseurl=https://repo.mongodb.org/yum/redhat/\$releasever/mongodb-org/7.0/x86_64/
gpgcheck=1
enabled=1
gpgkey=https://pgp.mongodb.com/server-7.0.asc
EOF

# Instalar MongoDB
sudo dnf install -y mongodb-org

# Iniciar MongoDB
sudo systemctl start mongod

# Habilitar MongoDB para iniciar en el arranque
sudo systemctl enable mongod

# Verificar instalación
sudo systemctl status mongod

Verificando la Instalación

Confirma que MongoDB está funcionando correctamente:

# Verificar versión de MongoDB
mongod --version

# Verificar estado del servicio
sudo systemctl status mongod

# Verificar proceso de MongoDB
ps aux | grep mongod

# Verificar puertos en escucha (predeterminado: 27017)
sudo ss -tulpn | grep 27017
sudo netstat -tulpn | grep 27017

# Conectar al shell de MongoDB
mongosh

# En mongosh, verificar versión
db.version()

# Salir de mongosh
exit

Estructura de Directorios

Entendiendo el diseño de directorios de MongoDB:

Configuración:

  • /etc/mongod.conf - Archivo de configuración principal

Datos:

  • /var/lib/mongo - Directorio de datos predeterminado

Registros:

  • /var/log/mongodb/mongod.log - Archivo de registro

Binarios:

  • /usr/bin/mongod - Servidor MongoDB
  • /usr/bin/mongos - Router de sharding de MongoDB
  • /usr/bin/mongosh - Shell de MongoDB

Configuración Inicial

Entendiendo mongod.conf

El archivo de configuración usa formato YAML:

# Editar archivo de configuración
sudo nano /etc/mongod.conf

Estructura básica de configuración:

# Configuración de red
net:
  port: 27017
  bindIp: 127.0.0.1

# Configuración de almacenamiento
storage:
  dbPath: /var/lib/mongo
  journal:
    enabled: true
  engine: wiredTiger
  wiredTiger:
    engineConfig:
      cacheSizeGB: 1

# Registro
systemLog:
  destination: file
  logAppend: true
  path: /var/log/mongodb/mongod.log

# Gestión de procesos
processManagement:
  timeZoneInfo: /usr/share/zoneinfo

# Seguridad
security:
  authorization: enabled

Habilitando Autenticación

Por defecto, MongoDB no tiene autenticación habilitada. Esto es inseguro para producción:

# Conectar a MongoDB sin autenticación
mongosh

# Cambiar a base de datos admin
use admin

# Crear usuario administrador
db.createUser({
  user: "admin",
  pwd: "tu_contraseña_fuerte",
  roles: [
    { role: "userAdminAnyDatabase", db: "admin" },
    { role: "readWriteAnyDatabase", db: "admin" },
    { role: "dbAdminAnyDatabase", db: "admin" },
    { role: "clusterAdmin", db: "admin" }
  ]
})

# Salir de mongosh
exit

Habilitar autenticación en mongod.conf:

security:
  authorization: enabled

Reiniciar MongoDB:

sudo systemctl restart mongod

# Conectar con autenticación
mongosh -u admin -p tu_contraseña_fuerte --authenticationDatabase admin

Creando Usuarios de Aplicación

Crear usuarios específicos para aplicaciones:

// Conectar como admin
mongosh -u admin -p tu_contraseña_fuerte --authenticationDatabase admin

// Cambiar a base de datos de aplicación
use myapp_db

// Crear usuario de aplicación con acceso lectura/escritura
db.createUser({
  user: "myapp_user",
  pwd: "contraseña_segura",
  roles: [
    { role: "readWrite", db: "myapp_db" }
  ]
})

// Crear usuario de solo lectura
db.createUser({
  user: "readonly_user",
  pwd: "contraseña_readonly",
  roles: [
    { role: "read", db: "myapp_db" }
  ]
})

// Verificar usuarios
db.getUsers()

// Probar autenticación
exit
mongosh -u myapp_user -p contraseña_segura --authenticationDatabase myapp_db

Roles Integrados

MongoDB proporciona roles integrados completos:

Roles de Usuario de Base de Datos:

  • read - Leer datos en colecciones no del sistema
  • readWrite - Leer y escribir datos en colecciones no del sistema

Roles de Administración de Base de Datos:

  • dbAdmin - Tareas administrativas en base de datos
  • dbOwner - Control total sobre base de datos
  • userAdmin - Crear y modificar usuarios

Roles de Administración de Clúster:

  • clusterAdmin - Administración completa de clúster
  • clusterManager - Operaciones de gestión de clúster
  • clusterMonitor - Monitoreo de clúster solo lectura
  • hostManager - Monitorear y gestionar servidores

Roles de Respaldo y Restauración:

  • backup - Respaldar base de datos
  • restore - Restaurar base de datos

Roles de Todas las Bases de Datos:

  • readAnyDatabase - Leer cualquier base de datos
  • readWriteAnyDatabase - Lectura/escritura en cualquier base de datos
  • userAdminAnyDatabase - Admin de usuario en cualquier base de datos
  • dbAdminAnyDatabase - Admin de BD en cualquier base de datos

Habilitando Acceso Remoto

Configurar MongoDB para aceptar conexiones remotas:

# Editar /etc/mongod.conf
net:
  port: 27017
  bindIp: 0.0.0.0  # Escuchar en todas las interfaces
  # O IP específica: bindIp: 127.0.0.1,192.168.1.100

Por seguridad, restringir a IPs específicas cuando sea posible:

net:
  port: 27017
  bindIp: 127.0.0.1,192.168.1.100,10.0.0.50

Reiniciar MongoDB:

sudo systemctl restart mongod

# Verificar binding
sudo ss -tulpn | grep 27017

Endurecimiento de Seguridad

Configuración de Firewall

Restringir acceso a MongoDB usando reglas de firewall:

# UFW (Ubuntu/Debian)
# Permitir desde IP específica
sudo ufw allow from 192.168.1.50 to any port 27017

# Permitir desde subred
sudo ufw allow from 192.168.1.0/24 to any port 27017

# Verificar reglas
sudo ufw status numbered

# firewalld (CentOS/Rocky)
# Permitir desde IP específica
sudo firewall-cmd --permanent --add-rich-rule='rule family="ipv4" source address="192.168.1.50" port protocol="tcp" port="27017" accept'

# Permitir desde subred
sudo firewall-cmd --permanent --add-rich-rule='rule family="ipv4" source address="192.168.1.0/24" port protocol="tcp" port="27017" accept'

# Recargar firewall
sudo firewall-cmd --reload

# Verificar reglas
sudo firewall-cmd --list-all

Habilitando Cifrado SSL/TLS

Generar certificados SSL:

# Crear directorio para certificados
sudo mkdir -p /etc/ssl/mongodb
cd /etc/ssl/mongodb

# Generar clave privada y solicitud de firma de certificado
sudo openssl req -newkey rsa:2048 -nodes -keyout mongodb.key -out mongodb.csr

# Generar certificado autofirmado (365 días)
sudo openssl x509 -req -days 365 -in mongodb.csr -signkey mongodb.key -out mongodb.crt

# Combinar clave y certificado
sudo cat mongodb.key mongodb.crt > mongodb.pem

# Establecer permisos apropiados
sudo chmod 600 mongodb.pem
sudo chown mongodb:mongodb mongodb.pem

Configurar SSL en mongod.conf:

net:
  port: 27017
  bindIp: 0.0.0.0
  tls:
    mode: requireTLS
    certificateKeyFile: /etc/ssl/mongodb/mongodb.pem
    allowConnectionsWithoutCertificates: true

Reiniciar MongoDB:

sudo systemctl restart mongod

# Conectar con TLS
mongosh --tls --tlsAllowInvalidCertificates -u admin -p --authenticationDatabase admin

Cifrado en Reposo

Habilitar cifrado para datos en reposo (característica Enterprise, o usar LUKS):

security:
  enableEncryption: true
  encryptionKeyFile: /etc/mongodb/encryption-keyfile

Para Community Edition, usar cifrado de disco LUKS:

# Ver guía de cifrado de disco para configuración completa de LUKS
# Cifrar la partición de datos antes de la instalación de MongoDB

Deshabilitando Transparent Huge Pages

MongoDB recomienda deshabilitar THP para mejor rendimiento:

# Crear servicio systemd
sudo nano /etc/systemd/system/disable-transparent-huge-pages.service

Agregar contenido:

[Unit]
Description=Disable Transparent Huge Pages (THP)
DefaultDependencies=no
After=sysinit.target local-fs.target
Before=mongod.service

[Service]
Type=oneshot
ExecStart=/bin/sh -c 'echo never | tee /sys/kernel/mm/transparent_hugepage/enabled > /dev/null'
ExecStart=/bin/sh -c 'echo never | tee /sys/kernel/mm/transparent_hugepage/defrag > /dev/null'

[Install]
WantedBy=basic.target

Habilitar servicio:

sudo systemctl daemon-reload
sudo systemctl enable disable-transparent-huge-pages
sudo systemctl start disable-transparent-huge-pages

# Verificar
cat /sys/kernel/mm/transparent_hugepage/enabled
cat /sys/kernel/mm/transparent_hugepage/defrag

Registro de Auditoría (Característica Enterprise)

Para MongoDB Enterprise, habilitar registro completo de auditoría:

auditLog:
  destination: file
  format: JSON
  path: /var/log/mongodb/auditLog.json
  filter: '{ atype: { $in: [ "authenticate", "createUser", "dropUser" ] } }'

Lista Blanca de IP

Restringir acceso a direcciones IP específicas:

net:
  bindIp: 127.0.0.1,192.168.1.100
  ipv6: false

Crear usuarios de MongoDB con restricciones de IP:

// Crear usuario restringido a IP específica
db.createUser({
  user: "restricted_user",
  pwd: "contraseña",
  roles: [{ role: "readWrite", db: "myapp_db" }],
  authenticationRestrictions: [{
    clientSource: ["192.168.1.50"],
    serverAddress: ["192.168.1.100"]
  }]
})

Optimización de Rendimiento

Configuración del Motor de Almacenamiento

MongoDB usa motor de almacenamiento WiredTiger por defecto:

storage:
  dbPath: /var/lib/mongo
  journal:
    enabled: true
  engine: wiredTiger
  wiredTiger:
    engineConfig:
      # Tamaño de caché (predeterminado: 50% de RAM - 1GB)
      cacheSizeGB: 8
      journalCompressor: snappy
      directoryForIndexes: true
    collectionConfig:
      blockCompressor: snappy
    indexConfig:
      prefixCompression: true

Recomendaciones de dimensionamiento de caché:

  • Servidor MongoDB dedicado: 50% de RAM
  • Servidor compartido: 25-40% de RAM
  • Mínimo: 256MB
  • Máximo: RAM - 1GB (para operaciones del sistema)

Configuración de Memoria

# Establecer tamaño de caché apropiadamente
storage:
  wiredTiger:
    engineConfig:
      cacheSizeGB: 8  # Ajustar basado en RAM disponible

# Cálculos de ejemplo:
# Servidor con 16GB RAM: cacheSizeGB: 6-8
# Servidor con 32GB RAM: cacheSizeGB: 14-16
# Servidor con 64GB RAM: cacheSizeGB: 30-32

Optimización de Índices

La indexación efectiva es crítica para el rendimiento de MongoDB:

// Crear índice de campo único
db.collection.createIndex({ field: 1 })

// Crear índice compuesto
db.collection.createIndex({ field1: 1, field2: -1 })

// Crear índice único
db.collection.createIndex({ email: 1 }, { unique: true })

// Crear índice disperso (solo documentos con campo)
db.collection.createIndex({ optional_field: 1 }, { sparse: true })

// Crear índice TTL (eliminar automáticamente documentos)
db.collection.createIndex({ createdAt: 1 }, { expireAfterSeconds: 86400 })

// Crear índice de texto para búsqueda de texto completo
db.collection.createIndex({ content: "text" })

// Crear índice geoespacial
db.collection.createIndex({ location: "2dsphere" })

// Listar todos los índices
db.collection.getIndexes()

// Analizar uso de índice
db.collection.aggregate([{ $indexStats: {} }])

// Encontrar consultas lentas sin índices
db.currentOp({
  "active": true,
  "secs_running": { "$gt": 3 }
})

Optimización de Consultas

Optimizar consultas para mejor rendimiento:

// Usar explain para analizar rendimiento de consulta
db.collection.find({ field: "value" }).explain("executionStats")

// Usar proyección para devolver solo campos necesarios
db.collection.find(
  { status: "active" },
  { name: 1, email: 1, _id: 0 }
)

// Usar limit con skip para paginación
db.collection.find().skip(20).limit(10)

// Evitar valores grandes de skip (usar consultas de rango en su lugar)
// Malo:
db.collection.find().skip(1000000).limit(10)

// Bueno:
db.collection.find({ _id: { $gt: lastSeenId } }).limit(10)

// Usar pipeline de agregación eficientemente
db.collection.aggregate([
  { $match: { status: "active" } },      // Filtrar primero
  { $sort: { createdAt: -1 } },          // Luego ordenar
  { $limit: 100 },                       // Limitar temprano
  { $project: { name: 1, email: 1 } }    // Proyectar último
])

// Usar consultas cubiertas (consulta cubierta por índice)
db.collection.find(
  { status: "active" },
  { status: 1, _id: 0 }
).hint({ status: 1 })

Configuración de Pool de Conexiones

Configurar pooling de conexiones en aplicación:

# URI de MongoDB con configuración de pool de conexiones
mongodb://user:password@localhost:27017/myapp_db?maxPoolSize=100&minPoolSize=10&maxIdleTimeMS=60000

Mejores prácticas:

  • maxPoolSize: 100-200 para aplicaciones típicas
  • minPoolSize: 10-20 para mantener conexiones listas
  • maxIdleTimeMS: Cerrar conexiones inactivas después de 60 segundos

Monitoreando Rendimiento

Habilitar profiling para identificar consultas lentas:

// Habilitar profiling (nivel 2 = registrar todas las operaciones)
db.setProfilingLevel(2)

// Habilitar profiling solo para consultas lentas (> 100ms)
db.setProfilingLevel(1, { slowms: 100 })

// Verificar estado de profiling
db.getProfilingStatus()

// Ver consultas lentas
db.system.profile.find().limit(10).sort({ ts: -1 }).pretty()

// Encontrar consultas más lentas
db.system.profile.find().sort({ millis: -1 }).limit(5)

// Deshabilitar profiling
db.setProfilingLevel(0)

Métricas clave de rendimiento:

// Estado del servidor
db.serverStatus()

// Estadísticas de base de datos
db.stats()

// Estadísticas de colección
db.collection.stats()

// Operaciones actuales
db.currentOp()

// Estadísticas de conexión
db.serverStatus().connections

// Contadores de operaciones
db.serverStatus().opcounters

// Estadísticas de red
db.serverStatus().network

// Uso de memoria
db.serverStatus().mem

Estrategias de Respaldo

Usando mongodump para Respaldos

Operaciones básicas de respaldo:

# Respaldar base de datos completa
mongodump --db myapp_db --out /backup/mongodb_$(date +%Y%m%d)

# Respaldar con autenticación
mongodump \
  --uri="mongodb://admin:password@localhost:27017/myapp_db?authSource=admin" \
  --out /backup/mongodb_$(date +%Y%m%d)

# Respaldar todas las bases de datos
mongodump \
  --uri="mongodb://admin:password@localhost:27017/?authSource=admin" \
  --out /backup/all_dbs_$(date +%Y%m%d)

# Respaldar colección específica
mongodump \
  --db myapp_db \
  --collection users \
  --out /backup/users_$(date +%Y%m%d)

# Respaldar con compresión
mongodump \
  --uri="mongodb://admin:password@localhost:27017/myapp_db?authSource=admin" \
  --gzip \
  --out /backup/compressed_$(date +%Y%m%d)

# Respaldar a archivo archive
mongodump \
  --uri="mongodb://admin:password@localhost:27017/myapp_db?authSource=admin" \
  --archive=/backup/myapp_$(date +%Y%m%d).archive \
  --gzip

Restaurando desde Respaldo

# Restaurar base de datos
mongorestore --db myapp_db /backup/mongodb_20260111/myapp_db

# Restaurar con autenticación
mongorestore \
  --uri="mongodb://admin:password@localhost:27017/?authSource=admin" \
  --db myapp_db \
  /backup/mongodb_20260111/myapp_db

# Restaurar todas las bases de datos
mongorestore \
  --uri="mongodb://admin:password@localhost:27017/?authSource=admin" \
  /backup/all_dbs_20260111

# Restaurar desde archive
mongorestore \
  --uri="mongodb://admin:password@localhost:27017/?authSource=admin" \
  --gzip \
  --archive=/backup/myapp_20260111.archive

# Restaurar colección específica
mongorestore \
  --db myapp_db \
  --collection users \
  /backup/mongodb_20260111/myapp_db/users.bson

# Restaurar y eliminar colecciones existentes
mongorestore --drop --db myapp_db /backup/mongodb_20260111/myapp_db

Script de Respaldo Automatizado

Crear script de respaldo completo:

sudo nano /usr/local/bin/mongodb-backup.sh

Agregar contenido:

#!/bin/bash

# Configuración
BACKUP_DIR="/backups/mongodb"
MONGO_URI="mongodb://admin:tu_contraseña@localhost:27017/?authSource=admin"
RETENTION_DAYS=7
DATE=$(date +%Y%m%d_%H%M%S)
LOG_FILE="$BACKUP_DIR/backup.log"

# Crear directorio de respaldo
mkdir -p $BACKUP_DIR

# Función para registrar mensajes
log_message() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a $LOG_FILE
}

# Iniciar respaldo
log_message "Iniciando respaldo de MongoDB"

# Realizar respaldo
mongodump \
    --uri="$MONGO_URI" \
    --gzip \
    --archive=$BACKUP_DIR/mongodb_backup_$DATE.archive

if [ $? -eq 0 ]; then
    log_message "Respaldo completado exitosamente: mongodb_backup_$DATE.archive"

    # Calcular tamaño de respaldo
    SIZE=$(du -h $BACKUP_DIR/mongodb_backup_$DATE.archive | cut -f1)
    log_message "Tamaño del respaldo: $SIZE"
else
    log_message "ERROR: Respaldo falló"
    exit 1
fi

# Eliminar respaldos antiguos
DELETED=$(find $BACKUP_DIR -name "mongodb_backup_*.archive" -mtime +$RETENTION_DAYS -delete -print | wc -l)
log_message "Eliminados $DELETED respaldo(s) antiguo(s) mayores de $RETENTION_DAYS días"

# Tamaño total del directorio de respaldo
TOTAL_SIZE=$(du -sh $BACKUP_DIR | cut -f1)
log_message "Tamaño total del directorio de respaldo: $TOTAL_SIZE"

log_message "Proceso de respaldo completado"

Hacer ejecutable y programar:

# Hacer ejecutable
sudo chmod +x /usr/local/bin/mongodb-backup.sh

# Probar script
sudo /usr/local/bin/mongodb-backup.sh

# Programar con cron (diario a las 2 AM)
sudo crontab -e

# Agregar línea:
0 2 * * * /usr/local/bin/mongodb-backup.sh

Snapshots de Sistema de Archivos

Para ambientes en la nube, usar snapshots de sistema de archivos:

# Snapshot de EBS de AWS
aws ec2 create-snapshot \
    --volume-id vol-1234567890abcdef0 \
    --description "Respaldo de MongoDB $(date +%Y%m%d)"

# Antes del snapshot, asegurar consistencia
mongosh --eval "db.fsyncLock()"
# Tomar snapshot
# Después del snapshot
mongosh --eval "db.fsyncUnlock()"

Respaldos de Replica Set

Para replica sets, respaldar desde secundario:

# Conectar a secundario
mongosh --host secondary.example.com

# Verificar que es secundario
rs.status()

# Realizar respaldo desde secundario (menos impacto en primario)
mongodump \
    --host secondary.example.com \
    --uri="mongodb://admin:[email protected]:27017/?authSource=admin" \
    --gzip \
    --out /backup/replica_backup_$(date +%Y%m%d)

Solución de Problemas

Problemas de Conexión

No se puede conectar a MongoDB:

# Verificar si MongoDB está en ejecución
sudo systemctl status mongod

# Verificar proceso de MongoDB
ps aux | grep mongod

# Verificar puertos en escucha
sudo ss -tulpn | grep 27017

# Verificar logs para errores
sudo tail -f /var/log/mongodb/mongod.log

# Probar conexión local
mongosh

# Probar conexión remota
mongosh --host 192.168.1.100 --port 27017

# Verificar firewall
sudo ufw status
sudo firewall-cmd --list-all

Fallos de Autenticación

// Verificar que el usuario existe
use admin
db.getUsers()

// Verificar roles de usuario
db.getUser("username")

// Restablecer contraseña de usuario
use admin
db.changeUserPassword("username", "nueva_contraseña")

// Verificar autenticación
db.auth("username", "contraseña")

Problemas de Rendimiento

Identificar y resolver problemas de rendimiento:

// Encontrar operaciones lentas actuales
db.currentOp({
  "active": true,
  "secs_running": { "$gt": 3 }
})

// Terminar operación lenta
db.killOp(opid)

// Verificar estado del servidor
db.serverStatus()

// Verificar índices faltantes
db.collection.find({ field: "value" }).explain("executionStats")

// Ver estadísticas de colección
db.collection.stats()

// Compactar colección para recuperar espacio
db.runCommand({ compact: "collection_name" })

// Reparar base de datos
db.repairDatabase()

Alto Uso de Memoria

# Verificar uso de memoria
free -h

# Verificar uso de memoria de MongoDB
ps aux | grep mongod

# Ajustar tamaño de caché en /etc/mongod.conf
storage:
  wiredTiger:
    engineConfig:
      cacheSizeGB: 4  # Reducir si es necesario

# Reiniciar MongoDB
sudo systemctl restart mongod

Problemas de Espacio en Disco

# Verificar uso de disco
df -h

# Verificar tamaño del directorio de datos de MongoDB
sudo du -sh /var/lib/mongo

# Verificar tamaños de bases de datos individuales
sudo du -sh /var/lib/mongo/*

# Eliminar archivos antiguos de journal (MongoDB hace esto automáticamente)
# Compactar colecciones para recuperar espacio
mongosh --eval "db.collection.compact()"

# Eliminar bases de datos no utilizadas
mongosh --eval "use old_database; db.dropDatabase()"

Retraso de Replicación

// Verificar estado de replica set
rs.status()

// Verificar retraso de replicación
rs.printReplicationInfo()

// Verificar estado de oplog
db.printReplicationInfo()

// Ver retraso de secundarios
rs.status().members.forEach(function(member) {
  if (member.stateStr == "SECONDARY") {
    print(member.name + " retraso: " + (member.optimeDate.getTime() - member.lastHeartbeat.getTime()) + "ms")
  }
})

Conclusión

MongoDB proporciona una solución de base de datos poderosa, flexible y escalable para aplicaciones modernas. Esta guía completa ha cubierto todo desde la instalación hasta configuración, seguridad, optimización y solución de problemas.

Puntos Clave

  1. Seguridad Primero: Siempre habilita autenticación y usa SSL/TLS para producción
  2. Optimiza Almacenamiento: Configura caché de WiredTiger apropiadamente para tu carga de trabajo
  3. Indexa Estratégicamente: Crea índices para campos consultados frecuentemente
  4. Monitorea Rendimiento: Usa profiling y estado del servidor para identificar cuellos de botella
  5. Respalda Regularmente: Implementa estrategias de respaldo automatizadas con retención apropiada
  6. Planifica para Escala: Diseña con replicación y sharding en mente desde el inicio

Resumen de Mejores Prácticas

  • Habilitar autenticación antes de exponer a red
  • Usar SSL/TLS para todas las conexiones remotas
  • Deshabilitar transparent huge pages
  • Optimizar tamaño de caché de WiredTiger basado en RAM
  • Crear índices apropiados para patrones de consulta
  • Usar proyección para devolver solo campos necesarios
  • Implementar connection pooling en aplicaciones
  • Programar respaldos automatizados regulares
  • Monitorear consultas lentas y optimizar
  • Usar replica sets para alta disponibilidad
  • Documentar tu configuración y procedimientos
  • Mantener MongoDB actualizado con parches de seguridad
  • Usar compresión apropiada para almacenamiento
  • Implementar monitoreo y alertas apropiados

Próximos Pasos

Después de dominar los fundamentos, explora temas avanzados de MongoDB:

  • Replica Sets: Configurar alta disponibilidad con failover automático
  • Sharding: Implementar escalamiento horizontal para grandes conjuntos de datos
  • Framework de Agregación: Dominar pipelines complejos de procesamiento de datos
  • Change Streams: Implementar procesamiento de datos en tiempo real
  • Transacciones: Usar transacciones ACID multi-documento
  • Atlas: Explorar servicio en la nube gestionado de MongoDB
  • Optimización de Rendimiento: Técnicas avanzadas de optimización
  • Seguridad: Implementar cifrado a nivel de campo e integración LDAP

Recursos Adicionales

La flexibilidad y escalabilidad de MongoDB la hacen una excelente elección para aplicaciones modernas. Siguiendo esta guía y continuando aprendiendo, estarás bien equipado para diseñar, desplegar y mantener bases de datos MongoDB que satisfagan las necesidades de tu aplicación mientras aseguran seguridad, rendimiento y confiabilidad.