MongoDB

MongoDB Curso, Introducción Practica a NoSQL
mongodb ejemplos de codigo
Databases

Introducción

MongoDB es:
- escalable, con soporte nativo para clusters y replicación.
- orientado a documentos en formato JSON/BSON.
- escrito en C++ y optimizado para rendimiento.
- schema-less (permite documentos con estructura flexible).
- diseñado para escalado horizontal mediante sharding.
- de propósito general: adecuado para APIs, microservicios, IoT, analítica básica, logging, e-commerce.
Ventajas clave:
- consultas ricas con operadores avanzados.
- integración natural con ecosistemas JavaScript.
- JSON como formato principal → curva de aprendizaje más rápida.
- drivers oficiales para múltiples lenguajes.

Instalación

Instalar MongoDB Community Server.
Instalar MongoDB Compass (cliente visual).
Ejecutar la instalación sin configurarlo como servicio (opcional según necesidades).
Añadir al PATH la carpeta /bin.
Verificar instalación:
- mongod --version
- mongod.exe --version

Configuración Inicial

Añadir variable de entorno apuntando a la carpeta bin.
Crear carpeta para almacenamiento:
- C:\data\db
Iniciar el servidor:
- mongod
Mantener la ventana abierta con mongod para que el servidor siga activo.
Abrir otra consola para el cliente:
- mongo
Mongo shell funciona como un intérprete de JavaScript.
Comprobar acceso:
- ejecutar funciones JS (Math.sin, Date, funciones propias).

Conceptos Básicos

Base de datos: agrupación lógica de colecciones.
Colección: conjunto de documentos relacionados, similar a tablas.
Documento: objeto JSON/BSON con estructura flexible.

Mongo Shell (JS Interpreter)

Comandos básicos:
- ver db actual: db
- listar dbs: show dbs
- ayuda: db.help()
Crear y usar bases de datos:
- use webstore
Crear colecciones:
- db.products.insert({"name": "laptop"})
- show collections
Eliminar una base de datos:
- db.dropDatabase()
Funcionalidades JS:
- Math.sin(Math.PI / 2)
- new Date()
- creación de funciones personalizadas

Funcionamiento de Colecciones

Crear colecciones explícitas:
- db.createCollection("users")
- db.createCollection("products")
Borrar colecciones:
- db.products.drop()
Insertar documentos:
- db.products.insert(<json>)
Búsqueda:
- db.products.find()
- db.products.find().pretty()
BSON:
- JSON se transforma a BSON (binario eficiente).
Expresiones regulares:
- "x": /foobar/i

Operaciones Típicas (CRUD Avanzado)

Insertar datos:
- db.products.insert({"name": "keyboard"})
- db.products.insert({"name": "laptop", "price": 999.99})
Buscar documentos:
- db.products.find({name: "mouse"})
- db.products.find({price: 999.99})
- db.products.find({"tags":"computers"})
- db.products.findOne({"tags": "computers"})
Proyecciones:
- db.products.findOne({"tags": "computers"}, {"name": 1, "description": 1, "_id": 0})
Ordenación:
- db.products.find().sort({name: 1})
Límites:
- db.products.find().limit(2)
Contar documentos:
- db.products.count()

Uso de Funciones en Consultas

Recorrer resultados:
- db.products.find().forEach(product => print("Product Price: " + product.price))
Actualizaciones:
- Reemplazo completo:
  - db.products.update({"name": "keyboard"}, {"price": 99.99})
- Uso de $set:
  - db.products.update({"name": "laptop"}, {$set: {"description": "lg gram laptop"}})
- Upsert:
  - db.products.update({"name": "desktop"}, {$set: {"description": "Gaming Desktop"}}, {upsert: true})
- Incrementos:
  - db.products.update({"name": "keyboard"}, {$inc: {"price": 0.01}})
- Renombrar atributos:
  - db.products.update({"name": "laptop"}, {$rename: {"name": "nombre"}})
Eliminaciones:
- db.products.remove({"nombre": "keyboard"})
- db.products.remove({}) (todos los documentos)

MongoDB Compass

Cliente visual para interactuar con MongoDB.
Conexión por defecto: puerto 27017.
Permite ver colecciones, insertar documentos y ejecutar consultas visualmente.
El servidor debe estar ejecutándose con mongod.

MongoDB — Conceptos Avanzados y Arquitectura

BSON y Tipos de Datos

MongoDB almacena documentos en BSON, una representación binaria de JSON.
Ventajas:
- más velocidad en la lectura/escritura.
- tipos adicionales no presentes en JSON.
Tipos relevantes:
- ObjectId
- Date
- Timestamp
- Binary
- Decimal128
- arrays, documentos anidados, regex.

Diseño de Documentos

Dos enfoques:
- Embedding: incluir documentos dentro de otro documento → consultas rápidas.
- Referencing: enlazar documentos mediante IDs → útil para conjuntos grandes y relaciones flexibles.
Consideraciones:
- documentos demasiado grandes degradan el rendimiento.
- mejor desnormalizar cuando se prioriza la lectura.

Índices

Principales tipos:
- Índices simples: un solo campo.
- Índices compuestos: varios campos, con orden específico.
- Índices únicos: no permite duplicados.
- Índices TTL: eliminan documentos automáticamente tras un tiempo.
- Índices de texto: búsquedas semánticas.
- Índices geoespaciales: admite coordenadas y mapas.
- Índices parciales: solo indexan documentos que cumplen una condición.
- Índices sparse: ignoran campos inexistentes.

Consultas Avanzadas

Comparaciones:
- $gt, $lt, $gte, $lte, $eq, $ne.
Arrays:
- $elemMatch, $size, $all.
Operadores lógicos:
- $and, $or, $nor, $not.
Expresiones regulares avanzadas usadas en búsquedas flexibles.

Aggregation Framework

Sistema similar a pipelines tipo SQL:
- $match: filtrar.
- $project: seleccionar campos.
- $group: agrupaciones y sumatorias.
- $sort: ordenar.
- $unwind: expandir arrays.
- $lookup: realizar joins con otras colecciones.
- $facet: múltiples pipelines en paralelo.
Usado para:
- reportes,
- dashboards,
- resúmenes,
- análisis avanzado.

Ejemplo de Aggregation

db.sales.aggregate([
	{ $match: { status: "paid" }},
	{ $group: { _id: "$seller", total: { $sum: "$amount" }}},
	{ $sort: { total: -1 }}
])

Transacciones y ACID

Desde MongoDB 4.0:
- Permite transacciones multi-documento en replica sets.
- Lecturas/escrituras atomizadas.
Útil para:
- operaciones financieras,
- integridad fuerte en varias colecciones.

Replicación (Replica Sets)

Un replica set contiene:
- un primary
- uno o varios secondary
- opcionalmente un arbiter (solo participa en votaciones).
Beneficios:
- tolerancia a fallos,
- lecturas distribuídas.
Configuraciones avanzadas:
- ajustar prioridades para decidir qué nodo es elegible como primary,
- crear nodos retrasados (delayed) para recuperación histórica,
- elegir read concern y write concern según consistencia.

Sharding

Estrategia para escalar horizontalmente.
Componentes:
- mongos: router de consultas.
- config servers: almacenan metadatos.
- shards: conjuntos de datos distribuidos.
Métodos de particionamiento:
- rangos: adecuado si los valores tienen una distribución uniforme.
- hash: balanceo automático más uniforme.
Shard key adecuada:
- evita hotspots,
- distribuye cargas de forma estable.

Seguridad

MongoDB implementa:
- autenticación por usuario/contraseña,
- roles con permisos específicos,
- encriptación TLS en tránsito,
- encriptación en reposo mediante claves KMS o integraciones con Atlas,
- auditoría para entornos de producción.

Herramientas del Ecosistema

MongoDB Atlas: servicio en la nube con backups, métricas, escalado automático y funciones serverless.
mongodump/mongorestore: backups binarios.
mongoexport/mongoimport: importación/exportación JSON/CSV.
mongosh: shell moderno reemplazando a mongo.
Drivers oficiales: Node.js, Python, Go, Java, C#, Rust…
Mongoose (Node.js):
- ODM para modelar schemas,
- middlewares,
- validaciones.

Patrones de Modelado NoSQL

Bucket Pattern: ideal para logs o streams.
Subset Pattern: guardar solo parte de un conjunto grande.
Computed Pattern: almacenar datos calculados para acelerar lecturas.
Tree Patterns: representación de jerarquías.
Outlier Pattern: separar elementos que rompen el tamaño típico del documento.

MongoDB — Arquitectura, Patrones y Casos de Uso Exhaustivos

Arquitectura — Componentes y Fundamentos

Componentes principales:
- mongod — proceso servidor que almacena datos y atiende consultas.
- mongos — router de consulta en clusters sharded; actúa como puerta de enlace.
- Config Servers — almacenan metadatos del cluster sharded (topología, chunks).
- Clients / Drivers — conexiones desde apps (drivers oficiales y ORMs/ODMs).
Flujo de operaciones:
- Cliente → mongos (si hay sharding) → shard(s) / replica set primary → escritura en oplog → replicación a secondaries.
Otras piezas:
- OpsLog (oplog) — registro de operaciones para replicación.
- Journaling — durabilidad a nivel de servidor (WiredTiger journaling).
- Storage Engine (WiredTiger por defecto, In-Memory opcional).

Storage Engines y Persistencia

WiredTiger:
- MVCC (versiones múltiples) → mayor concurrencia.
- Compresión configurable (snappy, zlib, zstd).
- Buen rendimiento en escritura/escritura concurrente.
In-Memory Engine:
- Datos residen en RAM, uso en casos de latencia ultra baja.
- No persistente por defecto (útil para caches o pruebas).
Consideraciones:
- Tamaño máximo de documento (16MB).
- Limitaciones del tamaño de la base de datos por recursos del nodo.

Replicación (Replica Sets) — Alta Disponibilidad

Conceptos:
- Réplica compuesta por un primary (lee/escribe) y múltiples secondaries (replican).
- Arbiter participa en votaciones pero no guarda datos.
- Read/Write Concerns:
  - w (write concern): numero de réplicas que deben confirmar.
  - wtimeout y majority para garantías fuertes.
  - readPreference: primary, primaryPreferred, secondary, nearest.
Consideraciones de diseño:
- Nodos en distintas zonas/centros para resiliencia.
- Nodos delayed para proteger contra eliminación accidental (p.ej. delay: 86400s).
- Prioridades para control de elecciones.

Oplog y Consistencia

Oplog:
- Cola capped que registra operaciones en el primary.
- Secondaries reproducen el oplog para alcanzar consistencia eventual.
Consistencia:
- Lecturas desde primary → más consistencia.
- Lecturas desde secondary → latencia reducida pero posible retraso (staleness).

Sharding — Escalado Horizontal

Elementos:
- Shards: cada shard puede ser un replica set.
- mongos: router que transparently reparte queries.
- config servers: normalmente 3 nodos (replica set) que guardan metadata.
Selección de Shard Key:
- Debe distribuir uniformemente la carga.
- Evitar keys monotonas (timestamp, _id incrementales) que generan hotspots.
- Considerar cardinalidad, frecuencia de consulta, y uso en filtros.
Estrategias:
- Rango (range sharding): bueno para queries por rango pero riesgo de hotspots.
- Hash (hashed sharding): balanceo más uniforme, peor para rangos.
Rebalanceo:
- Micro-movimientos de chunks entre shards.
- Impacto en I/O y red; planificar mantenimiento.

Seguridad, Networking y Operaciones

Autenticación:
- SCRAM, x.509, LDAP integrable.
Autorización:
- Roles basados en privilegios (built-in roles + roles personalizados).
Encriptación:
- TLS/SSL en tránsito.
- Encriptación en reposo: en disco (proveedores KMS para llaves).
Auditoría y cumplimiento:
- Logging de eventos, retención y conservación para auditoría.
Networking:
- Abrir puertos mínimos (27017, 27019, 27018 según roles).
- Whitelists / VPC para limitar accesos.
Backups:
- Snapshots del filesystem (si storage engine lo permite).
- mongodump/mongorestore para migraciones y backups lógicos.
- Backups consistentes en cluster sharded o Atlas snapshots.

Monitorización y Observabilidad

Métricas importantes:
- Latencia de operaciones, QPS, uso CPU/RAM, I/O disco, lock percentage.
Herramientas:
- MongoDB Cloud Manager / Ops Manager / Atlas Monitoring.
- Integraciones con Prometheus, Grafana.
- Logs y slow query profiler (db.system.profile).

Código: Iniciar Replica Set (ejemplo)

Iniciar Replica Set (shell)

// en cada nodo mongod (con --replSet rs0) y luego en shell:
rs.initiate({
	_id: "rs0",
	members: [
		{ _id: 0, host: "mongo1:27017" },
		{ _id: 1, host: "mongo2:27017" },
		{ _id: 2, host: "mongo3:27017" }
	]
})

Código: Habilitar Sharding en DB y Colección (ejemplo)

Habilitar Shard y Shard Key (mongos)

sh.enableSharding("commerce")
sh.shardCollection("commerce.orders", { "customerId": "hashed" })

Patrones de Modelado — Descripción y Ejemplos

Principios generales:
- Priorizar patrones según los requerimientos de lectura/escritura y consistencia.
- Evaluar trade-offs: duplicación (desnormalización) vs consistencia y costos de actualización.

Embedding vs Referencing

Embedding: almacenar subdocumentos dentro del documento padre.
- Pros:
  - Lecturas atómicas y rápidas (1 consulta).
  - Simplicidad conceptual.
- Contras:
  - Documentos pueden crecer demasiado (> 16MB).
  - Actualizaciones parciales más costosas si se repite en muchos documentos.
Referencing: guardar referencias (ObjectId) a otros documentos.
- Pros:
  - Evita documentos enormes.
  - Mejor para relaciones N:N y colecciones grandes.
- Contras:
  - Requiere múltiples queries o $lookup.
    Pattern: Bucket (time-series / logs)
Agrupa eventos por intervalos (por ejemplo, por día o por hora) dentro de un documento para reducir número de documentos.
Uso: métricas, telemetría, logs.
Consideración: tamaño del bucket (no superar límites de documento).

Pattern: Subset / Partial Aggregation

Guardar solo los campos más consultados o una vista parcial para acelerar queries frecuentes.
Ideal cuando el documento original es grande pero las consultas requieren solo un subconjunto.

Pattern: Outlier

Separar documentos que no encajan en el esquema “típico” (outliers) a otra colección para mantener tamaños y rendimiento.

Pattern: Computed/Pre-Aggregation

Guardar valores calculados (totales, contadores) para evitar cálculos pesados en cada lectura.
Requiere estrategia de actualización (triggers de aplicación o transacciones).

Pattern: Tree / Jerarquías

Adjacency List:
- Cada nodo contiene parentId. Fácil de mantener, consultas recursivas costosas.
Materialized Path:
- Guardar ruta completa en un campo ("path": "root/child/grandchild"). Fácil filtrado por prefijo.
Nested Sets:
- Representación con lft/rgt, ideal para lecturas de subárboles, costoso en escrituras.
- Elegir según patrón de lecturas vs escrituras.

Pattern: Versioning / Audit Trail

Mantener versiones históricas de documentos (copias o snapshots).
Uso en compliance y auditoría.

Pattern: Time-Series (específico)

Usar colecciones con bucket pattern o Timeseries Collections (feature nativa en versiones recientes).
Ventajas: compresión especializada y consultas optimizadas por tiempo.

Pattern: Leaderboard / Counters

Uso de documentos con contadores ($inc) y sharding por ranges/hashed para escalar.
Considerar limitaciones de concurrencia en hotspots.

Ejemplos de Código: Aggregation para Patrones Comunes

Aggregation — Top Sellers por Mes

db.orders.aggregate([
	{ $match: { status: "paid", date: { $gte: ISODate("2025-01-01") } } },
	{ $group: { _id: { seller: "$sellerId", month: { $month: "$date" } }, total: { $sum: "$amount" } } },
	{ $sort: { total: -1 } },
	{ $limit: 10 }
])

Casos de Uso y Recomendaciones de Patrones

E-commerce (catálogo, orders, carritos):
- Catálogo: usar embedding para atributos pequeños; referencing para relaciones complejas (reviews, suppliers).
- Orders: documentos por order (embedding items) + computed totals; replica sets para HA.
- Sharding por customerId o orderDate (evitar hotspot si es secuencial).
Sistemas de logging y métricas (telemetría, IoT):
- Bucket pattern o Time-Series Collections; compresión y TTL para retención.
Redes sociales / Feed:
- Denormalizar actividad (write-heavy): Precompute feeds o fan-out on write.
- Graph-like queries limitados; considerar DB especializada (graph DB) para queries profundas.
Geolocalización / Geospatial:
- Índices 2dsphere, consultas por proximidad; shards por regiones si necesario.
Gaming (estadísticas, leaderboards):
- Contadores con $inc, TTL para datos efímeros, shard por region/gameId.
Catalog/Content Management:
- Flexibilidad de esquema para múltiples tipos de contenido; indexing de texto y facets.
Financial / Transaccional (banking):
- Usar transacciones multi-documento y replica sets con majority write concern.
Analítica y BI:
- Pipeline de aggregation, $lookup para combinar datasets, export a data warehouse cuando se requiera consultas complejas.

Operaciones y Prácticas Recomendadas (Best Practices)

Diseñar shard key antes de la fase de crecimiento serio.
Monitorizar índices y eliminar índices sin uso.
Usar w: "majority" para operaciones críticas.
Mantener replica sets en 3+ nodos (o 5 para tolerancia mayor).
Automatizar backups y pruebas de restore.
Probar failover y recuperación periódicamente.
Mantener métricas y alertas para latencia, conexiones y uso de locks.

Recursos y Referencias

Considerar migración a MongoDB Atlas para manejo operativo (backups automáticos, autoscaling).
Herramientas de utilidad:
- mongodump, mongorestore, mongoexport, mongoimport, mongotop, mongostat.

Fundamentos y Conceptos Clave de MongoDB

Introducción

MongoDB es un Sistema de Gestión de Bases de Datos NoSQL orientado a documentos, diseñado para manejar datos semiestructurados, distribuidos y altamente escalables.
A diferencia de los modelos relacionales, en MongoDB los datos se almacenan como documentos BSON, permitiendo flexibilidad estructural, escalabilidad horizontal nativa y consultas ricas incluso sin esquema rígido.

Esta nota recoge los fundamentos teóricos esenciales que forman la base conceptual de MongoDB.

1. Modelo de Datos en MongoDB

1.1 Documento

Unidad fundamental de almacenamiento:

Formato BSON (Binary JSON).
Permite tipos extendidos: fechas, binarios, ObjectId, enteros de 64 bits, decimal128.
Soporte nativo para:
- Subdocumentos.
- Arrays.
- Tipos heterogéneos.

1.2 Colección

Conjunto de documentos relacionados:

No requieren esquema fijo.
Pueden contener documentos parcialmente distintos.
Equivalente conceptual a una “tabla”, pero sin tipado estricto.

1.3 Base de Datos

Agrupa colecciones lógicamente, con espacio de nombres propio.

2. Esquema Flexible

2.1 Flexibilidad del Esquema

No existe un esquema rígido.
Permite evolucionar los datos sin migraciones masivas.
Implica diseñar con intención, aunque sea flexible.

2.2 Embedding

Se recomienda embeber cuando:

Relación 1:1 o 1:N con tamaño acotado.
Se requiere lectura rápida en una sola operación.
La consistencia depende del mismo documento.

2.3 Referencing

Recomendado para:

Relaciones N:M.
Volumen grande de datos o crecimiento indefinido.
Necesidad de reutilizar entidades en múltiples documentos.

2.4 Anti-Patrones

Documentos que superan límites lógicos (>16 MB).
Arrays infinitos.
Crecimiento continuo del documento principal.
Demasiadas referencias entre colecciones.

3. Relaciones en MongoDB

3.1 1:1

Embedding casi siempre recomendable.

3.2 1:N

Embedding si el tamaño es moderado.
Referencing si crece de forma ilimitada o si los hijos cambian mucho.

3.3 N:M

Soluciones comunes:

Documentos puente.
Referencias duales.
$lookup en agregaciones.

4. Índices

4.1 B-Trees

Índice general para la mayoría de consultas.

4.2 Multikey

Indexa arrays.
Cada valor del array se indexa independientemente.

4.3 Text Index

Búsqueda por relevancia.
Stemming.
Idioma configurable.

4.4 Geo Index

2dsphere y 2d:

Cercanía (near).
Polígonos, intersecciones.
GeoJSON nativo.

4.5 TTL Index

Elimina documentos automáticamente tras un tiempo.

4.6 Índices para Sharding

Necesarios para claves de shard distribuidas.

5. Fundamentos del Motor Interno

5.1 WiredTiger

Compresión.
MVCC.
Checkpoints.
Concurrencia optimizada a nivel documento.

5.2 BSON

Binario.
Rápida serialización/deserialización.
Tipos extendidos optimizados.

5.3 Límite de Documento

16 MB por documento:

Evita fragmentación extrema.
Favorece patrones de diseño correctos.

6. CRUD y Operadores

6.1 CRUD

insertOne, insertMany
find, findOne
updateOne, updateMany
deleteOne, deleteMany

6.2 Operadores Básicos

$set, $unset
$inc, $mul
$push, $pull, $addToSet
$exists, $regex

6.3 Operadores Avanzados

$currentDate
$rename
$min, $max

6.4 Proyecciones

Inclusión/exclusión de campos.
Control del tamaño del documento resultante.

7. Agregaciones (Aggregation Pipeline)

7.1 Concepto

Pipeline tipo data-flow similar a ETL, compuesto de etapas secuenciales.

7.2 Etapas Frecuentes

$match
$project
$sort
$group
$unwind
$lookup
$facet
$limit, $skip

7.3 Características

Altamente optimizado.
Permite modelado analítico avanzado.
Reemplaza complejas consultas SQL.

8. Consistencia y Transacciones

8.1 Modelo de Consistencia

Fuerte a nivel de documento.
Eventual en sistemas distribuidos.

8.2 Write Concern

Control sobre la confirmación:

acknowledged
journaled
majority
linearizable

8.3 Read Concern

local
majority
linearizable
snapshot

8.4 Transacciones Multi-Documento

Útiles para integridad compleja.
Más lentas que operaciones atómicas nativas.

9. Concurrencia Interna

9.1 MVCC

Lecturas no bloquean escrituras.
Escrituras no bloquean lecturas.
Ideal para cargas mixtas.

9.2 Locking

Granularidad fina.
Locks por documento.
Locks de intención a nivel colección/DB.

10. Replicación

10.1 Replica Sets

Conjunto de nodos:

Primario recibe escrituras.
Secundarios replican.
Procesos de election automatizados.

10.2 Preferencias de Lectura

primary
primaryPreferred
secondary
secondaryPreferred
nearest

11. Sharding (Escalado Horizontal)

11.1 Clave de Shard

Requisitos:

Alta cardinalidad.
Buena distribución.
No monotónica (evitar hot spots).

11.2 Componentes

Shards.
Config servers.
Routers mongos.

11.3 Balancer

Reorganiza “chunks”.
Evita sobrecarga en nodos concretos.

11.4 Métodos de Sharding

Por rango.
Por hash.
Por zonas etiquetadas (tag aware).

12. Seguridad

12.1 Autenticación

SCRAM-SHA.
LDAP.
X.509.

12.2 Autorización

Roles integrados.
Roles definidos por el usuario.

12.3 Encriptación

En tránsito.
En reposo.
A nivel de campo (Client-Side FLE).

13. Observabilidad

13.1 Herramientas

mongostat
mongotop
Profiler
Logs estructurados

13.2 Métricas Clave

Latencia.
Lock ratio.
Cache hit ratio.
Fragmentación.
Uso del disco.

14. Patrones de Diseño

14.1 Bucket Pattern

Agrupar documentos pequeños por lotes/tiempo.

14.2 Attribute Pattern

Aplanar estructuras complicadas para mejor indexación.

14.3 Outlier Pattern

Separar valores anómalos en otra colección.

14.4 Extended Reference Pattern

Combinación de embedding parcial + referencia.

14.5 Polymorphic Pattern

Documentos con múltiples formas o estructuras bajo una misma colección.

15. Limitaciones

15.1 Transacciones Limitadas

Multi-documento es más costoso.

15.2 No Hay Foreign Keys Internas

La integridad referencial debe gestionarse en la aplicación o mediante agregaciones.

15.3 Riesgo de Fragmentación

Documentos de crecimiento constante pueden fragmentarse.

15.4 Elección Incorrecta de Shard Key

Causa particiones calientes y pérdida de escalabilidad.

Conclusión

MongoDB se basa en un modelo flexible, distribuido y optimizado para escalabilidad horizontal. Sus fundamentos teóricos permiten diseñar modelos eficientes, entender su comportamiento interno y aprovechar al máximo su capacidad para manejar datos modernos y aplicaciones distribuidas.

MongoDB

Introducción

Instalación

Configuración Inicial

Conceptos Básicos

Mongo Shell (JS Interpreter)

Funcionamiento de Colecciones

Operaciones Típicas (CRUD Avanzado)

Uso de Funciones en Consultas

MongoDB Compass

MongoDB — Conceptos Avanzados y Arquitectura

BSON y Tipos de Datos

Diseño de Documentos

Índices

Consultas Avanzadas

Aggregation Framework

Ejemplo de Aggregation

Transacciones y ACID

Replicación (Replica Sets)

Sharding

Seguridad

Herramientas del Ecosistema

Patrones de Modelado NoSQL

MongoDB — Arquitectura, Patrones y Casos de Uso Exhaustivos

Arquitectura — Componentes y Fundamentos

Storage Engines y Persistencia

Replicación (Replica Sets) — Alta Disponibilidad

Oplog y Consistencia

Sharding — Escalado Horizontal

Seguridad, Networking y Operaciones

Monitorización y Observabilidad

Código: Iniciar Replica Set (ejemplo)

Iniciar Replica Set (shell)

Código: Habilitar Sharding en DB y Colección (ejemplo)

Habilitar Shard y Shard Key (mongos)

Patrones de Modelado — Descripción y Ejemplos

Embedding vs Referencing

Pattern: Bucket (time-series / logs)

Pattern: Subset / Partial Aggregation

Pattern: Outlier

Pattern: Computed/Pre-Aggregation

Pattern: Tree / Jerarquías

Pattern: Versioning / Audit Trail

Pattern: Time-Series (específico)

Pattern: Leaderboard / Counters

Ejemplos de Código: Aggregation para Patrones Comunes

Aggregation — Top Sellers por Mes

Casos de Uso y Recomendaciones de Patrones

Operaciones y Prácticas Recomendadas (Best Practices)

Recursos y Referencias

Fundamentos y Conceptos Clave de MongoDB

Introducción

1. Modelo de Datos en MongoDB

1.1 Documento

1.2 Colección

1.3 Base de Datos

2. Esquema Flexible

2.1 Flexibilidad del Esquema

2.2 Embedding

2.3 Referencing

2.4 Anti-Patrones

3. Relaciones en MongoDB

3.1 1:1

3.2 1:N

3.3 N:M

4. Índices

4.1 B-Trees

4.2 Multikey

4.3 Text Index

4.4 Geo Index

4.5 TTL Index

4.6 Índices para Sharding

5. Fundamentos del Motor Interno

5.1 WiredTiger

5.2 BSON

5.3 Límite de Documento

6. CRUD y Operadores

6.1 CRUD

6.2 Operadores Básicos

6.3 Operadores Avanzados