📁 Crear una base de datos (Create DB)

En esta lección veremos paso a paso cómo crear una base de datos en MongoDB para una tienda online (colección de usuarios), qué herramientas usar y buenas prácticas: desde instalación y comandos básicos hasta uso con GUI y desde Node.js/Mongoose.

🔧 Herramientas recomendadas

MongoDB Community Server — si trabajas localmente (gratis, sin límites funcionales).
MongoDB Atlas — si quieres la base en la nube (plan Free disponible para pruebas).
Mongo Shell / mongosh — consola interactiva para ejecutar comandos directamente.
MongoDB Compass — interfaz gráfica oficial para explorar y administrar datos.
Node.js + MongoDB Driver o Mongoose — para integrar la BD con tu aplicación (ej.: tienda online en Node/Express).

1️⃣ Paso 0 — decidir dónde alojar la base

Local (Community Server): perfecto para desarrollo local y pruebas. Instalas MongoDB en tu máquina y controlas todo.
Atlas (Cloud): ideal si quieres desplegar en la nube y evitar administrar servidores — recomendado para staging/producción pequeña.

2️⃣ Paso 1 — instalación e inicio (resumen)

(Si ya tienes MongoDB instalado o usas Atlas, salta a la sección siguiente)

Windows: ejecuta el instalador Community y habilita el servicio o ejecuta `mongod.exe` manualmente.
macOS: brew tap mongodb/brew y brew install mongodb-community.
Linux: sigue la guía oficial para tu distro (apt/yum) e inicia mongod.

Luego inicia el servidor (por defecto puerto 27017) y abre el cliente con mongosh o mongo.

3️⃣ Paso 2 — crear la base de datos y la colección (línea de comandos)

Ejemplo para una base llamada tiendaDB y colección usuarios:

# Abrir shell de MongoDB
mongosh

# Cambiar/crear base de datos llamada "tiendaDB"
use tiendaDB

# Insertar un documento creará la colección "usuarios" automáticamente
db.usuarios.insertOne({
  nombre: "Ana Pérez",
  email: "ana@example.com",
  passwordHash: "HASH_AQUI",
  direccion: {
    calle: "C/ Mayor 1",
    ciudad: "Madrid",
    cp: "28001",
    pais: "España"
  },
  carrito: [],
  roles: ["cliente"],
  createdAt: new Date(),
  isActive: true
})

# Ver los documentos
db.usuarios.find().pretty()

Note: El comando use tiendaDB cambia el contexto a la DB; si no existía, MongoDB la crea cuando insertes datos.

4️⃣ Paso 3 — definir un esquema mínimo (conceptual)

Aunque MongoDB es esquema-flexible, conviene definir la estructura esperada para la colección usuarios:

{
  _id: ObjectId,
  nombre: String,
  email: String,           // único
  passwordHash: String,
  direccion: {
    calle: String,
    ciudad: String,
    cp: String,
    pais: String
  },
  telefono: String,
  carrito: [ { productoId, cantidad } ],
  roles: [ "cliente", "admin" ],
  createdAt: Date,
  lastLogin: Date,
  isActive: Boolean
}

5️⃣ Paso 4 — crear índices útiles

Índices importantes para usuarios:

# Índice único en email (impide duplicados)
db.usuarios.createIndex({ email: 1 }, { unique: true })

# Índice en createdAt para consultas por fecha
db.usuarios.createIndex({ createdAt: -1 })

# Índice compuesto ejemplo (ciudad + isActive)
db.usuarios.createIndex({ "direccion.ciudad": 1, isActive: 1 })

Los índices aceleran lecturas a costa de espacio y coste de escritura — crea solo los necesarios.

6️⃣ Paso 5 — añadir validación de esquema (opcional pero recomendado)

Puedes usar validadores JSON Schema al crear la colección para garantizar estructura mínima:

db.createCollection("usuarios", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["nombre", "email", "passwordHash", "createdAt"],
      properties: {
        nombre: { bsonType: "string" },
        email: { bsonType: "string", pattern: "^.+@.+\\..+$" },
        passwordHash: { bsonType: "string" },
        createdAt: { bsonType: "date" },
        isActive: { bsonType: "bool" }
      }
    }
  },
  validationLevel: "moderate"
})

validationLevel puede ser strict o moderate. Con esto evitas insertar documentos claramente inválidos.

7️⃣ Paso 6 — herramientas GUI: MongoDB Compass

Con Compass puedes:

Conectar a tu servidor Atlas o local con la cadena de conexión.
Crear bases de datos y colecciones desde un interfaz visual.
Definir validadores JSON Schema visualmente.
Ver índices, estadísticas y ejecutar consultas en modo visual.

Ejemplo rápido: abrir Compass → Conectar → Click en Create Database → nombre tiendaDB, colección usuarios.

8️⃣ Paso 7 — conectar desde Node.js (ejemplo mínimo)

Usando el driver oficial:

// npm install mongodb
const { MongoClient } = require("mongodb");

async function main() {
  const uri = "mongodb://localhost:27017"; // o tu cadena Atlas
  const client = new MongoClient(uri);

  try {
    await client.connect();
    const db = client.db("tiendaDB");
    const usuarios = db.collection("usuarios");

    // insertar
    const result = await usuarios.insertOne({
      nombre: "Luis",
      email: "luis@example.com",
      passwordHash: "HASH",
      createdAt: new Date(),
      isActive: true
    });
    console.log("Insertado ID:", result.insertedId);

    // buscar
    const user = await usuarios.findOne({ email: "luis@example.com" });
    console.log(user);
  } finally {
    await client.close();
  }
}

main().catch(console.error);

9️⃣ Paso 8 — usar Mongoose (si trabajas con Node/Express y quieres esquema)

Mongoose te da esquemas y validación en el código:

// npm install mongoose
const mongoose = require('mongoose');

async function main() {
  await mongoose.connect('mongodb://localhost:27017/tiendaDB');

  const usuarioSchema = new mongoose.Schema({
    nombre: { type: String, required: true },
    email: { type: String, required: true, unique: true },
    passwordHash: { type: String, required: true },
    direccion: {
      calle: String, ciudad: String, cp: String, pais: String
    },
    carrito: [{ productoId: mongoose.Schema.Types.ObjectId, cantidad: Number }],
    roles: [String],
    createdAt: { type: Date, default: Date.now },
    isActive: { type: Boolean, default: true }
  });

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

  const u = await Usuario.create({ nombre: 'Eva', email: 'eva@example.com', passwordHash: 'HASH' });
  console.log('Usuario creado:', u._id);
}

main().catch(console.error);

🔎 Ejemplo de consulta útil

Obtener usuarios activos en Madrid, ordenados por fecha de creación:

db.usuarios.find({ "direccion.ciudad": "Madrid", isActive: true })
          .sort({ createdAt: -1 })
          .limit(50)

🔐 Consideraciones de seguridad y producción

Nunca guardes contraseñas en texto plano; guarda solo hashes con salt (bcrypt, argon2).
Habilita autenticación en MongoDB en producción y crea usuarios con roles mínimos.
Usa TLS/SSL para conexiones remotas (Atlas lo fuerza por defecto).
Configura backups regulares (Atlas lo ofrece, en local usa mongodump / mongorestore o soluciones de snapshot de tu proveedor).

🔁 Escalado y limits (breve)

Para grandes volúmenes de datos en producción usarás replica sets (alta disponibilidad) y sharding (particionado horizontal).
Planifica índices y tamaño de documentos: documentos muy grandes (MBs) pueden penalizar rendimiento; piensa en referencias si corresponde.

✅ Resumen práctico (checklist)

Decide local vs Atlas.
Instala e inicia MongoDB o crea cluster en Atlas.
Crea la DB: use tiendaDB.
Define estructura mínima y reglas de validación.
Crea índices esenciales (email único, createdAt...).
Inserta datos de prueba y verifica con Compass o mongosh.
Integra con tu app usando driver o Mongoose.
Configura seguridad (auth, TLS) y backups antes de producción.

← Volver al índice

📁 Crear una base de datos (Create DB)