Introducción a MongoDB

Actualizado el 07 de noviembre, 2016. Por BlueHosting.

La evolución en el desarrollo de aplicaciones web ha dado lugar a nuevas tecnologías y nuevas formas de integración que resultan en soluciones muy eficientes para aplicaciones web. La inmensa mayoría de los sitios web siguen utilizando soluciones de infraestructuras LAMP o LEMP para la integración de las tecnologías necesarias para su funcionamiento; sin embargo, la versatilidad de JavaScript ha conducido al desarrollo de soluciones basadas en este lenguaje que proveen características muy diversas. Un nuevo framework o infraestructura que está dando de qué hablar es MEAN (acrónimo de las tecnologías MongoDB, ExpressJS, AngularJS y NodeJS) todas tecnologías basadas en JavaScript. En esta guía abordaremos algunos conceptos introductorios a la solución MongoDB, la cual provee una base de datos generalmente usada en un framework MEAN.

Qué es MongoDB

Logo MongoDB

MongoDB es una solución de base de datos "NoSQL", es decir, que su estructura y funcionamiento difiere enormemente de una base de datos MySQL, PostgreSQL o MariaDB. En contraste, MongoDB es una base de datos muy poderosa basada en "documentos", los cuales son equivalentes a un objeto de JavaScript o a un LinkedHashMap de Java, en lugar de las filas y columnas tradicionales de una solución basada en SQL.

Obviar el uso del Mapeo Relacional de Objetos o ORM (Object-Relational mapping) en la base de datos permite la fácil manipulación, transferencia de datos y escalabilidad, ya que puede aumentar la cantidad de datos considerablemente sin que esto afecte el rendimiento de la base de datos.

Además MongoDB es una solución gratuita y de código abierto que provee muy alto rendimiento, disponibilidad y —como ya se mencionó— escalamiento automático.

Conceptos básicos

Documentos

Tal como mencionamos, un registro de MongoDB es un documento. Pero, ¿cómo están escritos los documentos? MongoDB utiliza JSON (JavaScript Object Notation —notación de objetos tipo JavaScript—) para la representación de los datos. Esto es una ventaja importante, ya que JSON es un formato de texto ligero y fácil de leer que facilita el intercambio de datos.

Los valores en un documento pueden incluir arreglos, otros documentos, o arreglos de documentos. Veamos un ejemplo de un registro en MongoDB (adaptado al español de la base de datos de prueba de Mongo por fines prácticos):

{
   "_id" : ObjectId("54c955492b7c8eb21818bd09"),
   "direccion" : {
      "calle" : "2 Avenue",
      "codigozip" : "10075",
      "edificio" : "1480",
      "coord" : [ -73.9557413, 40.7720266 ]
   },
   "ciudad" : "Manhattan",
   "cocina" : "Italian",
   "clasificación" : [
      {
         "fecha" : ISODate("2014-10-01T00:00:00Z"),
         "clasificación" : "A",
         "puntuación" : 11
      },
      {
         "fecha" : ISODate("2014-01-16T00:00:00Z"),
         "clasificación" : "B",
         "puntuación" : 17
      }
   ],
   "nombre" : "Gonzalo",
   "restaurante_id" : "41704620"
}

Tal como ocurre en textos JSON, primero se define un campo y luego se asigna un valor asociado con ese campo. En nuestro ejemplo podemos ver una muestra básica: la definición del campo "nombre", a este campo le asignamos el valor "Gonzalo". Un campo también puede tener un subconjunto de objetos, como es el caso del campo "clasificación" en nuestro ejemplo.

Colecciones

MongoDB almacena los documentos en colecciones. Las colecciones serían el equivalente a una tabla de una base de datos relacional. A diferencia de una tabla, una colección no requiere que sus documentos tengan el mismo esquema.

Cada documento almacenado en una colección debe tener un campo _id único que identifica inmutablemente a dicho documento, actuando como clave primaria.

Instalación y uso básico del servicio MongoDB

Tenga en cuenta que las últimas versiones de MongoDB ya no soportan sistemas de 32-Bit, por lo tanto, es sumamente recomendable —y casi necesario— que utilice un SO de 64-Bit. De lo contrario, tendrá que instalar una versión más antigua de MongoDB que no poseerá el soporte ni las actualizaciones necesarias.

A continuación mostramos las instrucciones de instalación de MongoDB para las distribuciones de Linux más comunes.

Nota: las instrucciones mostradas asumen que usted es un usuario no root con privilegios administrativos adecuados para ejecutar estos comandos. Para más información relacionada con el tema consulte: De la teoría a la práctica: sudo, sudoers y visudo.

Debian/Ubuntu

Instalación Debian/Ubuntu

MongoDB ya está incluido en los repositorios de paquetes de Ubuntu (dpkg, apt), pero la forma más recomendada de instalarlo es usando el repositorio oficial de MongoDB para obtener versiones más actualizadas.

Para asegurar la autenticidad de los paquetes debe comenzar a usar la clave pública GPG (GNU Privacy Guard ) de MongoDB por razones de seguridad. Para importar esta clave pública ejecute el siguiente comando:
```
sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv EA312927
```
Si el procedimiento es exitoso, podrá ver algo similar a lo siguiente:
```
gpg: Total number processed: 1
gpg:               imported: 1  (RSA: 1)
```

Ahora debemos agregar los detalles del repositorio de MongoDB de modo que apt sepa dónde buscar al momento de descargar los paquetes. Para esto creamos una fuente dentro del directorio de fuentes de apt (/etc/apt/sources.list.d):

Para Ubuntu 12.04 ejecute:

echo "deb http://repo.mongodb.org/apt/ubuntu precise/mongodb-org/3.2 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-3.2.list

Para Ubuntu 14.04 ejecute:

echo "deb http://repo.mongodb.org/apt/ubuntu trusty/mongodb-org/3.2 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-3.2.list

Para Ubuntu 16.04 utilice:

echo "deb http://repo.mongodb.org/apt/ubuntu xenial/mongodb-org/3.2 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-3.2.list

Si utiliza Debian 7 (Wheezy):

echo "deb http://repo.mongodb.org/apt/debian wheezy/mongodb-org/3.2 main" | sudo tee /etc/apt/sources.list.d/mongodb-org-3.2.list

Finalmente, si usa Debian 8 (Jessie) ingrese:

echo "deb http://repo.mongodb.org/apt/debian jessie/mongodb-org/3.2 main" | sudo tee /etc/apt/sources.list.d/mongodb-org-3.2.list

El próximo es un paso recomendado antes de instalar cualquier paquete de Linux, es actualizar el gestor de paquetes correspondientes a nuestra distro. Este comando servirá para cualquier versión de Ubuntu o Debian:
```
sudo apt-get update
```
El próximo paso es instalar la versión actualizada más estable de MongoDB en nuestro servidor, para hacerlo simplemente ejecute:
```
sudo apt-get install -y mongodb-org
```
Este comando instalará todos los paquetes que contienen la última versión de MongoDB junto con las herramientas de gestión para el servidor MongoDB.
Si utiliza Ubuntu 16.04 debe seguir algunos pasos adicionales antes de que MongoDB pueda funcionar; en este caso continúe leyendo la siguiente sección, de lo contrario salte a Uso básico del servicio en Debian/Ubuntu.

Instrucciones adicionales para Ubuntu 16.04

Para esta versión de Ubuntu, debemos crear un archivo de unidad que describa el servicio. Este archivo le dirá a systemd cómo administrar el recurso. Cree un nuevo archivo en la ruta /lib/systemd/system/mongod.service. Puede usar su editor favorito, por ejemplo veamos cómo crear el archivo usando el editor vi:

sudo vi /lib/systemd/system/mongod.service

Luego copie el siguiente contenido y péguelo en su nuevo archivo. Para entrar al modo de inserción de vi presione la tecla i, luego podrá pegar el extracto de código:

[Unit]
Description=High-performance, schema-free document-oriented database
After=network.target
Documentation=https://docs.mongodb.org/manual

[Service]
User=mongodb
Group=mongodb
ExecStart=/usr/bin/mongod --quiet --config /etc/mongod.conf

[Install]
WantedBy=multi-user.target

Cuando termine, presione ESC para salir del modo de inserción. Luego escriba el comando :wq y presione Enter para salir y guardar el archivo.

Al finalizar, ya estará listo para continuar con la siguiente sección y usar su solución MongoDB.

Uso básico del servicio en Debian/Ubuntu

Para iniciar el servicio simplemente ejecute:
```
sudo service mongod start
```

Si el servicio inicia correctamente no se mostrará ninguna salida. Para comprobar el estatus del servicio puede utilizar el siguiente comando:

Debian o Ubuntu 12.04/14.04:
```
service mongod status
```
Si el servicio inició correctamente podrá ver una salida similar a la siguiente:
```
mongod start/running, process 1578
```

Ubuntu 16.04:

sudo systemctl status mongodb

Si el servicio inició correctamente podrá ver una salida similar a la siguiente:

● mongodb.service - High-performance, schema-free document-oriented database
   Loaded: loaded (/etc/systemd/system/mongodb.service; enabled; vendor preset: enabled)
   Active: active (running) since Mon 2016-11-07 15:45:20 EDT; 1min 30s ago
 Main PID: 4093 (mongod)
    Tasks: 16 (limit: 512)
   Memory: 47.1M
      CPU: 1.112s
   CGroup: /system.slice/mongodb.service
           └─4093 /usr/bin/mongod --quiet --config /etc/mongod.conf

Para detener el servicio de MongoDB utilice:
```
sudo service mongod stop
```
Para reiniciarlo ejecute:
```
sudo service mongod restart
```
También puede habilitar el arranque de MongoDB incluso después de un reinicio en su servidor:
```
sudo systemctl enable mongodb
```

CentOS/Red Hat

Instalación CentOS/Red Hat

MongoDB no está incluido en los repositorios de CentOS, pero puede usar el repositorio dedicado de MongoDB para obtener los paquetes necesarios.

Primero debemos crear un archivo para poder instalar los paquetes de MongoDB directamente desde el gestor de paquetes yum. Este archivo debe estar ubicado en la ruta /etc/yum.repos.d/mongodb-org-3.2.repo. Tenga en cuenta que en esta guía utilizamos la versión más reciente de MongoDB para la fecha de publicación (3.2). Cree el archivo usando el editor vi:
```
sudo vi /etc/yum.repos.d/mongodb-org-3.2.repo
```
Entre en el modo de inserción de vi presionando la tecla i. Luego copie y pegue el siguiente fragmento de código para agregar el paquete del repositorio:
```
[mongodb-org-3.2]
name=MongoDB Repository
baseurl=https://repo.mongodb.org/yum/redhat/$releasever/mongodb-org/3.2/x86_64/
gpgcheck=1
enabled=1
gpgkey=https://www.mongodb.org/static/pgp/server-3.2.asc
```
Puede encontrar cuáles son los archivos .repo disponibles en el propio repositorio de MongoDB para yum. Cuando termine, presione ESC para salir del modo de inserción. Luego escriba el comando :wq y presione Enter para salir y guardar el archivo.

Luego puede comprobar que el repositorio fue agregado correctamente ingresando lo siguiente en su línea de comandos:

yum repolist

La salida será similar a lo siguiente:

Loaded plugins: fastestmirror, tsflags, universal-hooks
EA4                                                      | 2.9 kB     00:00
base                                                     | 3.6 kB     00:00
epel/x86_64/metalink                                     | 3.4 kB     00:00
epel                                                     | 4.3 kB     00:00
extras                                                   | 3.4 kB     00:00
mongodb-org-3.2                                          | 2.5 kB     00:00
updates                                                  | 3.4 kB     00:00

Observe que el repositorio de MongoDB fue agregado correctamente.

Finalmente, para instalar la última versión estable de MongoDB ejecute lo siguiente:
```
sudo yum install -y mongodb-org
```

Uso básico del servicio en CentOS/Red Hat

Para iniciar el proceso correspondiente a MongoDB (mongod) ingrese el siguiente comando:
```
sudo service mongod start
```
Si el servicio inicia correctamente observará algo similar a lo siguiente:
```
Starting mongod (via systemctl):                           [  OK  ]
```
En caso de que necesite detener el servicio utilice:
```
sudo service mongod stop
```
Si después de un cambio de configuración tiene que reiniciar MongoDB entonces puede utilizar:
```
sudo service mongod stop
```

Para verificar el estatus de MongoDB podemos comprobar el archivo log que se encuentra bajo la ruta /var/log/mongodb/mongod.log. Por ejemplo, veamos las últimas 3 líneas de este archivo:

sudo tail -3 /var/log/mongodb/mongod.log

La salida para este ejemplo indica lo siguiente:

2016-11-07T22:48:36.518-0500 I FTDC     [initandlisten] Initializing full-time diagnostic data capture with directory '/var/lib/mongo/diagnostic.data'
2016-11-07T22:48:36.519-0500 I NETWORK  [HostnameCanonicalizationWorker] Starting hostname canonicalization worker
2016-11-07T22:48:36.528-0500 I NETWORK  [initandlisten] waiting for connections on port 27017

La última línea indica que el servicio MongoDB ha iniciado correctamente y está esperando conexiones en el puerto especificado.

Nota: MongoDB escucha por defecto en el puerto 27071. Si utilizará esta solución de forma práctica debe abrir este puerto. No agregamos las instrucciones para no hacer el tutorial demasiado denso; sin embargo, recomendamos visitar las opciones mostradas en Recursos Adicionales.

Uso básico de MongoDB

Una vez que complete la instalación de esta solución, podemos explorar algunos usos breves:

La forma más simple de probar que nuestra instalación fue correcta es ingresando al shell de su instancia de MongoDB en ejecución. Asegúrese de que el servicio fue iniciado antes de intentar abrir el shell de MongoDB. Luego ejecute el comando:
```
mongo
```

Si el ingreso es correcto se mostrará algo similar a lo siguiente:

MongoDB shell version: 3.2.10
connecting to: test
Welcome to the MongoDB shell.
For interactive help, type "help".
... 
>

Si ejecutamos un simple comando help obtendremos una breve lista de ayuda con información de ayuda que es útil cuando estamos comenzando a usar esta base de datos:

db.help()                    help on db methods
db.mycoll.help()             help on collection methods
sh.help()                    sharding helpers
rs.help()                    replica set helpers
help admin                   administrative help
help connect                 connecting to a db help
help keys                    key shortcuts
help misc                    misc things to know
help mr                      mapreduce

show dbs                     show database names
show collections             show collections in current database
show users                   show users in current database
show profile                 show most recent system.profile entries with time >= 1ms
show logs                    show the accessible logger names
show log [name]              prints out the last segment of log in memory, 'global' is default
use <db_name>                set current database
db.foo.find()                list objects in collection foo
db.foo.find( { a : 1 } )     list objects in foo where a == 1
it                           result of the last line evaluated; use to further iterate
DBQuery.shellBatchSize = x   set default number of items to display on shell
exit                         quit the mongo shell

Para obtener datos de ayuda correspondiente a métodos para bases de datos (los cuales sirven para administrar sus bases de datos y comienzan con el prefijo db.) ejecute:
```
db.help()
```
Para crear una nueva base de datos utilice el siguiente comando:
```
use nuevabd
```
Sustituyendo nuevabd con el nombre deseado. Al usar el comando use, todos los nuevos comandos db. que utilicemos editarán la base de datos nuevabd. Para comprobar la base de datos en la cual está trabajando actualmente simplemente use:
```
db
```
Se mostrará la base de datos actual en la salida, en nuestro caso: nuevabd.
Para mostrar las bases de datos en su instancia de MongoDB ejecute:
```
show dbs
```
Hasta ahora, solo podremos ver la siguiente salida:
```
local  0.000GB
```
¿Dónde está la nueva base de datos que acabamos de crear?: para que esta base de datos se muestre en la lista, debemos poblarla con al menos un documento o colección.
Insertemos un nuevo valor o documento dentro de nuestra base de datos. Por ejemplo, insertemos una cadena de datos básicos en la base de datos actual (nuevabd):
```
db.datos.insert({"nombre":"Johel", "apellido":"Burgos","correo":"johel@ejemplo.com"})
```
Ahora, cuando volvemos a consultar las bases de datos disponibles usando show dbs obtenemos:
```
> show dbs
local    0.000GB
nuevabd  0.000GB
```
Si ejecutamos el comando show collections podremos ver que se creó una nueva colección a la cual denominamos datos en el paso 7:
```
> show collections
datos
```
Para salir del shell de MongoDB ejecute simplemente:
```
exit
```

Importar base de datos de ejemplo

Para practicar y explorar el uso de MongoDB puede importar la base de datos de prueba que provee el repositorio de MongoDB. Con esta podrá realizar las pruebas que considere pertinentes antes de comenzar con el desarrollo de una base de datos para la implementación de una App.

Puede usar cualquier directorio para almacenar el archivo de prueba, por ejemplo:
```
cd /tmp
```

Utilice el siguiente comando para descargar el archivo de prueba en JSON:

curl -LO https://raw.githubusercontent.com/mongodb/docs-assets/primer-dataset/primer-dataset.json

Ahora debe importar los datos en nuestra base de datos de prueba test. Para hacerlo, por favor ingrese el siguiente comando:

mongoimport --db test --collection restaurants --file /tmp/primer-dataset.json

Si todo sale bien, obtendremos una salida similar a la siguiente:

2016-11-07T23:35:22.138-0500    connected to: localhost
2016-11-07T23:35:23.418-0500    imported 25359 documents

Ahora puede explorar y practicar con la base de datos de prueba. Ingrese una vez más al shell mongo para comenzar. Por ejemplo, para hacer un query o consulta simple de todos los documentos en la colección restaurants utilice:
```
db.restaurants.find()
```
Se mostrarán todos los documentos disponibles en dicha colección en texto plano.
Para hacer una consulta más específica simplemente declare los valores del objeto. Por ejemplo, consultemos los datos para el borough específico de Brooklyn:
```
db.restaurants.find( { "borough": "Brooklyn" } )
```
El resultado mostrará únicamente los documentos coincidentes.
Las combinaciones para consultas son innumerables, puede utilizar cadenas condicionales como $gt (mayor que) $lt (menor que), especificar "y lógicos" utilizando comas (,) u "o lógicos" utilizando el selector $or. Por ejemplo, para consultar los documentos cuyos arreglos grades contengan un campo score mayor que 80 y que coincidan con el borough de Brooklyn ejecute:
```
db.restaurants.find( { "borough": "Brooklyn", "grades.score": { $gt: 80 } } )
```
Si ya ha terminado de utilizar la base de pruebas y desea eliminarla, utilice el comando drop():
```
db.restaurants.drop()
```

¡Esto es todo!, con la información dispuesta en esta guía ya puede tener un conocimiento base sólido para comenzar a explorar el uso práctico de MongoDB. Sin embargo, el contenido de esta solución es muy extenso y para comenzar a usar MongoDB en un entorno de producción le recomendamos visitar guías más profundas en la documentación de Mongo.

Recursos adicionales

Para complementar la información aquí presentada puede consultar los siguientes recursos. Aunque este material es provisto esperando que sea útil, tome en cuenta que no podemos certificar su actualidad o precisión.

Documentación oficial de MongoDB.
Puede consultar los siguientes tutoriales como apoyo para la apertura del puerto 27071, que necesitará una vez que realice una integración con MongoDB:
- ¿Cómo mostrar y eliminar reglas de firewall en iptables?
- Introducción a FirewallD en CentOS.