Categoría: MongoBD

1. Introducción a MongoDB
1. ¿Qué es MongoDB?

MongoDB es una base de datos NoSQL orientada a documentos.
Características principales:
- Guarda la información en documentos JSON (llamados BSON internamente).
- No usa tablas ni filas como en SQL.
- Es flexible: cada documento puede tener campos distintos.
- Escalable y ampliamente usado en desarrollo web.
Ejemplo de documento en MongoDB:
```
{
  "nombre": "Pedro",
  "edad": 23,
  "ciudad": "Madrid"
}
```
2. Instalación en Ubuntu/Debian

2.1. Actualizar el sistema
```
sudo apt update && sudo apt upgrade -y
```
2.2. Instalar MongoDB desde repositorios oficiales (recomendado)
1. Importar la clave GPG:
```
curl -fsSL https://pgp.mongodb.com/server-7.0.asc | \
sudo gpg -o /usr/share/keyrings/mongodb-server-7.0.gpg --dearmor
```
1. Añadir el repositorio:
```
echo "deb [arch=amd64,arm64 signed-by=/usr/share/keyrings/mongodb-server-7.0.gpg] \
https://repo.mongodb.org/apt/ubuntu jammy/mongodb-org/7.0 multiverse" | \
sudo tee /etc/apt/sources.list.d/mongodb-org-7.0.list
```
1. Instalar MongoDB:
```
sudo apt update
sudo apt install -y mongodb-org
```
3. Iniciar, detener y habilitar el servicio

MongoDB se gestiona con systemctl:
- Iniciar:
```
sudo systemctl start mongod
```
- Detener:
```
sudo systemctl stop mongod
```
- Reiniciar:
```
sudo systemctl restart mongod
```
- Ver estado:
```
sudo systemctl status mongod
```
- Habilitar al arranque:
```
sudo systemctl enable mongod
```
Comprobar que funciona:
```
mongosh
```
Si aparece el prompt test>, está funcionando correctamente.

4. Acceso a la Consola de MongoDB (mongosh)

La herramienta principal para trabajar con MongoDB por consola es:
```
mongosh
```
Al entrar, verás un prompt similar a:
```
test>
```
test es la base de datos por defecto.

5. Comandos básicos

5.1. Mostrar bases de datos
```
show dbs
```
5.2. Cambiar o crear una base de datos
```
use tienda
```
Si no existe, MongoDB la creará al guardar datos.

5.3. Ver colecciones

Una colección es equivalente a una tabla en SQL.
```
show collections
```
5.4. Insertar documentos

Ejemplo:
```
db.clientes.insertOne({ nombre: "Ana", edad: 25, ciudad: "Sevilla" })
```
o varios a la vez:
```
db.clientes.insertMany([
  { nombre: "Luis", edad: 30 },
  { nombre: "María", edad: 27 }
])
```
5.5. Consultas (búsquedas)

Mostrar todos:
```
db.clientes.find()
```
Filtrar:
```
db.clientes.find({ edad: { $gt: 25 } })
```
5.6. Actualizar documentos

Modificar un campo:
```
db.clientes.updateOne(
  { nombre: "Ana" },
  { $set: { ciudad: "Granada" } }
)
```
5.7. Borrar documentos

Borrar uno:
```
db.clientes.deleteOne({ nombre: "Luis" })
```
Borrar varios:
```
db.clientes.deleteMany({ edad: { $lt: 28 } })
```
5.8. Borrar una colección entera
```
db.clientes.drop()
```
5.9. Borrar una base de datos

Primero entrar en ella:
```
use tienda
```
Luego eliminarla:
```
db.dropDatabase()
```
6. Estructura conceptual

En MongoDB la jerarquía es:
```
Servidor → Bases de datos → Colecciones → Documentos → Campos
```
Ejemplo:
- Base de datos: tienda
- Colección: productos
- Documento:
```
{
  "nombre": "Galletas",
  "precio": 1.20,
  "stock": 50
}
```
7. Exportación e Importación (extra)

Exportar una colección:
```
mongoexport --db tienda --collection clientes --out clientes.json
```
Importar:
```
mongoimport --db tienda --collection clientes --file clientes.json
```
8. Detener el servicio y desinstalar (opcional)

Detener:
```
sudo systemctl stop mongod
```
Desinstalar:
```
sudo apt purge mongodb-org -y
sudo rm -r /var/log/mongodb
sudo rm -r /var/lib/mongodb
```
Práctica Guiada: “MongoDB en la USS Horizon”

La USS Horizon ha sido enviada a explorar un cúmulo estelar cercano a Andoria. La tripulación científica necesita un sistema de gestión para almacenar informes, muestras biológicas, registros de comunicaciones y perfiles de planetas. Como Oficial de Ingeniería Informática, tu misión es instalar un sistema MongoDB en el núcleo de datos del servidor de la nave, aprender a administrarlo por consola y cargar registros básicos.

FASE 1 — Instalación del Servidor MongoDB

Instalar MongoDB en el servidor Linux de la USS Horizon.

Procedimiento
1. Accede al servidor (terminal local o SSH).
2. Actualiza los paquetes del sistema:
```
sudo apt update && sudo apt upgrade -y
```
1. Añade la llave GPG del “repositorio de la Federación”:
```
curl -fsSL https://pgp.mongodb.com/server-7.0.asc | \
sudo gpg -o /usr/share/keyrings/mongodb-server-7.0.gpg --dearmor
```
1. Activa el repositorio estable:
```
echo "deb [arch=amd64,arm64 signed-by=/usr/share/keyrings/mongodb-server-7.0.gpg] \
https://repo.mongodb.org/apt/ubuntu jammy/mongodb-org/7.0 multiverse" | \
sudo tee /etc/apt/sources.list.d/mongodb-org-7.0.list
```
1. Instala MongoDB:
```
sudo apt update
sudo apt install -y mongodb-org
```
Validación

Si no ha habido errores, MongoDB está instalado en el servidor auxiliar del núcleo de datos.

FASE 2 — Arranque del Núcleo de Datos MongoDB

Objetivo

Levantar el servicio mongod y verificar su estado.

Procedimiento
1. Inicia el servicio:
```
sudo systemctl start mongod
```
1. Comprueba su estado operativo:
```
sudo systemctl status mongod
```
1. Actívalo para que arranque con el sistema de la nave:
```
sudo systemctl enable mongod
```
Validación

Si el servicio está activo, el núcleo de datos está disponible.

FASE 3 — Acceso al Observador de Datos (mongosh)

Objetivo

Acceder a la consola interactiva de MongoDB.

Procedimiento

Entrada al núcleo:
```
mongosh
```
Resultado esperado:
```
test>
```
Ese prompt indica que estás dentro del sistema base.

FASE 4 — Organización del Archivo Estelar

En la Flota Estelar, los registros se organizan por sectores. En MongoDB será así:
```
Servidor → Bases de datos → Colecciones → Documentos → Campos
```
FASE 5 — Creación de Base de Datos y Colecciones

Objetivo

Crear una base de datos para almacenar datos del Sector Andoria.

Procedimiento
1. Cambia a la base de datos andoria_sector:
```
use andoria_sector
```
Ahora crearás una colección llamada planetas.
1. Inserta un documento básico:
```
db.planetas.insertOne({
  nombre: "Andoria",
  especie_principal: "Andoriano",
  clima: "Frío",
  alineacion: "Federación",
  tecnologia: "Warp"
})
```
1. Comprueba el contenido:
```
db.planetas.find()
```
FASE 6 — Manejo de Registros Científicos

Objetivo

Insertar, buscar, actualizar y eliminar registros.

A) Inserciones múltiples

Añade varios planetas explorados:
```
db.planetas.insertMany([
  { nombre: "Vulcano", especie_principal: "Vulcano", alineacion: "Federación", tecnologia: "Warp" },
  { nombre: "Qo'noS", especie_principal: "Klingon", alineacion: "Imperio Klingon", tecnologia: "Warp" },
  { nombre: "Romulus", especie_principal: "Romulano", alineacion: "Imperio Estelar", tecnologia: "Warp" }
])
```
B) Consultas

Lista los planetas:
```
db.planetas.find()
```
Filtra por alineación:
```
db.planetas.find({ alineacion: "Federación" })
```
C) Actualizaciones

El Consejo Andoriano ha cambiado la clasificación de Andoria:
```
db.planetas.updateOne(
  { nombre: "Andoria" },
  { $set: { clima: "Ártico" } }
)
```
D) Eliminaciones

Tras un incidente diplomático, se decide borrar temporalmente un registro:
```
db.planetas.deleteOne({ nombre: "Romulus" })
```
Comprueba que desapareció:
```
db.planetas.find()
```
FASE 7 — Gestión de Colecciones y Base de Datos

Ver colecciones existentes
```
show collections
```
Eliminar una colección entera

Ejemplo:
```
db.planetas.drop()
```
Eliminar una base de datos

Primero asegúrate de estar en ella:
```
use andoria_sector
```
Luego:
```
db.dropDatabase()
```
FASE 8 — Exportación e Importación (Bitácora Estelar)

Para generar bitácoras externas:

Exportar colección:
```
mongoexport --db andoria_sector --collection planetas --out planetas.json
```
Importar colección:
```
mongoimport --db andoria_sector --collection planetas --file planetas.json
```
FASE 9 — Cierre del Núcleo

Puedes detener el servicio si la nave entra en modo de sigilo:
```
sudo systemctl stop mongod
```
enero 15, 2026
2. MongoDB Compass
Compass es un entorno gráfico oficial para MongoDB. Permite:
- Conectarse a una base de datos local o remota
- Ver bases de datos y colecciones
- Visualizar documentos
- Crear, editar y borrar documentos
- Crear índices
- Lanzar agregaciones con interfaz visual
- Ver estadísticas de la colección (distribuciones, tamaños, etc.)
En esencia, Compass cumple el mismo papel que “phpMyAdmin” en MySQL, pero para MongoDB.

Instalación de MongoDB Compass (Linux/Windows/macOS)

Para clase normalmente recomiendo:
- Que los alumnos lo instalen en su portátil si lo tienen
- Si no, instalarlo en el servidor Linux con GUI (si existe) o usar su PC personal
Descarga oficial

https://www.mongodb.com/try/download/compass

Ir a:

Seleccionar:
- Versión estable
- Sistema operativo correspondiente
Instalar siguiendo el asistente.

Configuración inicial en clase

Antes de abrir Compass, asegúrate de que el servidor MongoDB ya está corriendo en Linux:
```
sudo systemctl status mongod
```
Y que el puerto por defecto (27017) está accesible en la red del aula.

Si usan Compass desde sus ordenadores:
- Conexión dentro de la misma LAN del aula → bien
- Si hay cortafuegos, abrir el puerto 27017
- Si es SSH, configurar túnel (lo explico más abajo opcionalmente)
Conexión desde Compass (práctica guiada sencilla)

Abrir Compass → aparecerá pantalla con Connection String.

Por defecto la cadena es:
```
mongodb://localhost:27017
```
Casos:

Caso A: Compass instalado en el servidor

Usar:
```
mongodb://localhost:27017
```
Clic Connect.

Caso B: Compass desde portátil del alumno

Si conocen la IP del servidor:
```
mongodb://IP_DEL_SERVIDOR:27017
```
Ejemplo:
```
mongodb://192.168.0.50:27017
```
Para realizar conexiones remotas debemos cambiar la configuración del archivo mongod.conf

sudo nano /etc/mongod.conf

y cambiar el 127.0.0.1 por 0.0.0.

Clic Connect.

Si la conexión funciona, aparecen las bases de datos.

Exploración visual de datos (lo que deben observar)

Una vez dentro:
1. Sección izquierda: lista de bases de datos
2. Seleccionar andoria_sector (o la que crearon antes)
3. Seleccionar colección planetas
Ahora verán documentos tipo:
```
{
  "_id": ObjectId("..."),
  "nombre": "Andoria",
  "especie_principal": "Andoriano",
  ...
}
```
Aquí ya puedes hacer mini demostración:
- Ordenar por campo
- Editar un documento (botón Edit Document)
- Añadir nuevos campos manualmente
- Borrar un documento desde la interfaz
Esto consolida el concepto “un documento no necesita la misma estructura en todos los registros”.

Agregaciones visuales (el jugo interesante)

Compass tiene una sección llamada Aggregations:
- Clic en Aggregations
- Crear un pipeline con $match
- Ejemplo:
```
{ "$match": { "alineacion": "Federación" } }
```
Esto muestra solo planetas federados.

Si quieres mostrarles algo más vistoso:
- $group por alineacion
- $sort descendente por conteo
El pipeline sería:
```
[
  { "$group": { "_id": "$alineacion", "total": { "$sum": 1 } } },
  { "$sort": { "total": -1 } }
]
```
Esto es excelente para enseñar que MongoDB es más “analítico” que un simple CRUD.

Índices

Compass → pestaña Indexes

Allí puedes:
- Ver índices existentes
- Crear uno nuevo desde GUI
Por ejemplo, crear índice en nombre:
- Clic Create Index
- Campo: nombre
- Orden: Ascending
- Crear
Esto deja caer la idea de rendimiento sin entrar en ingeniería pesada.

Estadísticas de colección

Compass tiene una pestaña Schema que permite:
- Inferir estructura de documentos
- Detectar tipos
- Ver distribuciones
Ejemplo: podrían ver que clima es “Frío”, “Ártico”, etc.
Visualmente ayuda a entender diversidad de documentos.

Práctica Guiada: “Exploración Visual de Datos con MongoDB Compass”

La USS Horizon ha completado su instalación del núcleo MongoDB en la sala de máquinas. Ahora la Sección de Ciencia quiere que los oficiales accedan a los registros desde una interfaz visual que permita agrupar, filtrar y entender datos sin necesidad de abrir un terminal. Te han asignado la operación.

FASE 1 — Preparar la Conexión desde Compass

Tu estación de trabajo local será el cliente de monitorización. Antes de iniciar la misión:
1. Asegúrate de que MongoDB está activo en el servidor de la nave:
```
sudo systemctl status mongod
```
1. Si estás en el mismo equipo donde instalaste MongoDB, podrás conectarte con localhost.
2. Si estás desde otro equipo del aula, necesitas la IP del servidor de la nave (por ejemplo 192.168.0.50).
Abre MongoDB Compass y en el campo de conexión escribe:

Para conexión local:
```
mongodb://localhost:27017
```
Para conexión remota en la red de aula:
```
mongodb://IP_DEL_SERVIDOR:27017
```
Pulsa Connect. Si todo va bien, deberías ver una lista de bases de datos en la barra lateral izquierda. Bienvenido al puente de mando.

FASE 2 — Exploración de la Biblioteca de Datos

Al conectarte, Compass mostrará un conjunto de bases predeterminadas del sistema.

Tu tarea inicial consiste en crear una estructura nueva que represente planetas registrados por la Federación.
1. Dirígete al botón de Create database
2. Nombre de la base de datos: fed_records
3. Nombre de la colección inicial: planets
4. Clic en Create
Acabas de crear un archivo científico dentro de la Biblioteca Estelar.

FASE 3 — Inserción de Datos Científicos

Ahora toca poblar la colección con datos reales que los sensores ya capturaron.
Compass permite insertar datos con un editor visual.

Abre la colección planets y pulsa Insert Document.

Aparece un editor con un documento JSON. Rellénalo con:
```
{
  "name": "Vulcan",
  "species": "Vulcans",
  "affiliation": "Federation",
  "warp_capable": true
}
```
Pulsa Insert para guardar.

Agrega un segundo documento pero esta vez usando Insert Document y cambia el contenido:
```
{
  "name": "Qo'noS",
  "species": "Klingons",
  "affiliation": "Klingon Empire",
  "warp_capable": true
}
```
Inserta un tercero:
```
{
  "name": "Ferenginar",
  "species": "Ferengi",
  "affiliation": "Ferengi Alliance",
  "warp_capable": true
}
```
Fíjate en un detalle interesante: no hay esquema rígido. MongoDB no te obliga a declarar columnas antes. Es como una biblioteca que acepta libros sin exigir número exacto de capítulos.

FASE 4 — Visualización y Edición de Documentos

Observa cómo Compass representa cada documento con su _id. Esa key es asignada automáticamente y sirve como identificador universal.

Ahora haz dos pruebas:
1. Edita un documento desde el icono Edit Document
  Cambia warp_capable de true a false en algún planeta no confirmado. Guarda y comprueba que Compass valida el JSON.
2. Elimina un planeta usando el botón Delete para simular que los registros debieron ser clasificadas tras un fallo diplomático.
Nadie en la Flota se escapa del poder del botón Delete.

FASE 5 — Consultas Visuales con Filtros

La Sección de Ciencia quiere consultar todos los planetas bajo Federation.
Compass lo hace sin comandos: usa el buscador superior.

Pulsa el filtro visual y escribe:
```
{ "affiliation": "Federation" }
```
Pulsa Apply.

Si el universo está en orden, solo aparecerán planetas pertenecientes a la Federación.

FASE 6 — Agregaciones en la Sala de Análisis

Compass dispone de un módulo llamado Aggregations que permite crear pipelines de análisis (equivalente a map–reduce ligero).

Entra en Aggregations y añade una etapa $group:
```
{
  "$group": {
    "_id": "$affiliation",
    "total": { "$sum": 1 }
  }
}
```
Pulsa Run.

Compass mostrará un resultado parecido a una estadística diplomática:
```
Federation: 1
Klingon Empire: 1
Ferengi Alliance: 1
```
Este tipo de vista enseña que MongoDB no solo guarda datos, también los procesa de forma analítica.

FASE 7 — Inferir Esquemas

Entra en la pestaña Schema dentro de la colección.

Compass examinará los documentos e inferirá:
- Tipos de campos
- Frecuencia de aparición
- Valores más comunes
Esto simula cómo la Sección de Xenobiología analiza patrones entre especies sin necesidad de preguntar “¿cuál es la estructura del registro?”.

FASE 8 — Crear Índices

Ahora ve a la pestaña Indexes para crear un índice sobre el campo name.

Pulsa Create Index y configura:
- Field: name
- Sort: Ascending
Clic en Create.

MongoDB construirá el índice internamente. Tu planeta ahora se encuentra más rápido cuando alguien lo necesita. Rendimiento y diplomacia se dan la mano.

FASE 9 — Desconexión y Cierre de Misión

Cierra Compass.
Detén el servicio MongoDB solo si el servidor necesita entrar en modo sigilo:
```
sudo systemctl stop mongod
```
La misión Compass se considera cumplida si has conseguido:
- Conectarse a una instancia MongoDB
- Crear bases de datos y colecciones desde GUI
- Insertar y editar documentos
- Filtrar visualmente
enero 15, 2026

3. MongoDB desde PHP y Python

Partimos de:

Servidor MongoDB: ya instalado y corriendo en Linux (mongod).
Base de datos de ejemplo: fed_records
Colección de ejemplo: planets
Conexión por defecto: mongodb://localhost:27017
(si el servidor está en otra máquina: mongodb://IP_DEL_SERVIDOR:27017)

En ambos lenguajes usaremos:

Crear conexión
Elegir base de datos y colección
CRUD básico: insertar, listar, buscar, actualizar, borrar

Uso de MongoDB desde PHP

Instalar el driver de MongoDB para PHP

En un entorno típico (Linux con PHP y Apache):

Instalar la extensión de MongoDB:

sudo pecl install mongodb

Puede ser que no tengas instaladas las herramientas deb, para hacerlo en ubuntu:

sudo apt update
sudo apt install php-pear php-dev build-essential

Tambien debemos instalar el conector de mongo con PHP

sudo apt install php-mongodb

Activar la extensión en PHP (por ejemplo en /etc/php/8.3/apache2/php.ini o similar):

Añadir esta línea:

extension=mongodb.so

Reiniciar Apache:

sudo systemctl restart apache2

Instalar el paquete Composer del driver oficial:

En el directorio del proyecto PHP:

composer require mongodb/mongodb

Si no usan Composer todavía, esta es buena ocasión para introducirlo.

Si no tienes instalada la herramienta composer de php:

sudo apt install composer

Recuerda que siempre es util pedir al servidor que muestre los errores de código.

ini_set(‘display_errors’, 1);

ini_set(‘display_startup_errors’, 1);

error_reporting(E_ALL);

Estructura de conexión en PHP

Archivo de ejemplo: mongo_test.php

<?php
require 'vendor/autoload.php'; // Carga automática de Composer

use MongoDB\Client;

// 1. Crear cliente (conexión)
$client = new Client("mongodb://localhost:27017");

// 2. Seleccionar base de datos y colección
$database = $client->fed_records;
$collection = $database->planets;

// 3. Insertar un documento
$insertResult = $collection->insertOne([
    'name' => 'Vulcan',
    'species' => 'Vulcans',
    'affiliation' => 'Federation',
    'warp_capable' => true
]);

echo "Insertado con ID: " . $insertResult->getInsertedId() . "<br>";

// 4. Buscar todos los documentos
echo "<h2>Lista de planetas:</h2>";

$cursor = $collection->find();

foreach ($cursor as $planet) {
    echo "Nombre: " . $planet['name'] . " - Alineación: " . $planet['affiliation'] . "<br>";
}

// 5. Búsqueda filtrada
echo "<h2>Planetas de la Federación:</h2>";

$cursor = $collection->find(['affiliation' => 'Federation']);

foreach ($cursor as $planet) {
    echo "Nombre: " . $planet['name'] . "<br>";
}

Abrir en el navegador (por ejemplo):
http://localhost/mongo_test.php

Operaciones CRUD básicas en PHP

Insertar varios documentos

$collection->insertMany([
    [
        'name' => 'Qo\'noS',
        'species' => 'Klingons',
        'affiliation' => 'Klingon Empire',
        'warp_capable' => true
    ],
    [
        'name' => 'Ferenginar',
        'species' => 'Ferengi',
        'affiliation' => 'Ferengi Alliance',
        'warp_capable' => true
    ]
]);

Buscar un solo documento

$planet = $collection->findOne(['name' => 'Vulcan']);

if ($planet) {
    echo "Encontrado: " . $planet['name'] . " (" . $planet['species'] . ")";
}

Actualizar

$updateResult = $collection->updateOne(
    ['name' => 'Vulcan'],
    ['$set' => ['warp_capable' => false]]
);

echo "Documentos modificados: " . $updateResult->getModifiedCount();

Borrar

$deleteResult = $collection->deleteOne(['name' => 'Ferenginar']);

echo "Documentos eliminados: " . $deleteResult->getDeletedCount();

Con esto ya pueden hacer una pequeña “mini-API” o scripts de administración en PHP.

Uso de MongoDB desde Python

Instalar el driver de MongoDB para Python

Usaremos el driver oficial pymongo.

Pymongo vive fuera del zoológico de paquetes de Ubuntu, así que el mensaje de PEP 668 que viste antes aplica aquí. La forma elegante es montar un entorno virtual y meter ahí el driver.

Pasos rápidos:

Instala las herramientas para crear entornos:

sudo apt install python3-venv python3-full

Crea un entorno para tu proyecto Mongo:

python3 -m venv ~/.venvs/mongo

Actívalo:

source ~/.venvs/mongo/bin/activate

Ahora el pip dentro de ese entorno puede instalar lo que sea sin que Ubuntu proteste:

pip install pymongo

Comprueba que funciona desde Python:

python3 - << 'EOF'
import pymongo
print("Pymongo ok, versión:", pymongo.__version__)
EOF

Conexión y CRUD básico en Python

Archivo de ejemplo: mongo_test.py

from pymongo import MongoClient

# 1. Crear cliente (conexión)
client = MongoClient("mongodb://localhost:27017")

# 2. Seleccionar base de datos y colección
db = client["fed_records"]
planets = db["planets"]

# 3. Insertar un documento
result = planets.insert_one({
    "name": "Vulcan",
    "species": "Vulcans",
    "affiliation": "Federation",
    "warp_capable": True
})

print("Insertado con ID:", result.inserted_id)

# 4. Obtener todos los documentos
print("\nLista de planetas:")
for planet in planets.find():
    print(f"- {planet['name']} ({planet['affiliation']})")

# 5. Búsqueda filtrada
print("\nPlanetas de la Federación:")
for planet in planets.find({"affiliation": "Federation"}):
    print(f"- {planet['name']}")

Ejecutar:

python3 mongo_test.py

Operaciones CRUD más completas en Python

planets.insert_many([
    {
        "name": "Qo'noS",
        "species": "Klingons",
        "affiliation": "Klingon Empire",
        "warp_capable": True
    },
    {
        "name": "Ferenginar",
        "species": "Ferengi",
        "affiliation": "Ferengi Alliance",
        "warp_capable": True
    }
])

Buscar uno

Insertar varios

vulcan = planets.find_one({"name": "Vulcan"})
if vulcan:
    print("Encontrado:", vulcan["name"], "-", vulcan["species"])

Actualizar

update_result = planets.update_one(
    {"name": "Vulcan"},
    {"$set": {"warp_capable": False}}
)

print("Documentos modificados:", update_result.modified_count)

Borrar

delete_result = planets.delete_one({"name": "Ferenginar"})
print("Documentos eliminados:", delete_result.deleted_count)

Ejemplo de pequeña “consulta analítica” (aggregations) en Python

Simulando algo tipo “cuántos planetas hay por alineación”:

pipeline = [
    {"$group": {"_id": "$affiliation", "total": {"$sum": 1}}},
    {"$sort": {"total": -1}}
]

print("\nResumen por alineación:")
for group in planets.aggregate(pipeline):
    print(f"{group['_id']}: {group['total']}")

Este ejemplo encaja muy bien con lo que ya han visto en Compass (pestaña Aggregations).

Práctica Guiada:

“Un mismo universo de datos: PHP, Python y MongoDB Compass”

Antes de empezar, debe estar listo:

Servidor MongoDB instalado y funcionando en el servidor Linux: sudo systemctl status mongod
PHP instalado (por ejemplo PHP 8.x) y un servidor web (Apache) o PHP CLI.
Composer instalado: composer --version
Python 3 instalado: python3 --version
MongoDB Compass instalado en el equipo del alumno o en alguna máquina con entorno gráfico.

PARTE 1 – PHP + MongoDB

Fase 1.1 — Preparar el proyecto PHP

Crea una carpeta para el proyecto, por ejemplo: mkdir ~/mongo_php_lab cd ~/mongo_php_lab
Instala el driver oficial de MongoDB para PHP vía Composer: composer require mongodb/mongodb
Asegúrate de tener instalada y activada la extensión nativa de MongoDB en PHP:
- Instalar extensión (si no está): sudo pecl install mongodb
- Añadir en el php.ini correspondiente (CLI o Apache): extension=mongodb.so
- Reiniciar Apache si usas servidor web: sudo systemctl restart apache2
- Comprobar desde CLI: php -m | grep mongodb
Debe aparecer mongodb en la lista de módulos.

Fase 1.2 — Crear el script PHP

Crea el archivo mongo_php_lab.php dentro de ~/mongo_php_lab con este contenido:

<?php
require 'vendor/autoload.php';

use MongoDB\Client;

// 1. Conexión al servidor MongoDB
$client = new Client("mongodb://localhost:27017");

// 2. Selección de base de datos y colección
$database = $client->fed_records;
$collection = $database->planets;

echo "<h1>PHP + MongoDB: Laboratorio de planetas</h1>";

// 3. Insertar varios planetas (insertMany)
echo "<h2>1. Insertando planetas...</h2>";

$insertResult = $collection->insertMany([
    [
        'name' => 'Vulcan',
        'species' => 'Vulcans',
        'affiliation' => 'Federation',
        'warp_capable' => true
    ],
    [
        'name' => "Qo'noS",
        'species' => 'Klingons',
        'affiliation' => 'Klingon Empire',
        'warp_capable' => true
    ],
    [
        'name' => 'Ferenginar',
        'species' => 'Ferengi',
        'affiliation' => 'Ferengi Alliance',
        'warp_capable' => true
    ]
]);

echo "Planetas insertados: " . $insertResult->getInsertedCount() . "<br>";

// 4. Listar todos los planetas
echo "<h2>2. Lista completa de planetas</h2>";

$cursor = $collection->find();

foreach ($cursor as $planet) {
    echo "Nombre: " . $planet['name'] .
         " | Especie: " . $planet['species'] .
         " | Alineación: " . $planet['affiliation'] .
         " | Warp: " . ($planet['warp_capable'] ? 'Sí' : 'No') .
         "<br>";
}

// 5. Mostrar solo los de la Federación
echo "<h2>3. Planetas de la Federación</h2>";

$cursorFed = $collection->find(['affiliation' => 'Federation']);

foreach ($cursorFed as $planet) {
    echo "Nombre: " . $planet['name'] . "<br>";
}

// 6. Cambiar un campo (warp_capable) para Vulcan
echo "<h2>4. Actualizando warp_capable de Vulcan a false</h2>";

$updateResult = $collection->updateOne(
    ['name' => 'Vulcan'],
    ['$set' => ['warp_capable' => false]]
);

echo "Documentos modificados: " . $updateResult->getModifiedCount() . "<br>";

// 7. Borrar un registro (Ferenginar)
echo "<h2>5. Borrando el planeta Ferenginar</h2>";

$deleteResult = $collection->deleteOne(['name' => 'Ferenginar']);

echo "Documentos eliminados: " . $deleteResult->getDeletedCount() . "<br>";

// 8. Lista final para comprobar cambios
echo "<h2>6. Lista final de planetas tras cambios</h2>";

$cursorFinal = $collection->find();

foreach ($cursorFinal as $planet) {
    echo "Nombre: " . $planet['name'] .
         " | Alineación: " . $planet['affiliation'] .
         " | Warp: " . ($planet['warp_capable'] ? 'Sí' : 'No') .
         "<br>";
}

Fase 1.3 — Ejecutar el script PHP

Opción A – Desde navegador (si usas Apache):

Copia el proyecto a la carpeta del servidor, por ejemplo: sudo cp -r ~/mongo_php_lab /var/www/html/
En el navegador, abre: http://IP_DEL_SERVIDOR/mongo_php_lab/mongo_php_lab.php

Opción B – Desde línea de comandos (CLI):

cd ~/mongo_php_lab
php mongo_php_lab.php

(La salida será texto plano, pero funcional para comprobar inserciones y cambios.)

Cuando termine esta parte, en la colección fed_records.planets deberían existir al menos:

Vulcan (warp_capable = false tras el update)
Qo'noS
Y no debería estar Ferenginar (borrado).

PARTE 2 – Python + MongoDB

Ahora toca hacer lo mismo, pero desde Python, y además añadir una agregación por affiliation.

Fase 2.1 — Instalar `pymongo`

En el servidor o equipo donde ejecutes Python:

pip install pymongo

(si usas pip3, cámbialo por pip3)

Fase 2.2 — Crear el script Python

En tu home (o donde quieras), crea para el lab:

mkdir ~/mongo_python_lab
cd ~/mongo_python_lab

Crea el archivo mongo_python_lab.py con este contenido:

from pymongo import MongoClient

# 1. Conexión al servidor MongoDB
client = MongoClient("mongodb://localhost:27017")

# 2. Seleccionar base de datos y colección
db = client["fed_records"]
planets = db["planets"]

print("PYTHON + MongoDB: Laboratorio de planetas\n")

# 3. Insertar nuevos planetas
print("1) Insertando nuevos planetas...\n")

insert_result = planets.insert_many([
    {
        "name": "Andoria",
        "species": "Andorians",
        "affiliation": "Federation",
        "warp_capable": True
    },
    {
        "name": "Cardassia Prime",
        "species": "Cardassians",
        "affiliation": "Cardassian Union",
        "warp_capable": True
    }
])

print("IDs insertados:", insert_result.inserted_ids, "\n")

# 4. Listar todos los planetas
print("2) Lista completa de planetas:")

for planet in planets.find():
    print(f"- {planet['name']} ({planet['affiliation']}) | Warp: {planet.get('warp_capable', 'N/A')}")

print()

# 5. Filtrar solo la Federación
print("3) Planetas de la Federación:")

for planet in planets.find({"affiliation": "Federation"}):
    print(f"- {planet['name']}")

print()

# 6. Actualizar: poner warp_capable = True de nuevo en Vulcan (si existe)
print("4) Actualizando warp_capable de Vulcan a True...\n")

update_result = planets.update_one(
    {"name": "Vulcan"},
    {"$set": {"warp_capable": True}}
)

print("Documentos modificados:", update_result.modified_count, "\n")

# 7. Borrar un planeta concreto: Cardassia Prime
print("5) Borrando Cardassia Prime...\n")

delete_result = planets.delete_one({"name": "Cardassia Prime"})
print("Documentos eliminados:", delete_result.deleted_count, "\n")

# 8. Agregación por affiliation
print("6) Agregación: número de planetas por affiliation:\n")

pipeline = [
    {"$group": {"_id": "$affiliation", "total": {"$sum": 1}}},
    {"$sort": {"total": -1}}
]

for group in planets.aggregate(pipeline):
    print(f"{group['_id']}: {group['total']} planetas")

Fase 2.3 — Ejecutar el script Python

Desde la carpeta del proyecto:

cd ~/mongo_python_lab
python3 mongo_python_lab.py

Observa:

Insertará Andoria y Cardassia Prime.
Luego listará todo lo que haya en fed_records.planets (incluyendo lo creado por PHP).
Volverá a poner Vulcan con warp_capable = True.
Borrará Cardassia Prime.
Mostrará la agregación por affiliation.

Con esto ya habrán hecho la misma lógica (y algo más) que en PHP, pero desde Python.

PARTE 3 – Verificación en MongoDB Compass

(La parte chula para cerrar el círculo)

Fase 3.1 — Conectarse con Compass

Abre MongoDB Compass.
En la pantalla inicial de conexión, usa:
- Si Compass está en el mismo servidor que MongoDB:
  - mongodb://localhost:27017
- Si Compass está en otro equipo de la red:
  - mongodb://IP_DEL_SERVIDOR:27017
Pulsa Connect.

Fase 3.2 — Explorar la base de datos `fed_records`

En la barra lateral izquierda, localiza la base de datos fed_records.
Entra en la colección planets.

Ahí deberías ver documentos provenientes de:

Las inserciones del script PHP.
Las inserciones del script Python.

Es decir, una mezcla de Vulcan, Qo’noS, Andoria, etc.

Fase 3.3 — Comprobar coherencia de los cambios

Verifica que:
- Vulcan existe y tiene warp_capable = true (último cambio lo hizo Python).
- Ferenginar no está (PHP lo borró).
- Cardassia Prime no está (Python lo borró).
Modifica un documento desde Compass, por ejemplo:
- Edita Qo'noS y cambia affiliation a "Klingon Empire (Updated)".
- Guarda los cambios.
Vuelve a ejecutar el script Python: cd ~/mongo_python_lab python3 mongo_python_lab.py En la parte de “lista completa de planetas” verás la nueva affiliation de Qo'noS leída desde Python.
Si vuelves a ejecutar el script PHP, también verá la misma realidad.

Con esto se ve claramente que la fuente de verdad es MongoDB, y PHP / Python / Compass son solo distintas formas de mirar y manipular ese mismo universo de datos.

enero 15, 2026

Categoría: MongoBD

1. Introducción a MongoDB

1. ¿Qué es MongoDB?

2. Instalación en Ubuntu/Debian

2.1. Actualizar el sistema

2.2. Instalar MongoDB desde repositorios oficiales (recomendado)

3. Iniciar, detener y habilitar el servicio

4. Acceso a la Consola de MongoDB (mongosh)

5. Comandos básicos

5.1. Mostrar bases de datos

5.2. Cambiar o crear una base de datos

5.3. Ver colecciones

5.4. Insertar documentos

5.5. Consultas (búsquedas)

5.6. Actualizar documentos

5.7. Borrar documentos

5.8. Borrar una colección entera

5.9. Borrar una base de datos

6. Estructura conceptual

7. Exportación e Importación (extra)

8. Detener el servicio y desinstalar (opcional)

Práctica Guiada: “MongoDB en la USS Horizon”

FASE 1 — Instalación del Servidor MongoDB

Procedimiento

Validación

FASE 2 — Arranque del Núcleo de Datos MongoDB

Objetivo

Procedimiento

Validación

FASE 3 — Acceso al Observador de Datos (mongosh)

Objetivo

Procedimiento

FASE 4 — Organización del Archivo Estelar

FASE 5 — Creación de Base de Datos y Colecciones

Objetivo

Procedimiento

FASE 6 — Manejo de Registros Científicos

Objetivo

A) Inserciones múltiples

B) Consultas

C) Actualizaciones

D) Eliminaciones

FASE 7 — Gestión de Colecciones y Base de Datos

Ver colecciones existentes

Eliminar una colección entera

Eliminar una base de datos

FASE 8 — Exportación e Importación (Bitácora Estelar)

FASE 9 — Cierre del Núcleo

2. MongoDB Compass

Instalación de MongoDB Compass (Linux/Windows/macOS)

Descarga oficial

Configuración inicial en clase

Conexión desde Compass (práctica guiada sencilla)

Caso A: Compass instalado en el servidor

Caso B: Compass desde portátil del alumno

Exploración visual de datos (lo que deben observar)

Agregaciones visuales (el jugo interesante)

Índices

Estadísticas de colección

Práctica Guiada: “Exploración Visual de Datos con MongoDB Compass”

FASE 1 — Preparar la Conexión desde Compass

FASE 2 — Exploración de la Biblioteca de Datos

FASE 3 — Inserción de Datos Científicos

FASE 4 — Visualización y Edición de Documentos

FASE 5 — Consultas Visuales con Filtros

FASE 6 — Agregaciones en la Sala de Análisis

FASE 7 — Inferir Esquemas

FASE 8 — Crear Índices

FASE 9 — Desconexión y Cierre de Misión

3. MongoDB desde PHP y Python

Partimos de:

Uso de MongoDB desde PHP

Instalar el driver de MongoDB para PHP

Estructura de conexión en PHP

Operaciones CRUD básicas en PHP

Insertar varios documentos

Buscar un solo documento

Actualizar

Borrar

Uso de MongoDB desde Python

Fase 2.1 — Instalar `pymongo`

Fase 3.2 — Explorar la base de datos `fed_records`