Instalación, Atlas y Compass

Tienes dos caminos para empezar con MongoDB: instalarlo en tu computadora (o en Docker) o usar MongoDB Atlas, su servicio en la nube con un cluster gratuito para siempre. En esta lección harás ambos, aprenderás a usar mongosh (la terminal de MongoDB) y Compass (la interfaz gráfica), y conectarás VS Code.

Concepto: las piezas

Pieza	Qué es
mongod	El servidor de MongoDB. Escucha en el puerto 27017
mongosh	La terminal interactiva (un intérprete de JavaScript conectado a la base)
Compass	Interfaz gráfica oficial: explorar datos, consultas, agregaciones, índices
Atlas	MongoDB en la nube (administrado por MongoDB Inc.)
Database Tools	mongodump, mongorestore, mongoimport, mongoexport
Driver	Librería para tu lenguaje (mongodb para Node, Mongoose encima de él)

Ediciones: Community (gratuita, la que usarás) y Enterprise (de pago, con funciones corporativas).

Opción 1: MongoDB Atlas (recomendada para empezar)

Atlas te da un cluster real en la nube, con respaldos y seguridad, sin instalar nada. El plan M0 (Free) es gratuito para siempre (con límites de espacio, unos 512 MB).

Paso a paso

1. Entra a mongodb.com/cloud/atlas y crea una cuenta.
2. Create a cluster → elige M0 Free.
3. Proveedor (AWS, Google Cloud o Azure) y región cercana a ti o a tu servidor.
4. Dale un nombre (tienda-cluster) y créalo.

Seguridad: usuario y lista de IPs

Atlas te pedirá dos cosas antes de conectarte:

a) Usuario de base de datos (Database Access):

Usuario:    tienda_app
Contraseña: (usa "Autogenerate Secure Password" y guárdala)
Rol:        Read and write to any database   ← o restringe a una base concreta

Este usuario es distinto de tu cuenta de Atlas: es el que usará tu aplicación.

b) Lista de acceso de IPs (Network Access):

Add IP Address
  ○ Add Current IP Address     ← tu IP actual (recomendado para desarrollo)
  ○ Allow Access from Anywhere (0.0.0.0/0)   ← solo si tu servidor no tiene IP fija

0.0.0.0/0

Permitir acceso desde cualquier IP es común en tutoriales y en plataformas serverless sin IP fija, pero entonces tu única protección es la contraseña. Usa contraseñas largas y aleatorias, un usuario con permisos solo sobre su base, y si tu proveedor de hosting ofrece IPs fijas o private endpoints, úsalos.

La cadena de conexión

En tu cluster → Connect → Drivers (o Shell). Atlas te muestra una URI como:

mongodb+srv://tienda_app:<password>@tienda-cluster.ab1cd.mongodb.net/?retryWrites=true&w=majority&appName=tienda-cluster
└─ esquema ─┘└── usuario:clave ──┘└──────── host del cluster ────────┘└──────────── opciones ────────────┘

• mongodb+srv:// resuelve automáticamente todos los nodos del cluster (Atlas siempre usa un replica set de 3 nodos).
• Reemplaza <password> por la contraseña real (codificada si tiene caracteres especiales: @ → %40).
• Agrega el nombre de la base después del host: ...mongodb.net/tienda?retryWrites=true...

# .env
MONGODB_URI="mongodb+srv://tienda_app:CLAVE@tienda-cluster.ab1cd.mongodb.net/tienda?retryWrites=true&w=majority"

Datos de ejemplo

Atlas puede cargar datasets de prueba: en tu cluster → ⋯ → Load Sample Dataset. Incluye bases como sample_mflix (películas) y sample_restaurants, ideales para practicar consultas.

Opción 2: instalación local

Windows

1. Descarga MongoDB Community Server (MSI) desde mongodb.com/try/download/community.
2. Instalación Complete. Marca Install MongoD as a Service (se iniciará con Windows).
3. Opcionalmente instala Compass desde el mismo instalador.
4. Descarga mongosh aparte (mongodb.com/try/download/shell) si no viene incluido, y agrégalo al PATH.

Get-Service MongoDB          # verificar el servicio
mongosh                      # conecta a mongodb://localhost:27017

Ubuntu

# Importar la llave y el repositorio oficial (ajusta la versión, por ejemplo 8.0, y tu Ubuntu)
sudo apt-get install -y gnupg curl
curl -fsSL https://www.mongodb.org/static/pgp/server-8.0.asc | \
  sudo gpg -o /usr/share/keyrings/mongodb-server-8.0.gpg --dearmor
echo "deb [ arch=amd64,arm64 signed-by=/usr/share/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

sudo apt-get update
sudo apt-get install -y mongodb-org

sudo systemctl start mongod
sudo systemctl enable mongod
sudo systemctl status mongod
mongosh

(Consulta la guía oficial para el comando exacto según tu versión de Ubuntu: jammy para 22.04, noble para 24.04.)

Archivos importantes: configuración en /etc/mongod.conf, datos en /var/lib/mongodb, log en /var/log/mongodb/mongod.log.

Activa la autenticación

Una instalación local de MongoDB no pide usuario ni contraseña por defecto. Si la expones a internet, cualquiera puede leer y borrar tus datos (hubo oleadas de ataques de "rescate" contra miles de servidores así). En un servidor:

1. Crea un administrador:

use admin
db.createUser({ user: "admin", pwd: passwordPrompt(), roles: ["root"] })

2. Activa la seguridad en /etc/mongod.conf:

security:
  authorization: enabled
net:
  bindIp: 127.0.0.1    # solo local

3. Reinicia: sudo systemctl restart mongod.

macOS

brew tap mongodb/brew
brew install mongodb-community
brew services start mongodb-community
mongosh

Docker

docker run -d \
  --name mongo-tienda \
  -p 127.0.0.1:27017:27017 \
  -e MONGO_INITDB_ROOT_USERNAME=admin \
  -e MONGO_INITDB_ROOT_PASSWORD=secreto \
  -v mongo_datos:/data/db \
  mongo:8

docker exec -it mongo-tienda mongosh -u admin -p secreto

Con docker-compose.yml (incluye Mongo Express, un panel web):

services:
  mongo:
    image: mongo:8
    restart: unless-stopped
    environment:
      MONGO_INITDB_ROOT_USERNAME: admin
      MONGO_INITDB_ROOT_PASSWORD: ${MONGO_PASSWORD}
      MONGO_INITDB_DATABASE: tienda
    ports:
      - "127.0.0.1:27017:27017"
    volumes:
      - mongo_datos:/data/db
      - ./mongo-init:/docker-entrypoint-initdb.d   # scripts .js que se ejecutan la primera vez

  mongo-express:
    image: mongo-express:1
    restart: unless-stopped
    environment:
      ME_CONFIG_MONGODB_URL: mongodb://admin:${MONGO_PASSWORD}@mongo:27017/
      ME_CONFIG_BASICAUTH: "true"
    ports:
      - "127.0.0.1:8081:8081"
    depends_on:
      - mongo

volumes:
  mongo_datos:

URI local con autenticación:

MONGODB_URI="mongodb://admin:secreto@localhost:27017/tienda?authSource=admin"

(authSource=admin indica en qué base está definido el usuario.)

mongosh: la terminal

mongosh                                         # local, sin autenticación
mongosh "mongodb://localhost:27017/tienda"
mongosh "mongodb+srv://tienda-cluster.ab1cd.mongodb.net/tienda" --username tienda_app

Comandos esenciales:

show dbs                       // bases de datos (las vacías no aparecen)
use tienda                     // cambiar de base (se crea al insertar)
db                             // ¿en qué base estoy?
show collections               // colecciones de la base actual
db.productos.find()            // documentos (de 20 en 20; escribe "it" para más)
db.productos.countDocuments()  // cuántos hay
db.productos.findOne()         // uno, bonito
db.stats()                     // estadísticas de la base
db.productos.drop()            // borrar la colección
db.dropDatabase()              // borrar la base actual (¡cuidado!)
cls                            // limpiar pantalla
exit                           // salir

mongosh es un intérprete de JavaScript completo: puedes usar variables, ciclos y funciones.

// Insertar 100 documentos de prueba con un ciclo
for (let i = 1; i <= 100; i++) {
  db.pruebas.insertOne({ numero: i, par: i % 2 === 0, creado: new Date() })
}

const total = db.pruebas.countDocuments({ par: true })
print(`Hay ${total} números pares`)

// Ejecutar un archivo de script
load("semilla.js")

# Ejecutar un script desde la terminal
mongosh "mongodb://localhost:27017/tienda" semilla.js
mongosh --quiet --eval "db.productos.countDocuments()" "mongodb://localhost:27017/tienda"

Compass: la interfaz gráfica

Descárgalo desde mongodb.com/products/compass (gratis).

1. New connection → pega la URI (local o de Atlas) → Connect.
2. Navega: base de datos → colección.

Pestañas de una colección:

Pestaña	Para qué
Documents	Ver, filtrar, insertar, editar y borrar documentos. Barra de filtro con sintaxis de consulta
Aggregations	Constructor visual de pipelines, etapa por etapa con vista previa (Agregaciones)
Schema	Analiza una muestra y muestra qué campos existen, sus tipos y distribución. ¡Ideal para detectar datos inconsistentes!
Indexes	Ver, crear y eliminar índices
Explain Plan	Plan de ejecución visual de una consulta
Validation	Editar las reglas $jsonSchema

En la barra de filtro de Documents escribes la parte del filtro que irías en find():

// Filter
{ precio: { $lt: 500 }, categoria: "Hogar" }
// Project
{ nombre: 1, precio: 1, _id: 0 }
// Sort
{ precio: -1 }

Compass también incluye una mini terminal mongosh integrada (abajo) e importar/exportar JSON y CSV.

Otras herramientas

• Extensión de VS Code "MongoDB for VS Code": conectar, explorar y ejecutar playgrounds (.mongodb.js) con tus consultas directamente en el editor.
• Database Tools: mongoimport/mongoexport (JSON/CSV), mongodump/mongorestore (respaldos binarios).

# Respaldo y restauración
mongodump --uri="$MONGODB_URI" --out=respaldo_$(date +%F)
mongorestore --uri="$MONGODB_URI" respaldo_2024-07-01/

# Importar un JSON (un documento por línea o un array con --jsonArray)
mongoimport --uri="$MONGODB_URI" --collection=productos --file=productos.json --jsonArray

# Exportar a CSV
mongoexport --uri="$MONGODB_URI" --collection=productos --type=csv \
  --fields=nombre,precio,stock --out=productos.csv

Atlas además hace respaldos automáticos en los planes de pago, y permite exportar en los gratuitos con estas herramientas.

Ejercicios

1. Crea un cluster M0 en Atlas (o instala MongoDB local/Docker) y conéctate con mongosh.
2. Crea la base tienda, inserta un documento en la colección pruebas y verifica con show dbs que la base aparece.
3. Conecta Compass al mismo servidor y usa la pestaña Schema sobre pruebas.
4. ¿Por qué show dbs no muestra la base tienda justo después de ejecutar use tienda?
5. Tu app en Render no conecta a Atlas con el error MongoServerSelectionError: ... timed out. ¿Qué revisarías primero?

Ver solución

// 2
use tienda
db.pruebas.insertOne({ mensaje: "Hola MongoDB", fecha: new Date() })
show dbs   // ahora aparece "tienda"

4. Porque MongoDB crea las bases y colecciones de forma perezosa: use tienda solo cambia el contexto; la base existe físicamente cuando insertas el primer documento.

5. La lista de IPs de Atlas (Network Access): si la IP del servidor no está permitida, la conexión se queda esperando hasta el timeout. Después: que la URI tenga la contraseña correcta (codificada), el nombre de usuario de base de datos (no el de tu cuenta de Atlas) y que el cluster no esté pausado.

Resumen

• Atlas M0 es la forma más rápida de empezar: cluster gratuito en la nube con usuario de BD y lista de IPs.
• La URI mongodb+srv://usuario:clave@host/base va en una variable de entorno.
• Local: instalador (Windows), repositorio oficial (Ubuntu), Homebrew (macOS) o Docker con volumen.
• Activa la autenticación en cualquier servidor; nunca expongas el puerto 27017 sin protección.
• mongosh es una terminal JavaScript; Compass permite explorar, analizar el esquema, crear índices y agregaciones visualmente.