MongoDB

¿Qué es MongoDB?

MongoDB es un sistema de gestión de bases de datos NoSQL que almacena la información en documentos BSON (una extensión de JSON).

Se diferencia de bases de datos relacionales como MySQL o PostgreSQL en varios aspectos clave:

• Estructura flexible:
  No requiere un esquema fijo como las tablas en SQL.
  Cada documento puede tener campos distintos y anidados.
• Alta escalabilidad horizontal:
  Permite distribuir datos en múltiples servidores (sharding) para manejar grandes volúmenes.
• Consultas potentes:
  Uso de operadores avanzados para búsquedas complejas sin necesidad de JOIN.
• Velocidad en datos no estructurados:
  Ideal para datos que cambian con frecuencia o no tienen una estructura definida.

2. ¿Para qué se usa?

MongoDB es ideal para proyectos que requieren agilidad y flexibilidad en el modelado de datos, como:

• Aplicaciones web y móviles con datos dinámicos.
• Sistemas que manejan grandes volúmenes de datos (Big Data).
• Proyectos con esquemas que cambian con frecuencia.
• APIs REST o GraphQL donde se trabaja con documentos JSON.
• Aplicaciones que necesitan escalar rápidamente con alto tráfico.

Ejemplo: redes sociales, plataformas de e-commerce, aplicaciones de streaming o sistemas de IoT.

3. ¿Qué puedo construir con MongoDB?

Con MongoDB puedes crear desde aplicaciones simples hasta sistemas empresariales complejos.
Algunos ejemplos incluyen:

• E-commerce:
  Gestión de productos, carritos de compra y pedidos.
• Sistemas de mensajería:
  Chats en tiempo real con datos no estructurados.
• Plataformas de análisis:
  Procesamiento de datos de sensores o transacciones.
• APIs modernas:
  Backends escalables para apps móviles y web.
• Sistemas de recomendación:
  Basados en datos de usuarios y patrones de uso.

4. ¿Cuándo es más conveniente usarlo?

MongoDB sobresale en escenarios donde:

• El esquema de datos cambia constantemente o es flexible.
• Se manejan datos no estructurados o semiestructurados, como JSON.
• Se espera crecimiento rápido y escalabilidad.
• El rendimiento en lectura y escritura es más importante que la integridad referencial compleja.
• El proyecto necesita desarrollos ágiles y prototipado rápido.

Si necesitas relaciones complejas y fuertes restricciones de integridad, una base SQL podría ser mejor.

Buenas prácticas recomendadas

Para trabajar eficientemente con MongoDB, sigue estas recomendaciones:

Estructura y diseño

• Modela los datos según cómo serán consultados, no solo cómo se almacenan.
• Usa subdocumentos y arrays para datos relacionados en lugar de múltiples colecciones cuando sea posible.
• Evita documentos demasiado grandes (límite recomendado: 16MB por documento).

Rendimiento

• Crea índices adecuados para optimizar consultas frecuentes.
• Utiliza paginación con limit y skip para manejar grandes conjuntos de resultados.
• Monitorea el tamaño de la base y planifica el sharding cuando sea necesario.

Código limpio

• Centraliza la lógica de conexión y configuración.
• Utiliza variables de entorno para credenciales y configuración.
• Implementa validaciones de datos antes de guardarlos.
• Mantén nombres claros y consistentes para colecciones y campos.

Seguridad

• Configura usuarios con roles y permisos adecuados.
• Habilita autenticación y cifrado de datos.
• Nunca expongas la base de datos directamente a internet sin protección.

Resumen rápido

Síntesis rápida de lo aprendido sobre MongoDB.

✅ Fortalezas principales:

• Flexibilidad en el esquema de datos.
• Escalabilidad horizontal eficiente.
• Alto rendimiento con datos no estructurados.
• Integración natural con aplicaciones modernas (JSON).

⚠️ Debilidades principales:

• No es ideal para relaciones complejas.
• Puede consumir más espacio en disco que SQL.
• Requiere diseño cuidadoso para evitar consultas ineficientes.

🛠️ Cuándo usarlo:

• Proyectos que necesitan crecer rápido.
• Datos que cambian con frecuencia.
• Aplicaciones web/móviles con estructuras dinámicas.

🚫 Cuándo evitarlo:

• Sistemas financieros o con alta integridad transaccional.
• Proyectos con relaciones complejas y normalización estricta.
• Cuando la estructura de datos es muy estable y no requiere flexibilidad.

Temas

• inicio
• Conceptos relacionados
• Herramientas recomendadas
• Snippets rápidos
• Comandos
• Conceptos Claves
• Otros artículos

Conceptos relacionados

Antes de trabajar con MongoDB, es importante entender los siguientes conceptos:

1. Documentos

• Unidad básica de datos en MongoDB.
• Se almacenan en formato BSON (Binary JSON).
• Similar a un objeto en JavaScript.

{
  "nombre": "Fernando",
  "edad": 28,
  "email": "fernando@example.com"
}

2. Colecciones

• Conjunto de documentos relacionados, equivalente a una tabla en SQL.
• Ejemplo: una colección llamada usuarios que contiene varios documentos con información de usuarios.

3. Base de datos

• Contenedor de colecciones.
• Cada aplicación puede tener una o varias bases de datos según la necesidad.

4. BSON

• Formato binario basado en JSON.
• Permite almacenar tipos de datos más complejos, como:
  • ObjectId
  • Date
  • Binary
  • Decimal128

5. ObjectId

• Identificador único para cada documento.
• Se genera automáticamente al insertar un documento.

{
  "_id": "651c5f4b8d0f5e9d12345678",
  "nombre": "Producto 1",
  "precio": 1500
}

6. CRUD

Operaciones esenciales que se realizan en una base de datos:

7. Índices

• Mejoran la velocidad de búsqueda y consultas.
• Sin índices, MongoDB recorre toda la colección (full scan).

Ejemplo: indexar el campo email en una colección de usuarios.

db.usuarios.createIndex({ email: 1 });

8. Agregaciones (Aggregation Pipeline)

• Herramienta poderosa para procesar y transformar datos.
• Funciona en etapas (stages) como un flujo de trabajo.

Ejemplo básico: contar usuarios por país.

db.usuarios.aggregate([
  { $group: { _id: "$pais", totalUsuarios: { $sum: 1 } } },
]);

9. Replica Set

• Grupo de servidores MongoDB que mantienen copias sincronizadas de los datos.
• Brinda alta disponibilidad y resiliencia.

10. Sharding

• Técnica de escalamiento horizontal.
• Distribuye datos en múltiples servidores para manejar grandes volúmenes.

🔼 temas

Herramientas recomendadas

Para trabajar con MongoDB de forma eficiente, estas son las herramientas más importantes:

1. MongoDB Compass

• Interfaz gráfica oficial de MongoDB.
• Permite visualizar datos, crear índices y ejecutar consultas sin usar la terminal.
• Ideal para desarrolladores que prefieren trabajar visualmente.

Descarga: https://www.mongodb.com/products/compass

2. MongoDB Atlas

Plataforma en la nube para gestionar bases de datos MongoDB.

Características clave:

• Escalabilidad automática.
• Backups automáticos.
• Alta disponibilidad global.
• Seguridad integrada.

Uso recomendado: hosting de bases de datos para producción y pruebas.
Registro gratuito: https://www.mongodb.com/cloud/atlas

3. Extensión MongoDB for VS Code

• Permite conectarse a bases de datos directamente desde Visual Studio Code.
• Ejecuta consultas y explora colecciones sin salir del editor.

Instalar desde el Marketplace de VS Code:
MongoDB for VS Code

4. Mongoose (ODM para Node.js)

Librería para interactuar con MongoDB en proyectos de Node.js.

Beneficios:

• Definir esquemas y modelos para los datos.
• Validación automática.
• Simplificación en consultas y operaciones complejas.

npm install mongoose

5. Robo 3T (alternativa a Compass)

• Cliente liviano para administrar bases de datos MongoDB.
• Ideal para usuarios que buscan una herramienta rápida y minimalista.

Descarga: https://robomongo.org/

6. Node.js + Express

MongoDB se integra perfectamente con Node.js y Express para construir APIs y aplicaciones backend modernas.

Paquete oficial de MongoDB para Node.js:

npm install mongodb

7. Docker

• Permite levantar un contenedor de MongoDB en segundos para desarrollo o pruebas.

docker run -d -p 27017:27017 --name my-mongo mongo

8. Mongosh

• Shell interactivo para trabajar con MongoDB desde la terminal.
• Reemplazo moderno del clásico mongo shell.

Instalación: https://www.mongodb.com/try/download/shell

📌 Resumen rápido de herramientas

🔼 temas

Snippets rápidos

Fragmentos de código para tareas comunes en Node.js con MongoDB.

1. Conexión básica con Mongoose

import mongoose from "mongoose";

mongoose
  .connect("mongodb://localhost:27017/mi_base")
  .then(() => console.log("Conectado a MongoDB"))
  .catch((err) => console.error("Error de conexión", err));

2. Definir un modelo

const usuarioSchema = new mongoose.Schema({
  nombre: String,
  email: { type: String, required: true },
  edad: Number,
});

const Usuario = mongoose.model("Usuario", usuarioSchema);

3. Crear un documento

const nuevoUsuario = new Usuario({
  nombre: "Ana",
  email: "ana@example.com",
  edad: 25,
});
await nuevoUsuario.save();

4. Consultar documentos

const usuarios = await Usuario.find(); // Todos los usuarios
const ana = await Usuario.findOne({ nombre: "Ana" }); // Un usuario específico

5. Actualizar un documento

await Usuario.updateOne({ nombre: "Ana" }, { edad: 26 });

6. Eliminar un documento

await Usuario.deleteOne({ nombre: "Ana" });

7. Conexión nativa sin Mongoose

import { MongoClient } from "mongodb";

const cliente = new MongoClient("mongodb://localhost:27017");
await cliente.connect();

const db = cliente.db("mi_base");
const coleccion = db.collection("usuarios");

await coleccion.insertOne({ nombre: "Carlos", edad: 30 });

🔼 temas

Comandos

Comandos básicos para trabajar desde mongosh o la terminal.

1. Conectarse a MongoDB

mongosh

Si está en otro host/puerto:

mongosh "mongodb://localhost:27017"

2. Mostrar bases de datos

show dbs

3. Crear o usar una base de datos

use mi_base

4. Mostrar colecciones

show collections

5. Insertar documentos

db.usuarios.insertOne({ nombre: "Ana", edad: 25 });
db.usuarios.insertMany([
  { nombre: "Luis", edad: 30 },
  { nombre: "Carla", edad: 22 },
]);

6. Consultar documentos

db.usuarios.find(); // Todos
db.usuarios.find({ edad: { $gt: 25 } }); // Condición
db.usuarios.findOne({ nombre: "Ana" }); // Solo uno

7. Actualizar documentos

db.usuarios.updateOne({ nombre: "Ana" }, { $set: { edad: 26 } });

db.usuarios.updateMany({ edad: { $lt: 18 } }, { $set: { estado: "menor" } });

8. Eliminar documentos

db.usuarios.deleteOne({ nombre: "Ana" });
db.usuarios.deleteMany({ edad: { $lt: 18 } });

9. Crear índice

db.usuarios.createIndex({ email: 1 });

10. Contar documentos

db.usuarios.countDocuments();

11. Agregaciones básicas

Contar usuarios por país:

db.usuarios.aggregate([{ $group: { _id: "$pais", total: { $sum: 1 } } }]);

12. Exportar e importar datos

Exportar colección:

mongoexport --db mi_base --collection usuarios --out usuarios.json

Importar colección:

mongoimport --db mi_base --collection usuarios --file usuarios.json

📌 Resumen rápido de comandos

🔼 temas

Conceptos Claves

🟢 Básico

1. Estructura principal: Documentos y Colecciones

• Documento:
  Es la unidad básica de almacenamiento en MongoDB. Está representado en formato BSON (similar a JSON).
• Colección:
  Conjunto de documentos relacionados, similar a una tabla en bases de datos relacionales.

Ejemplo de documento:

{
  "nombre": "Ana",
  "edad": 25,
  "email": "ana@example.com"
}

Colección: usuarios puede contener miles de documentos similares.

2. BSON vs JSON

• BSON (Binary JSON):
  Es el formato binario que usa MongoDB internamente.
  • Soporta tipos de datos adicionales como ObjectId, Date, Decimal128, Binary.
  • Más eficiente en almacenamiento y velocidad.
• JSON:
  Solo texto plano, más limitado en tipos de datos.

MongoDB usa BSON porque optimiza la lectura y escritura de datos, y soporta tipos que JSON no maneja.

3. Operaciones CRUD básicas

4. ObjectID

Es el identificador único que MongoDB asigna automáticamente a cada documento en el campo _id.

Tiene 12 bytes, distribuidos así:

• 4 bytes
  Marca de tiempo (timestamp).
• 5 bytes
  Identificador de máquina y proceso.
• 3 bytes
  Contador incremental.

Esto asegura unicidad global sin necesidad de un servidor central.

Ejemplo:
64f83d2a8d9b4e7cbb123456

5. Crear un índice

db.usuarios.createIndex({ email: 1 });

• 1 = Orden ascendente.
• -1 = Orden descendente.

Importancia:
Los índices aceleran la búsqueda de documentos, evitando que MongoDB recorra toda la colección (full collection scan).

🟡 Intermedio

6. Tipos de índices y casos de uso

7. Documentos embebidos vs Referencias

Embebidos (Embedded):**

• Toda la información está en el mismo documento.
• Más rápido para lecturas frecuentes.
• Ideal para datos que siempre se consultan juntos.

Ejemplo:

{
  "nombre": "Ana",
  "direccion": {
    "calle": "Av. Siempre Viva",
    "ciudad": "Springfield"
  }
}

Referencias (Referencing):**

• Documentos separados que se relacionan mediante un ObjectId.
• Útil cuando los datos cambian con frecuencia o se comparten entre colecciones.

Ejemplo:

{
  "nombre": "Ana",
  "direccionId": ObjectId("64f83d2a8d9b4e7cbb123456")
}

8. Diferencia entre $set, $inc y $push

9. Schemas en MongoDB

MongoDB es schema-less (sin esquema rígido), pero se pueden definir esquemas opcionales usando librerías como Mongoose.

Beneficios:

• Validación de datos.
• Estandarización.
• Prevención de errores.

Buenas prácticas:

• Mantener consistencia en los campos.
• Definir reglas claras para documentos.
• Usar validaciones al insertar datos.

10. Replica set

Grupo de servidores que mantienen copias sincronizadas de los datos.

Funciones clave:

• Alta disponibilidad.
• Recuperación automática ante fallos (failover).

Funcionamiento:

1. Un Primary recibe todas las escrituras.
2. Los Secondaries replican los datos.
3. Si el Primary falla, uno de los Secondaries es elegido automáticamente como nuevo Primary.

🔴 Avanzado

11. Join entre colecciones con $lookup

db.pedidos.aggregate([
  {
    $lookup: {
      from: "clientes",
      localField: "clienteId",
      foreignField: "_id",
      as: "infoCliente",
    },
  },
]);

Similar a un LEFT JOIN en SQL.

12. Estrategias de escalabilidad horizontal

Sharding:

• Divide la base de datos en fragmentos distribuidos en varios servidores.
• Mejora el rendimiento con grandes volúmenes de datos.

Replica Sets:

• Multiplica copias de los datos para mejorar disponibilidad y tolerancia a fallos.

13. Transacciones en MongoDB

• Permiten ejecutar múltiples operaciones como una sola unidad atómica.
• Útiles en operaciones financieras o multi-documento.

Ejemplo básico:

const session = client.startSession();
session.startTransaction();

try {
  await db
    .collection("cuentas")
    .updateOne({ _id: 1 }, { $inc: { saldo: -100 } }, { session });

  await db
    .collection("cuentas")
    .updateOne({ _id: 2 }, { $inc: { saldo: 100 } }, { session });

  await session.commitTransaction();
} catch (e) {
  await session.abortTransaction();
}

14. Consulta optimizada para los 10 documentos más recientes

Estrategia:

1. Crear un índice en el campo fecha:

   db.posts.createIndex({ fecha: -1 });
   

2. Consulta optimizada:

   db.posts.find().sort({ fecha: -1 }).limit(10);
   

Esto evita un full collection scan y utiliza el índice directamente.

15. Modelado de datos para red social

Colección usuarios:

{
  "_id": ObjectId("..."),
  "nombre": "Ana",
  "amigos": [ObjectId("..."), ObjectId("...")]
}

Colección posts:

{
  "_id": ObjectId("..."),
  "usuarioId": ObjectId("..."),
  "contenido": "Mi primer post",
  "likes": [ObjectId("..."), ObjectId("...")]
}

Estrategia:

• Amigos:
  Array embebido, porque suele consultarse junto al perfil.
• Likes:
  Guardar solo los IDs para evitar duplicidad y mantener la consulta rápida.

🔼 temas