La aplicación Notepad será opcional en Windows 10 20H1

Cada pocos años, en la industria del desarrollo de software, ocurre un cambio de paradigma. Uno de estos fenómenos es el aumento del interés por el concepto de microservicios. Aunque los microservicios no son una tecnología nueva, su popularidad ha crecido exponencialmente en tiempos recientes.

Los grandes servicios monolíticos están siendo reemplazados hoy en día por microservicios autónomos e independientes. Un microservicio puede considerarse como una aplicación que cumple un único y muy específico propósito. Por ejemplo, puede ser una base de datos relacional, una aplicación Express o un servicio Solr.

Hoy en día, es difícil imaginar el desarrollo de un nuevo sistema de software sin el uso de microservicios. Esta situación, a su vez, nos lleva a la plataforma Docker.

Docker

Plataforma Docker, en el desarrollo y despliegue de microservicios, se ha convertido prácticamente en un estándar industrial. En el sitio del proyecto, se puede encontrar que Docker es la única plataforma de contenedorización independiente que permite a las organizaciones crear, distribuir y ejecutar cualquier aplicación en diversos entornos, desde nubes híbridas hasta sistemas de borde.

Docker Compose

Tecnología Docker Compose está diseñado para configurar aplicaciones de múltiples contenedores. En un proyecto de Docker Compose, puede haber tantos contenedores Docker como el creador de dicho proyecto necesite.

Al trabajar con Docker Compose, se usa un archivo YAML para configurar los servicios de la aplicación y organizar su interacción entre sí. Docker Compose es, por lo tanto, una herramienta para describir y ejecutar aplicaciones de múltiples contenedores Docker.

Dos contenedores que funcionan en el sistema host

GNU Make

reescribirá los metadatos del sistema de archivos. Para esto, usamos el siguiente comando: make, en esencia, es una herramienta para automatizar la construcción de programas y bibliotecas a partir del código fuente. En general, se puede decir que make se aplica a cualquier proceso que involucre la ejecución de comandos arbitrarios para transformar ciertos materiales de entrada en una forma o un objetivo resultante. En nuestro caso, los comandos docker-compose se transformarán en objetivos abstractos (Phony targets).

Para indicar al programa make lo que queremos de él, necesitaremos un archivo Makefile.

En nuestro Makefile que contendrá comandos habituales docker y docker-compose, que están destinados a resolver diversas tareas. En particular, se habla de la creación de un contenedor, su inicio, detención, reinicio, la organización del acceso del usuario al contenedor, el trabajo con los registros del contenedor y la solución de otras tareas similares.

Opciones típicas de uso de Docker Compose

Imaginemos una aplicación web típica, que tiene los siguientes componentes:

• Base de datos TimescaleDB (Postgres).
• Aplicación Express.js.
• Ping (simplemente un contenedor que no hace nada especial).

Esta aplicación necesitará 3 contenedores Docker y un archivo docker-compose, que contiene instrucciones para administrar estos contenedores. Cada uno de los contenedores tendrá diferentes puntos de interacción. Por ejemplo, con el contenedor timescale , se podrá trabajar de manera similar a cómo se trabaja con bases de datos. Es decir, permite realizar las siguientes acciones:

• Acceso a la consola de Postgres.
• Importar y exportar tablas.
• Creación pg_dump tablas o bases de datos.

Contenedor de la aplicación Express.js, expressjs, puede tener las siguientes capacidades:

• Proporcionar datos frescos del registro del sistema.
• Acceso a la consola para ejecutar ciertos comandos.

Interacción con los contenedores

Después de que hayamos configurado la conexión entre contenedores usando Docker Compose, es hora de establecer la interacción con estos contenedores. Dentro del sistema Docker Compose hay un comando docker-compose, que admite la opción -f, que permite pasar al sistema un archivo docker-compose.yml.

Utilizando las capacidades de esta opción, se puede limitar la interacción con el sistema solo a aquellos contenedores mencionados en el archivo docker-compose.yml.

Veamos cómo lucen las interacciones con los contenedores al usar comandos docker-compose. Si imaginamos que necesitamos acceder a la consola de psql, los comandos correspondientes pueden verse así:

docker-compose -f docker-compose.yml exec timescale psql -Upostgres

El mismo comando, para el que no se utiliza docker-compose, y docker, podría verse así:

docker exec -it edp_timescale_1 psql -Upostgres

Tenga en cuenta que en tales casos siempre es preferible usar el comando docker, en lugar del comando docker-compose, ya que esto elimina la necesidad de recordar los nombres de los contenedores.

Ambos comandos mencionados anteriormente no son tan difíciles. Pero si usáramos un 'wrapper' en forma de Makefile, que nos daría una interfaz en forma de comandos simples y que invocaría comandos largos similares, podríamos alcanzar los mismos resultados así:

make db-shell

Es completamente evidente que el uso de Makefile simplifica significativamente el trabajo con contenedores!

Ejemplo práctico

Basándonos en el esquema del proyecto previamente mencionado, crearemos el siguiente archivo docker-compose.yml:

version: '3.3'
services:
    api:
        build: .
        image: mywebimage:0.0.1
        ports:
            - 8080:8080
        volumes:
            - /app/node_modules/
        depends_on:
            - timescale
        command: npm run dev
        networks:
            - webappnetwork
    timescale:
        image: timescale/timescaledb-postgis:latest-pg11
        environment:
          - POSTGRES_USER=postgres
          - POSTGRES_PASSWORD=postgres
        command: ["postgres", "-c", "log_statement=all", "-c", "log_destination=stderr"]
        volumes:
          - ./create_schema.sql:/docker-entrypoint-initdb.d/create_schema.sql
        networks:
           - webappnetwork
    ping:
       image: willfarrell/ping
       environment:
           HOSTNAME: "localhost"
           TIMEOUT: 300
networks:
   webappnetwork:
       driver: bridge

Para gestionar la configuración de Docker Compose y para interactuar con los contenedores que describe, crearemos el siguiente archivo Makefile:

THIS_FILE := $(lastword $(MAKEFILE_LIST))
.PHONY: help build up start down destroy stop restart logs logs-api ps login-timescale login-api db-shell
help:
        make -pRrq -f $(THIS_FILE) : 2>/dev/null | awk -v RS= -F: '/^# File/,/^# Finished Make data base/ {if ($$1 !~ "^[#.]") {print $$1}}' | sort | egrep -v -e '^[^[:alnum:]]' -e '^$@$$'
build:
        docker-compose -f docker-compose.yml build $(c)
up:
        docker-compose -f docker-compose.yml up -d $(c)
start:
        docker-compose -f docker-compose.yml start $(c)
down:
        docker-compose -f docker-compose.yml down $(c)
destroy:
        docker-compose -f docker-compose.yml down -v $(c)
stop:
        docker-compose -f docker-compose.yml stop $(c)
restart:
        docker-compose -f docker-compose.yml stop $(c)
        docker-compose -f docker-compose.yml up -d $(c)
logs:
        docker-compose -f docker-compose.yml logs --tail=100 -f $(c)
logs-api:
        docker-compose -f docker-compose.yml logs --tail=100 -f api
ps:
        docker-compose -f docker-compose.yml ps
login-timescale:
        docker-compose -f docker-compose.yml exec timescale /bin/bash
login-api:
        docker-compose -f docker-compose.yml exec api /bin/bash
db-shell:
        docker-compose -f docker-compose.yml exec timescale psql -Upostgres

La mayoría de los comandos descritos aquí se aplican a todos los contenedores, pero el uso de la opción c= permite limitar el alcance del comando a un único contenedor.

Después de que Makefile está listo, se puede usar así:

• make help — muestra una lista de todos los comandos disponibles para make.

Ayuda sobre los comandos disponibles

• make build — construcción de la imagen a partir de Dockerfile. En nuestro ejemplo, hemos utilizado imágenes existentes timescale y ping. Pero la imagen api que queremos construir localmente. Esto es exactamente lo que se hará después de ejecutar este comando.

Construcción de un contenedor Docker

• make start — iniciar todos los contenedores. Para iniciar solo un contenedor, se puede utilizar un comando como make start c=timescale.

Iniciar el contenedor timescale

Iniciar el contenedor ping

• make login-timescale — acceso a la sesión bash del contenedor timescale.

Iniciar bash en el contenedor timescale

• make db-shell — acceso a psql en un contenedor timescale para ejecutar consultas SQL a la base de datos.

Iniciar psql en el contenedor timescaledb

• make stop — detener los contenedores.

Detener el contenedor timescale

• make down — detener y eliminar contenedores. Para eliminar un contenedor específico, se puede usar este comando indicando el contenedor deseado. Por ejemplo — make down c=timescale o make down c=api.

Detener y eliminar todos los contenedores

Resultados

A pesar de que el sistema Docker Compose nos proporciona un amplio conjunto de comandos para gestionar los contenedores, a veces estos comandos se hacen largos, lo que dificulta su memorización.

La metodología de uso Makefile nos ha ayudado a establecer una interacción rápida y simple con los contenedores desde el archivo docker-compose.yml. En concreto, se trata de lo siguiente:

• El desarrollador interactúa solo con los contenedores del proyecto, descritos en docker-compose.yml, sin que otros contenedores en funcionamiento interfieran en el trabajo.
• En caso de que se olvide algún comando, se puede ejecutar el comando make help y obtener ayuda sobre los comandos disponibles.
• No es necesario memorizar largas listas de argumentos para realizar acciones como obtener entradas recientes del registro o iniciar sesión. Por ejemplo, un comando como docker-compose -f docker-compose.yml exec timescale psql -Upostgres se convierte en make db-shell.
• Archivo Makefile se puede adaptar flexiblemente a medida que el proyecto crece. Por ejemplo, no es difícil agregar un comando para realizar copias de seguridad de la base de datos o para ejecutar cualquier otra acción.
• Si un gran equipo de desarrolladores usa el mismo Makefile, esto organiza el trabajo en conjunto y reduce la cantidad de errores.

P.D. En nuestro en el marketplace hay una imagen Docker, que se instala con un solo clic. Puedes comprobar el funcionamiento de los contenedores en VPS. Todos los nuevos clientes tienen 3 días de prueba gratuita.

¡Estimados lectores! ¿Cómo automatizas el trabajo con Docker Compose?

Fuente: habr.com