Cómo utilizar los volúmenes de Docker para programar más rápido

Use Docker Host Volumes y nodemon para escribir y probar su código más rápido durante el desarrollo.

Si es un desarrollador que usa Docker, es probable que haya escuchado que puede usar volúmenes para mantener el estado persistente de sus contenedores en producción. Pero lo que muchos desarrolladores no saben es que los volúmenes también pueden ser una excelente herramienta para acelerar su flujo de trabajo de desarrollo.

En esta publicación, le daré una breve descripción general de qué es un volumen de Docker, cómo funcionan los volúmenes de host de Docker y le mostraré un tutorial y un ejemplo de cómo puede usar volúmenes y nodemon para hacer que la codificación con Docker sea más fácil y rápida.

¿Qué es un volumen?

Los volúmenes son un tipo especial de carpeta a la que se puede acceder mediante un contenedor de Docker. A diferencia de las carpetas normales, los volúmenes tienen un ciclo de vida independiente de los contenedores en los que están montados. Eso es porque se almacenan fuera de un contenedor. Como resultado, los volúmenes facilitan la persistencia de datos incluso cuando los contenedores mueren y comparten datos entre contenedores y el host.

Docker le permite usar una variedad de métodos para implementar volúmenes. Algunos de ellos se centran en facilitar el intercambio de datos entre contenedores en el mismo host. Otros le permiten almacenar datos en un sistema de archivos externo, como un montaje de volumen NFS. En este artículo, nos vamos a centrar en un tipo de volumen conocido como volúmenes de host, que se pueden usar para que sea más fácil y rápido trabajar con el código de un contenedor.

Volúmenes de host

Los volúmenes de host le permiten montar una carpeta en su computadora portátil en un contenedor. Y eso resulta ser muy útil para acelerar su proceso de desarrollo.

Los volúmenes de host sincronizan los cambios de archivos entre una carpeta de host local y una carpeta contenedora. Por lo tanto, si usa un volumen de host para montar el código en el que está trabajando en un contenedor, cualquier edición que realice en su código en su computadora portátil aparecerá automáticamente en el contenedor.

Sin este enfoque, cada vez que desee probar su código, debe reconstruir el contenedor en el que está almacenado. Pero si monta su código como un volumen de host, puede configurar ese contenedor para sincronizar los cambios de código a medida que los realiza.

Para ilustrar esto, usaremos un ejemplo de Node.js: Node-todo , una sencilla aplicación de tareas creada por scotch.io . Para clonar el repositorio:

$ git clone https://github.com/kelda-inc/node-todo

El repositorio está diseñado para funcionar con Docker Compose. También funciona con Blimp , una alternativa a Compose que se ejecuta en la nube.

Aquí está el archivo de Node-todo "Docker-compose.yml":

YAML

version: '3'
services:
  web:
    build: .
    ports:
      - "8080:8080"
    depends_on:
      - mongo
    volumes:
      - "./app:/usr/src/app/app"
  mongo:
    image: "mongo"
    ports:
      - "27017:27017"

Este archivo le dice a Docker que inicie un contenedor, la aplicación y una base de datos MongoDB que la aplicación usa para almacenar las tareas pendientes. También le dice a Docker que monte un volumen de host:

    volumes:
      - "./app:/usr/src/app/app"

Como resultado, Docker montará el directorio ./app en su computadora portátil, que contiene su código, en el contenedor en /usr/src/app/app.

Ahora, lo que debemos hacer es asegurarnos de que el proceso del nodo se reinicie siempre que haya editado su código. Para eso, usaremos nodemon.

nodemon es un paquete de Node.js que reinicia automáticamente una aplicación cuando detecta cambios en los archivos en uno o más directorios específicos. Cuando cambia su código en su computadora portátil/de escritorio, nodemon detecta que el código ha cambiado y reinicia el proceso.

Entonces, en Dockerfile establecemos el punto de entrada en nodemon en lugar de node.js:

FROM node:10-alpine
ENV PORT 8080
WORKDIR /usr/src/app
COPY . /usr/src/app

RUN npm install -g nodemon
RUN npm install

ENTRYPOINT ["nodemon", "/usr/src/app/server.js"]

En este ejemplo, le mostramos cómo puede usar un volumen de host y un nodemon para sincronizar automáticamente su código entre su computadora portátil y su contenedor. Si no hubiera montado su código en el volumen del host, tendría que reconstruir el contenedor cada vez que quisiera probar un cambio. Dependiendo de su aplicación, eso puede consumir mucho tiempo.

Y al ahorrarle tiempo, esta técnica también le facilita la escritura de código excelente. Si necesita detenerse y esperar cada vez que necesita probar un cambio, es un desafío mantener un estado de flujo. Agregue todas las otras distracciones con las que tiene que lidiar, y no es una receta para ser productivo.

Sincronización de su código al desarrollar su aplicación

En esta sección, describiremos cómo tomar uno de sus proyectos existentes y habilitar la sincronización para un desarrollo rápido tal como lo hicimos anteriormente.

En este ejemplo, usaremos Node.js. En publicaciones futuras, proporcionaremos ejemplos para otros idiomas.

requisitos previos

Al igual que en el ejemplo anterior, su proyecto debe tener:

• Un repositorio git con el código en el que estás trabajando
• Un Dockerfile que compila ese código en un contenedor de trabajo
• Un archivo Docker-compose.yml que usa para ejecutar ese contenedor

Cómo configurar su contenedor para sincronizar su código automáticamente

1) Busque la carpeta en su contenedor Docker que tiene su código . La forma más fácil de averiguar dónde se encuentra su código en su contenedor es mirar los COPY comandos en su Dockerfile. En el ejemplo de Node-todo, puede ver en su Dockerfile que el código se encuentra en . /usr/src/aplicación:

COPY . /usr/src/app

2) Encuentre la ruta a la carpeta en su computadora portátil que tiene el mismo código .

3) Agregue un volumen de host a su archivo Docker-compose. Encuentre el contenedor en su archivo Docker-compose con el que desea sincronizar el código y agregue una instrucción de 'volumen' debajo de ese contenedor:

volumes:
  "/path-to-laptop-folder:/path-to-container-folder"

4) Cambiar de usar node.js a nodemon. En el ejemplo de Node-todo, lo implementamos usando su Dockerfile:

Caparazón

RUN npm install -g nodemon
RUN npm install

ENTRYPOINT ["nodemon", "/usr/src/app/server.js"]

Como resultado, Docker instalará nodemon "npm install -g nodemony" cambiará el punto de entrada de node a nodemon.

5) Ejecute Docker Compose o Blimp . Ahora todo lo que necesita hacer es ejecutar Docker-compose:

$ docker-compose up

O si estás usando Blimp :

$ blimp up

Docker sobrescribirá el código integrado en el contenedor con el código que tiene ejecutándose localmente en su computadora portátil.

¡Y ya está todo listo! Al modificar su proyecto para que use un volumen de host y un nodemon, cualquier cambio que realice en el código de su computadora portátil ahora aparecerá automáticamente en el contenedor.

Conclusión

Los volúmenes de Docker se diseñaron originalmente para facilitar el trabajo con archivos locales. Pero como hemos visto en este artículo, también son una excelente manera de hacer que el desarrollo sea más fácil y rápido. Es posible que le tome un poco de tiempo acostumbrarse a usar volúmenes como parte de su proceso de desarrollo. Pero a la larga, te alegrarás de haber cambiado a usarlos.