Docker es cada vez más popular y lo he ido introduciendo poco a poco en mis proyectos. Facilita la distribución de tus aplicaciones porque, independientemente de dónde despliegues tus contenedores, la experiencia será la misma. Veamos cómo funciona esto usando Docker y Node.js, que tiene muchas variaciones. Aunque generalmente funcionan independientemente del aplicación web, no se puede estar realmente seguro cuando se utiliza el tiempo de ejecución de Node.js.
Vamos a ver cómo construir un NoSQL y desplegarlo junto a un contenedor de aplicaciones web personalizado que hace uso de Node y Docker para encapsular la información necesaria. Couchbase funciones.
¿Qué es Node.js?
Antes de pasar al tutorial, dediquemos un minuto a definir Node.js. En lugar de ejecutarse dentro de un navegador, Node es un tiempo de ejecución de código abierto y totalmente multiplataforma para ejecutar JavaScript en un entorno de servidor. Con Node.js, los desarrolladores pueden crear aplicaciones totalmente en la nube que operan de forma invisible para los usuarios pero que proporcionan funcionalidades cruciales en las empresas modernas. Couchbase está optimizado para ejecutar aplicaciones construidas con Node.js. Este tutorial demuestra cómo aprovechar esta capacidad emparejando Node.js y contenedores Docker.
Si es la primera vez que se expone a Docker contenedores, vamos a desglosar lo que esperamos lograr. Couchbase ha publicado una imagen Docker oficial para Centro Docker para desarrolladores de Node.js, pero la imagen no está preaprovisionada. Esto no es algo malo y es definitivamente lo que esperaríamos en un contenedor de base de datos. Esto significa que tenemos que crear una imagen personalizada basada en la imagen oficial, de lo contrario cuando despleguemos Couchbase, no se habrá configurado. Vamos a escribir una aplicación en Node.js y "Dockerizarla en un paquete contenedor. Estos dos contenedores Docker de Couchbase y Node.js podrán comunicarse entre sí.
Creación de una imagen Docker y un contenedor Couchbase Server personalizados
Cree un directorio en algún lugar de su ordenador e incluya los dos archivos siguientes:
|
1 2 |
Dockerfile configure.sh |
El dockerfile de ejemplo - Dockerfile - representará nuestra imagen personalizada, y el configure.sh será un script de ejecución para cuando despleguemos nuestro contenedor.
Abra el Dockerfile e incluya lo siguiente:
|
1 2 3 4 5 |
DESDE couchbase COPIAR configure.sh /opt/couchbase CMD ["/opt/couchbase/configure.sh"] |
Nuestra imagen personalizada utilizará la imagen oficial de Couchbase como base. En el momento de la compilación, el script de configuración se copiará en la imagen. Cuando se ejecute, el script será ejecutado. Echemos un vistazo a ese script.
Abra el configure.sh e incluya lo siguiente:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
set -m /entrypoint.sh couchbase-server & dormir 15 curl -v -X POST http://127.0.0.1:8091/pools/default -d memoryQuota=512 -d indexMemoryQuota=512 curl -v http://127.0.0.1:8091/node/controller/setupServices -d services=kv%2cn1ql%2Cindex curl -v http://127.0.0.1:8091/settings/web -d port=8091 -d username=$COUCHBASE_ADMINISTRATOR_USERNAME -d password=$COUCHBASE_ADMINISTRATOR_PASSWORD curl -i -u $COUCHBASE_ADMINISTRATOR_USERNAME:$COUCHBASE_ADMINISTRATOR_PASSWORD -X POST http://127.0.0.1:8091/settings/indexes -d 'storageMode=memory_optimized' curl -v -u $COUCHBASE_ADMINISTRATOR_USERNAME:$COUCHBASE_ADMINISTRATOR_PASSWORD -X POST http://127.0.0.1:8091/pools/default/buckets -d name=$COUCHBASE_BUCKET -d bucketType=couchbase -d ramQuotaMB=128 -d authType=sasl -d saslPassword=$COUCHBASE_BUCKET_PASSWORD dormir 15 curl -v http://127.0.0.1:8093/query/service -d "statement=CREATE PRIMARY INDEX ON `$COUCHBASE_BUCKET`" fg 1 |
Una vez más, el objetivo de la configure.sh es aprovisionar el servidor después de su lanzamiento. Para ello, podemos hacer uso de la API RESTful de Couchbase. La configuración incluye crear un clúster, habilitar los servicios de Couchbase, definir las credenciales de administración, crear un Bucket y crear un índice N1QL en el bucket.
En el script de configuración observará que se utilizan varias variables de entorno, por ejemplo la variable $COUCHBASE_ADMINISTRATOR_USERNAME variable. Esto nos ahorrará codificar información potencialmente sensible en la imagen. En su lugar, podemos definir estas variables en el despliegue.
Ahora vamos a construir la imagen personalizada de Couchbase para nuestro proyecto. Desde Docker Shell, ejecuta lo siguiente:
|
1 |
docker build -t couchbase-custom /ruta/a/directorio/con/dockerfile |
En el comando anterior, el couchbase-personalizar text es el nombre de nuestra imagen, mientras que path es la ruta a nuestra Dockerfile y configure.sh archivos.
Con la imagen personalizada creada para Couchbase, ejecute el siguiente comando para ejecutarla:
|
1 2 3 4 5 6 7 8 9 |
docker run -d \ -p 8091-8093:8091-8093 \ -e COUCHBASE_ADMINISTRATOR_USERNAME=Administrador \ -e COUCHBASE_ADMINISTRATOR_PASSWORD=contraseña \ -e COUCHBASE_BUCKET=default \ -e COUCHBASE_BUCKET_PASSWORD= \ --network="docker_default" \ --name couchbase couchbase-personalizar |
El comando anterior dice que queremos desplegar un contenedor, mapeando cada uno de los puertos necesarios de Couchbase. Pasamos las variables de entorno que se encuentran en nuestro configure.sh y definimos en qué red queremos que se ejecute el contenedor. El contenedor se llamará couchbaseque también será el nombre de host del contenedor.
Creación de una aplicación web Node.js RESTful API
Con Couchbase funcionando, podemos desarrollar una simple aplicación Node.js. Crea un directorio en algún lugar de tu ordenador para representar nuestro proyecto. Dentro de ese proyecto, crea un directorio app.js archivo. Vamos a instalar paquetes privados con NPM en un contenedor Docker. Desde el Símbolo del sistema o Terminal, ejecuta lo siguiente:
|
1 |
npm init --y |
El comando anterior creará un paquete.json que será la base de nuestra aplicación Node.js. Hay algunas dependencias que deben ser instaladas, así que vamos a ejecutar lo siguiente para obtenerlas:
|
1 |
npm install express couchbase body-parser uuid --save |
Utilizaremos express para construir nuestra API, couchbase como nuestro SDK, body-parser para trabajar con organismos POST, y uuid para generar valores de identificación únicos que representarán las claves del documento.
Con la base de la aplicación en su lugar, podemos empezar a desarrollar la aplicación. Abra el archivo app.js e incluya el siguiente código:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
var Couchbase = require("couchbase"); var Express = require("express"); var BodyParser = require("body-parser"); var UUID = require("uuid"); var app = Express(); var N1qlQuery = Couchbase.N1qlQuery; var bucket = (new Couchbase.Cluster("couchbase://" + process.env.COUCHBASE_HOST)).openBucket(process.env.COUCHBASE_BUCKET, process.env.COUCHBASE_BUCKET_PASSWORD); app.use(BodyParser.json()); app.get("/", function(request, response) { response.send("¡Intente utilizar los puntos finales `/get` o `/save`!"); }); app.get("/get", function(request, response) { var query = N1qlQuery.fromString("SELECT `" + bucket._name + "`.* FROM `" + bucket._name + "`"); bucket.query(query, function(error, result) { if(error) { return response.status(500).send(error); } response.send(resultado); }); }); app.post("/guardar", function(request, response) { bucket.insert(UUID.v4(), request.body, function(error, result) { if(error) { return response.status(500).send(error); } response.send(resultado); }); }); var server = app.listen(process.env.APPLICATION_PORT || 3000, function() { console.log("Escuchando en el puerto " + server.address().port + "..."); }); |
¿Qué ocurre en el código anterior?
Primero importamos todas las dependencias descargadas y luego establecemos una conexión con Couchbase. Notarás que estamos usando env.proceso en todo el código. Esto nos permite leer variables de entorno. Vamos a utilizar un enfoque similar al que vimos en la imagen de Couchbase.
La API tiene dos puntos finales que realmente hacen algo. El /guardar insertará lo que haya en el cuerpo de la solicitud y el archivo /obtener buscará lo que esté guardado en Couchbase.
Containerización de la aplicación web Node.js
Con la aplicación construida, necesitamos contenerizarla para que pueda ser desplegada fácilmente con Docker. En el mismo directorio que su paquete.json añada los dos archivos siguientes:
|
1 2 |
Dockerfile .dockerignore |
El plan es crear una imagen personalizada basada en la imagen Docker oficial de Node.js. Dentro de la Dockerfile incluya lo siguiente:
|
1 2 3 4 5 6 7 8 |
DE nodo:6-alpina COPIA . /srv/ directorio de trabajo /srv EJECUTAR /usr/local/bin/npm install CMD /usr/local/bin/node app.js |
Durante la construcción de la imagen, vamos a copiar nuestro proyecto en el sistema de archivos de la imagen y cambiar el directorio de trabajo. A continuación, vamos a instalar todas las dependencias que se encuentran en el archivo paquete.json archivo. Cuando se despliega el contenedor, el archivo app.js se ejecutará el archivo.
Puede que te preguntes por qué hacemos una instalación cuando creamos la imagen. Lo hacemos porque no queremos copiar las dependencias en la imagen, ya que podría haber incompatibilidades de sistema operativo y arquitectura. Para excluir las node_modules de nuestra imagen, incluya lo siguiente en el directorio .dockerignore file:
|
1 |
node_modules |
Todo lo que quieras excluir de la imagen puede ir en ese archivo.
Para construir esta imagen, ejecute lo siguiente desde Docker Shell:
|
1 |
docker build -t nodejs-custom /ruta/a/directorio/con/dockerfile |
El nombre de la imagen para nuestra aplicación Node.js se llamará nodejs-custom y se basará en el directorio que contiene el archivo Dockerfile archivo. Puede encontrar más información sobre la creación de imágenes Docker personalizadas en un archivo artículo anterior que escribí.
Con la imagen disponible, necesitamos ejecutarla. Desde Docker Shell, ejecuta lo siguiente:
|
1 2 3 4 5 6 7 8 9 |
docker run -d \ -p 3000:3000 \ -e COUCHBASE_HOST=couchbase \ -e COUCHBASE_BUCKET=default \ -e COUCHBASE_BUCKET_PASSWORD= \ -e APPLICATION_PORT=3000 \ --network="docker_default" \ --name nodejs \ nodejs-custom |
El comando anterior debería parecernos familiar a lo que vimos en el despliegue de Couchbase. Estamos definiendo el mapeo de puertos de nuestra aplicación, pasando las variables de entorno que se utilizan en el comando app.js definiendo la red de contenedores y el nombre de la imagen.
Si vas a tu navegador web y navegas a cualquiera de los endpoints de la aplicación web, debería funcionar correctamente.
Uso de un archivo Compose para desplegar contenedores Docker
Tener que recordar todas las variables de entorno y todo en el comando para desplegar los contenedores puede ser doloroso. Crear un archivo Compose puede simplificar mucho las cosas.
Una vez que hayas creado tus dos imágenes personalizadas, crea un archivo docker-compose.yml en algún lugar de su ordenador. Este archivo debe contener lo siguiente:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
versión: "2 servicios: couchbase: imagen: couchbase-custom puertos: - 8091:8091 - 8092:8092 - 8093:8093 medio ambiente: - COUCHBASE_ADMINISTRATOR_USERNAME=Administrador - COUCHBASE_ADMINISTRATOR_PASSWORD=contraseña - COUCHBASE_BUCKET=por defecto - COUCHBASE_BUCKET_PASSWORD= CONTRASEÑA nodejs: imagen: nodejs-custom puertos: - 3000:3000 medio ambiente: - COUCHBASE_HOST=couchbase - COUCHBASE_BUCKET=por defecto - COUCHBASE_BUCKET_PASSWORD= CONTRASEÑA - PUERTO_APLICACION=3000 reinicio: siempre |
Cuando se utiliza Compose, no hay que preocuparse de definir la red, ya que todo el archivo estará en la misma red. Para lanzar cualquiera de los contenedores, puedes ejecutar lo siguiente:
|
1 |
docker-compose run -d --service-ports --name couchbase couchbase |
Con Couchbase, no puedes hilar todo junto porque Couchbase no tiene un método para decirte cuando está listo. Debido a esto, la aplicación Node.js podría intentar conectarse antes de que Couchbase esté listo para aceptar conexiones.
|
1 |
docker-compose up -d |
El comando anterior normalmente pone en marcha todos los contenedores en el archivo Compose, pero no podemos usarlo en este escenario.
Conclusión
Si te preguntas cómo puedes desplegar tu aplicación web Node.js con Couchbase, Docker es una solución fácil. Después de construir imágenes de Couchbase o Node.js, puedes confiar en que funcionará igual en cualquier servidor u ordenador que ejecute el motor Docker.
Para obtener más información sobre el uso del SDK de Couchbase para Node.js, consulte la página Portal para desarrolladores de Couchbase.
[...] hace demasiado tiempo escribí sobre la contenedorización de una API RESTful de Node.js y Couchbase Server para demostrar lo fácil que es desplegar aplicaciones web de forma rápida y fiable. En aquel [...]
[...] Si estás interesado en desplegar una aplicación web Node.js en contenedores que utiliza contenedores Couchbase, echa un vistazo a este artículo que había escrito anteriormente llamado, Deploy a Node.js with Couchbase Web Application as Docker Containers. [...]
[...] siguientes posts de Nic Raboy son muy útiles para ponerse en marcha con Docker y [...]