Docker Compose: simplificando o trabalho com o uso de Makefile

A cada alguns anos, a indústria de desenvolvimento de software testemunha uma mudança de paradigma. Um dos fenômenos que podemos reconhecer é o aumento do interesse pela concepção de microsserviços. Embora os microsserviços não sejam uma tecnologia nova, sua popularidade disparou recentemente.

Grandes serviços monolíticos estão sendo substituídos atualmente por microsserviços autônomos independentes. Um microsserviço pode ser visto como um aplicativo que serve a um único propósito muito específico. Por exemplo, pode ser um banco de dados relacional, um aplicativo Express ou um serviço Solr.

Hoje em dia, é difícil imaginar o desenvolvimento de um novo sistema de software sem a utilização de microsserviços. Essa situação, por sua vez, nos leva à plataforma Docker.

Docker

Plataforma Docker, no desenvolvimento e implantação de microsserviços, tornou-se praticamente um padrão da indústria. No site do projeto, podemos descobrir que o Docker é a única plataforma de contêiner independente que permite que organizações criem quaisquer aplicativos sem grandes dificuldades, além de distribuí-los e executá-los em qualquer ambiente, desde nuvens híbridas até sistemas de borda.

Docker Compose

Tecnologia Docker Compose destina-se à configuração de aplicativos de múltiplos contêineres. Em um projeto Docker Compose, podem ser incluídos quantos contêineres Docker o criador do projeto achar necessário.

Ao trabalhar com o Docker Compose, um arquivo YAML é utilizado para configurar os serviços da aplicação e organizar sua interação entre si. O Docker Compose, assim, é uma ferramenta para descrever e executar aplicativos Docker de múltiplos contêineres.

Dois contêineres funcionando em um sistema host

GNU Make

O programa make, essencialmente, é uma ferramenta para automatizar a construção de programas e bibliotecas a partir do código-fonte. De maneira geral, podemos afirmar que make aplica-se a qualquer processo que implique a execução de comandos arbitrários para transformar certos materiais de entrada em um determinado resultado, a um certo objetivo. No nosso caso, os comandos docker-compose serão transformados em objetivos abstratos (Alvos Phony).

Para informar ao programa make o que queremos dele, precisaremos de um arquivo Makefile.

marketplace Makefile que conterá comandos normais docker e docker-compose, que são destinados a resolver uma série de tarefas. Ou seja, falamos sobre a montagem do container, o seu lançamento, parada, reinício, organização do login do usuário no container, gerenciamento dos logs do container e solução de outras tarefas semelhantes.

Casos de uso típicos do Docker Compose

Imaginemos um aplicativo da web comum, que possui os seguintes componentes:

• Banco de dados TimescaleDB (Postgres).
• Aplicativo Express.js.
• Ping (apenas um container que não faz nada especial).

Este aplicativo precisará de 3 containers Docker e de um arquivo docker-compose, contendo as instruções sobre como gerenciar esses containers. Cada um dos containers terá diferentes pontos de interação. Por exemplo, com o container timescale , será possível interagir de maneira semelhante ao gerenciamento de bancos de dados. Ou seja, ele permite realizar as seguintes ações:

• Acesso ao shell do Postgres.
• Importação e exportação de tabelas.
• Criar pg_dump tabelas ou bancos de dados.

O container do aplicativo Express.js, expressjs, pode ter as seguintes capacidades:

• Fornecimento de dados atualizados do log do sistema.
• Acesso ao shell para executar alguns comandos.

Interação com os containers

Depois que configuramos a comunicação entre os containers utilizando o Docker Compose, chegou a hora de estabelecer a interação com esses containers. No sistema Docker Compose, existe um comando docker-compose, que suporta a opção --follow, que permite passar para o sistema o arquivo docker-compose.yml.

Usando os recursos dessa opção, podemos limitar a interação com o sistema apenas aos containers mencionados no arquivo docker-compose.yml.

Vamos dar uma olhada em como as interações com os containers se parecem ao usar os comandos docker-compose. Se imaginarmos que precisamos acessar o shell psql, os comandos correspondentes podem ser assim:

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

O mesmo comando, que usa não docker-compose, e docker, pode ser assim:

docker exec -it edp_timescale_1 psql -Upostgres

Note que em tais casos é sempre preferível usar não o comando docker, mas sim o comando docker-compose, pois isso elimina a necessidade de lembrar os nomes dos containers.

Ambos os comandos mencionados acima não são tão difíceis. Mas se usássemos um "wrapper" como Makefile, que nos daria uma interface em forma de comandos simples e chamaria automaticamente comandos longos semelhantes, poderíamos alcançar os mesmos resultados assim:

make db-shell

É completamente óbvio que o uso de Makefile facilita significativamente o trabalho com contêineres!

Exemplo prático

Com base no esquema de projeto discutido acima, criaremos o seguinte arquivo 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 gerenciar a configuração do Docker Compose e interagir com os contêineres que ele descreve, criaremos o seguinte arquivo 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 maioria dos comandos descritos aqui se aplica a todos os contêineres, mas a opção c= permite restringir o alcance do comando a um único contêiner.

Depois que Makefile Está pronto, você pode usá-lo assim:

• make help — exibe uma lista de todos os comandos disponíveis para make.

Ajuda com os comandos disponíveis

• make build — construção da imagem a partir de Dockerfile. No nosso exemplo, usamos imagens existentes timescale e ping. Mas a imagem api que queremos construir localmente. É isso que será feito após a execução deste comando.

Construção do contêiner Docker

• make start — inicia todos os contêineres. Para iniciar apenas um contêiner, você pode usar um comando do tipo make start c=timescale.

Iniciar o contêiner timescale

Iniciar o contêiner ping

• make login-timescale — login na sessão bash do contêiner timescale.

Iniciar bash no contêiner timescale

• make db-shell — login em psql em um contêiner timescale para executar consultas SQL no banco de dados.

Iniciar psql no contêiner timescaledb

• make stop — parar contêineres.

Parar o contêiner timescale

• make down — parar e remover contêineres. Para remover um contêiner específico, você pode usar este comando especificando o contêiner necessário. Por exemplo — make down c=timescale ou make down c=api.

Parar e remover todos os contêineres

Resultados

Embora o sistema Docker Compose nos forneça um vasto conjunto de comandos para gerenciar contêineres, às vezes esses comandos se tornam longos, tornando difícil lembrar deles.

A metodologia de uso Makefile nos ajudou a estabelecer uma interação rápida e simples com os contêineres a partir do arquivo docker-compose.yml. Em particular, trata-se do seguinte:

• O desenvolvedor interage apenas com os contêineres do projeto, descritos em docker-compose.yml, sem interferência de outros contêineres em execução.
• No caso de alguma equipe ter esquecido um comando, pode-se executar o comando make help e obter ajuda sobre os comandos disponíveis.
• Não é necessário lembrar longas listas de argumentos para realizar ações como obter registros recentes do log ou fazer login. Por exemplo, um comando do tipo docker-compose -f docker-compose.yml exec timescale psql -Upostgres se transforma em make db-shell.
• Arquivo Makefile pode, à medida que o projeto cresce, ser ajustado de forma flexível. Por exemplo, é fácil adicionar um comando para criar um backup do banco de dados ou realizar qualquer outra ação.
• Se uma grande equipe de desenvolvedores usar o mesmo Makefile, isso organiza a colaboração e reduz o número de erros.

P.S. marketplace , há uma imagem , que é instalada com um clique. Você pode verificar o funcionamento dos contêineres em Docker. Todos os novos clientes recebem 3 dias grátis para testes. VPSVocê está utilizando tecnologias CI/CD em seus projetos?

Prezados leitores! Como você automatiza o trabalho com Docker Compose?

Fonte: habr.com