Mi primer proyecto con Docker + NodeJS + Express

Advertencia: Esta guía ya está desactualizada. Espero de igual forma mientras tanto te sirva.

A veces cuando tenemos varias máquinas y queremos compartir código utilizamos un repositorio y desde este podemos actualizar nuestro proyecto y compartirlo con nuestras distintas computadoras o, si estás en un equipo compartirlo con los demás y darle seguimiento al código por medio del repositorio, pero, ¿qué pasa si este proyecto necesita de mantener configuraciones especiales y hay muchos miembros en el equipo?, ¿qué pasa cuando tenemos todo configurado correctamente en nuestro servidor de desarrollo y vamos a mandarlo a producción?.

Para estos casos existe Docker, que con el mismo podemos generar una “mini máquina virtual” (por así decirle)donde estará por medio de un archivo llamado Dockerfile generando esta “mini máquina virtual” con el software necesario y las configuraciones necesarias para poder compartir entre nuestras máquinas o con nuestro equipo, así como mandar a producción y mucho más.

Combinando un repositorio + Docker podemos tener proyectos que podemos compartir fácilmente haciendo que nuestro equipo obtenga el código actual y cree su propio ambiente para trabajar en pocos minutos.

Para este caso, no voy a enseñar cómo funciona todo el Dockerfile ni tampoco mucho el uso de Docker o su instalación, para todo lo demás, existe MasterCard y Google. Pero si veremos cómo adaptar un proyecto de NodeJS + Express en Docker de forma sencilla.

Empezando con Express

Lo primero que necesitamos es generar una aplicación o tener ya una lista creada con Express, recomiendo que, si no tienen una aplicación (si ya la tienen puedes saltarte esta sección) y son novatos a la hora de usar Express, utilicen el generador de express instalándolo con el comando:

npm install express-generator -g

Recordemos que la flag -g nos permite instalarlo de forma global, por lo que podemos usarlo donde querramos, una vez que tengamos esto, hay que generar nuestro proyecto con el comando:

express --view=ejs api

Ejecutando este comando nos generará una carpeta llamada api con todos los archivos listos para hacer funcionar nuestro proyecto. Ahora, para poder iniciarlo y saber que está funcionando necesitamos instalar los paquetes incluídos para ello usamos el siguiente comando:

cd api && npm install

De esta forma accedemos a la carpeta api y después instalamos los paquetes con npm . Esperamos a que termine y después ejecutamos el comando:

npm start

Una vez que hagamos esto nos dirá que está corriendo el servidor y ya podremos acceder a el en la URL: http://localhost:3000 por default.

Creando nuestro contenedor

Ya que tenemos el proyecto necesitamos generar nuestro contenedor, para esto, ocupamos tener Docker y Docker-Compose instalados en nuestra máquina donde generaremos por primera vez nuestros archivos para nuestro contenedor.

Fuera de la carpeta api vamos a crear dos archivos, uno llamado Dockerfile (sin extensión) y el otro llamado docker-compose.yml (como se puede observar la extensión es .yml ). Pensando entonces que, fuera de la carpeta api es ahora nuestra raíz tendríamos algo como:

api
├── app.js
├── bin
│   └── www
├── package.json
├── public
│   ├── images
│   ├── javascripts
│   └── stylesheets
│       └── style.css
├── routes
│   ├── index.js
│   └── users.js
└── views
    ├── error.pug
    ├── index.pug
    └── layout.pug
Dockerfile
docker-compose.yml

Ahora, antes de avanzar y editar los archivos, es recomendable utilizar un tercer archivo llamado .dockerignore que hará que algunos archivos no se copien a nuestro contenedor ya que de igual manera dentro serán generados, por lo que recomiendo altamente crear un tercer archivo en la raíz de nuestro proyecto (fuera de la carpeta api como se menciona) y dentro poner únicamente:

.git
.gitignore
README.md
docker-compose.yml
node_modules

Una explicación rápida, en caso de que tengamos un repositorio en nuestro proyecto, ignoramos todos los archivos que se manejan con git, así como el README.md en caso de existir tampoco incluímos el archivo que compone el contenedor y por último lo más importante, no copiamos los módulos de node.

El Dockerfile

Ya que tenemos lo anterior, estamos listos para empezar a editar el Dockerfile para ello, únicamente es necesario abrirlo con cualquier editor, yo recomiendo Atom o Notepad++ para rápido, y una vez abierto en nuestro IDE de preferencia, necesitamos agregar lo siguiente:

FROM node:latest
RUN mkdir /src
WORKDIR /src
ADD api/package.json /src/package.json
RUN npm install
EXPOSE 3000
CMD nodemon server.js

Básicamente lo que hace es llamar la última versión de Node, crear un directorio de trabajo y usarlo, agregar el package.json de nuestro proyecto al contenedor, instalar los paquetes de forma interna, exponer el puerto 3000 y arrancar el script.

Pero aquí hay un problema, no queremos tener que entrar al contenedor y actualizar los cambios si no que queremos que de forma automática lo haga, para ello, en la carpeta de la api creamos un archivo llamado nodemon.json . El contenido del mismo lo explico más abajo. Una vez que tengamos esto hay que modificar el Dockerfile para incluir el soporte a Nodemon quedando ahora:

FROM node:latest
RUN mkdir /src
RUN npm install nodemon -g
WORKDIR /src
ADD api/package.json /src/package.json
RUN npm install
ADD api/nodemon.json /src/nodemon.json
EXPOSE 3000
CMD nodemon app.js

Hace lo mismo que anteriormente mencioné pero ahora incluye a Nodemon.

Hasta este punto ya está bastante bien adaptado nuestro contenedor, solo nos faltan dos cosas el docker-compose.yml y el nuevo nodemon.json .

Docker-compose + Nodemon

Para el docker-compose hay que abrirlo con nuestro IDE de preferencia e incluir el siguiente código:

api:  
     build: .  
     volumes:    
         - "./api:/src/"  
     ports:    
         - "80:3000"

Es sencillo lo que hace, genera el contenedor (basado en el Dockerfile ), agrega un volúmen y hace que nuestro puerto 3000 interno del Docker se convierta en 80 para afuera (por así decirlo).

Rápido, ¿qué es un volúmen?, básicamente el volúmen permite copiar los archivos de nuestra máquina al Docker para que de esta forma podamos trabajar desde fuera sin la necesidad de meter los archivos al Docker cada que los actualizamos.

Por último hay que agregar el código para nuestro Nodemon

{  
     "env": {    
         "NODE_ENV":"development"
     },
     "ext": "js json ejs"
}

Con esto ya finalizado, guardamos y deberíamos tener una estructura parecida a la siguiente:

api
├── app.js
├── bin
│   └── www
├── package.json
├── nodemon.json
├── public
│   ├── images
│   ├── javascripts
│   └── stylesheets
│       └── style.css
├── routes
│   ├── index.js
│   └── users.js
└── views
    ├── error.pug
    ├── index.pug
    └── layout.pug
Dockerfile
docker-compose.yml
.dockerignore

Corriendo el contenedor

Una vez que ya tenemos todo listo hay que construir la imagen y correr el contenedor, para esto usamos el comando para construir todo en la raíz de nuestro proyecto (donde se encuentra el docker-compose ):

docker-compose build

Esperamos a que realice todo el Docker (en caso de que tire un error, correr el comando con:sudo ), una vez que termine, si lo hizo sin errores ya estará disponible para funcionar, usamos el comando:

docker-compose up -d

Y ¡vualá!, nuestro docker está funcionando, podemos acceder a http://localhost y veremos nuestro Docker funcional y nuestra aplicación de Express. Si hacemos cambios en nuestro proyecto, se verán reflejados de forma automática en el Docker y veremos que se actualiza de forma automática el servidor, haciendo que, únicamente debamos darle “F5” (ctrl + R preferente para borrar la caché) a nuestro navegador y veremos los cambios reflejados.