Docker Compose: simplificando o seu traballo usando Makefiles

Cada poucos anos, a industria do desenvolvemento de software sofre un cambio de paradigma. Un destes fenómenos pódese recoñecer como o crecente interese polo concepto de microservizos. Aínda que os microservizos non son a tecnoloxía máis nova, só recentemente disparouse a súa popularidade literalmente.

Os grandes servizos monolíticos están sendo substituídos por microservizos independentes e autónomos. Un microservizo pódese pensar como unha aplicación que ten un propósito único e moi específico. Por exemplo, podería ser un DBMS relacional, unha aplicación Express, un servizo Solr.

Nestes días, é difícil imaxinar desenvolver un novo sistema de software sen utilizar microservizos. E esta situación, á súa vez, lévanos á plataforma Docker.

Estivador

Plataforma Estivador, no desenvolvemento e despregamento de microservizos, converteuse case nun estándar da industria. No sitio web do proxecto podes descubrir que Docker é a única plataforma de contenedores independente que permite ás organizacións crear sen esforzo calquera aplicación, así como distribuílas e executalas en calquera ambiente, desde nubes híbridas ata sistemas de borde.

Docker Compose

Технология Docker Compose deseñado para configurar aplicacións multicontedor. Un proxecto Docker Compose pode conter tantos contedores Docker como necesite o creador do proxecto.

Cando se traballa con Docker Compose, utilízase un ficheiro YAML para configurar os servizos de aplicacións e organizar a súa interacción entre si. Docker Compose é, polo tanto, unha ferramenta para describir e executar aplicacións Docker con varios contedores.

Dous contedores en execución nun sistema host

GNU Make

Programa make, é esencialmente unha ferramenta para automatizar a construción de programas e bibliotecas a partir do código fonte. En xeral, podemos dicir que make aplícase a calquera proceso que implique executar comandos arbitrarios para transformar algúns materiais de entrada nunha forma de saída con algún propósito. No noso caso, os comandos docker-compose transformaranse en obxectivos abstractos (Obxectivos telefónicos).

Para contar o programa make sobre o que queremos del, necesitamos un ficheiro Makefile.

No noso Makefile conterá comandos habituais docker и docker-compose, que están deseñados para resolver moitos problemas. É dicir, estamos a falar de montar un contedor, de inicialo, detelo, reinicialo, de organizar o inicio de sesión do usuario no contenedor, de traballar cos rexistros de contedores e de resolver outros problemas similares.

Casos de uso típicos de Docker Compose

Imaxinemos unha aplicación web normal que teña os seguintes compoñentes:

• Base de datos TimescaleDB (Postgres).
• Aplicación Express.js.
• Ping (só un recipiente, non fai nada especial).

Esta aplicación necesitará 3 contedores Docker e un ficheiro docker-compose, que contén instrucións para xestionar estes contedores. Cada recipiente terá diferentes puntos de contacto. Por exemplo, cun recipiente timescale será posible traballar aproximadamente do mesmo xeito que funcionan coas bases de datos. É dicir, permítelle realizar as seguintes accións:

• Iniciando sesión no shell de Postgres.
• Importación e exportación de táboas.
• creación pg_dump táboas ou bases de datos.

contenedor de aplicacións Express.js, expressjs, pode ter as seguintes capacidades:

• Proporcionando datos novos do rexistro do sistema.
• Inicie sesión no shell para executar determinados comandos.

Interactuar con Containers

Unha vez que configuramos a comunicación entre contedores mediante Docker Compose, é hora de comunicarnos con eses contedores. Dentro do sistema Docker Compose hai un comando docker-compose, opción de apoio -f, que permite transferir un ficheiro ao sistema docker-compose.yml.

Usando as capacidades desta opción, pode limitar a interacción co sistema só aos contedores que se mencionan no ficheiro docker-compose.yml.

Vexamos como son as interaccións cos contedores cando se usan comandos docker-compose. Se imaxinamos que necesitamos iniciar sesión no shell psql, entón os comandos correspondentes poden verse así:

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

O mesmo comando que non se utiliza para executar docker-composeE docker, pode verse así:

docker exec -it  edp_timescale_1 psql -Upostgres

Teña en conta que nestes casos sempre é preferible utilizar o comando docker, e o equipo docker-compose, xa que isto elimina a necesidade de lembrar os nomes dos contedores.

Os dous comandos anteriores non son tan difíciles. Pero se usamos un "envoltorio" no formulario Makefile, que nos daría unha interface en forma de comandos simples e que el mesmo chamaría comandos longos similares, entón os mesmos resultados poderían conseguirse así:

make db-shell

É bastante obvio que o uso Makefile facilita moito o traballo con contedores!

Exemplo de traballo

Baseándonos no diagrama do proxecto anterior, crearemos o seguinte ficheiro 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 xestionar a configuración de Docker Compose e interactuar cos contedores que describe, crearemos o seguinte ficheiro 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

A maioría dos comandos descritos aquí aplícanse a todos os contedores, pero usando a opción c= permítelle limitar o alcance dun comando a un contedor.

Despois Makefile listo, podes usalo así:

• make help — emitir unha lista de todos os comandos dispoñibles para make.

Axuda sobre os comandos dispoñibles

• make build - Montaxe dunha imaxe a partir Dockerfile. No noso exemplo usamos imaxes existentes timescale и ping. Pero a imaxe api queremos recoller localmente. Isto é exactamente o que se fará despois de executar este comando.

Construír un contedor Docker

• make start - Lanzamento de todos os contedores. Para lanzar só un contedor, pode usar un comando como make start c=timescale.

Execución do contedor de escala temporal

Execución dun contedor de ping

• make login-timescale — inicie sesión na sesión bash do contedor timescale.

Execución de bash nun contedor de escala temporal

• make db-shell - entrada a psql nun recipiente timescale para executar consultas SQL contra a base de datos.

Execución de psql nun contenedor timescaledb

• make stop - detención de contedores.

Parando un contedor de escala temporal

• make down - Parar e retirar os envases. Para eliminar un contedor específico, pode usar este comando especificando o contedor desexado. Por exemplo - make down c=timescale ou make down c=api.

Deter e eliminar todos os contedores

Resultados de

Aínda que Docker Compose ofrécenos un rico conxunto de comandos para xestionar contedores, ás veces estes comandos poden facerse longos e difíciles de lembrar.

Método de uso Makefile axudounos a establecer unha interacción rápida e sinxela cos contedores dun ficheiro docker-compose.yml. É dicir, estamos a falar do seguinte:

• O programador interactúa só cos contedores do proxecto descritos en docker-compose.yml, o traballo non é interferido por outros contedores en funcionamento.
• No caso de que se esqueza un determinado comando, pode executalo make help e obtén axuda sobre os comandos dispoñibles.
• Non tes que lembrar longas listas de argumentos para realizar accións como obter as últimas entradas de rexistro ou iniciar sesión nun sistema. Por exemplo, un comando como docker-compose -f docker-compose.yml exec timescale psql -Upostgres convértese en make db-shell.
• arquivo Makefile Pódese adaptar a el de forma flexible a medida que o proxecto vaia crecendo. Por exemplo, é fácil engadir un comando para crear unha copia de seguridade da base de datos ou realizar calquera outra acción.
• Se un gran equipo de desenvolvedores usa o mesmo Makefile, isto simplifica a colaboración e reduce os erros.

PS No noso mercado hai unha imaxe Estivador, que se pode instalar cun só clic. Podes consultar o funcionamento dos contedores en Estudantes. Todos os novos clientes reciben 3 días de probas de balde.

Queridos lectores! Como se automatiza Docker Compose?

Fonte: www.habr.com