💆🏼 👨🏻‍🚒 🎑 Docker Compose: Simplifique usando Makefile 🧑🏾‍🤝‍🧑🏼 👎🏿 🦖

A cada poucos anos, uma mudança de paradigma ocorre na indústria de desenvolvimento de software. Um desses fenômenos é o crescente interesse no conceito de microsserviços. Embora os microsserviços não sejam a tecnologia mais recente, apenas recentemente sua popularidade disparou literalmente.

Atualmente, grandes serviços monolíticos são substituídos por microsserviços autônomos independentes. Um microsserviço pode ser considerado como um aplicativo que serve a um propósito único e muito específico. Por exemplo, pode ser um DBMS relacional, aplicativo Express, serviço Solr. Hoje em dia é difícil imaginar o desenvolvimento de um novo sistema de software sem o uso de microsserviços. E essa situação, por sua vez, nos leva à plataforma Docker.

Docker

A plataforma Docker , no desenvolvimento e implantação de microsserviços, tornou-se quase um padrão do setor. No site do projeto, você pode descobrir que o Docker é a única plataforma de contêiner independente que permite que as organizações criem sem esforço qualquer aplicativo, além de distribuí-lo e executá-lo em qualquer ambiente - de nuvens híbridas a sistemas de fronteira.

Docker compor

A tecnologia Docker Compose foi projetada para configurar aplicativos com vários contêineres. Um projeto do Docker Compose pode incluir quantos contêineres do Docker forem necessários para o criador deste projeto.

Ao trabalhar com o Docker Compose, um arquivo YAML é usado para configurar serviços de aplicativos e organizar sua interação. O Docker Compose é, portanto, uma ferramenta para descrever e executar aplicativos Docker com vários contêineres.

Dois contêineres em execução no sistema host

GNU Make

Um programa makeé essencialmente uma ferramenta para automatizar a montagem de programas e bibliotecas a partir do código fonte. Em geral, podemos dizer que é makeaplicável a qualquer processo que inclua a execução de comandos arbitrários para converter determinados materiais de origem em uma determinada forma resultante, em um determinado objetivo. No nosso caso, as equipes docker-composeserão convertidas em objetivos abstratos ( alvos falsos ).

Para dizer ao programa makeo que queremos dele, precisamos de um arquivo Makefile.

Os nossos Makefileconterão os comandos usuais dockeredocker-composeque são projetados para resolver muitos problemas. Ou seja, estamos falando sobre a montagem do contêiner, sobre como iniciá-lo, parar, reiniciar, organizar o logon do usuário no contêiner, trabalhar com logs do contêiner e resolver outros problemas semelhantes.

Usos típicos do Docker Compose

Imagine um aplicativo Web regular que possua os seguintes componentes:

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

Esse aplicativo precisará de três contêineres do Docker e um arquivo docker-composecontendo instruções para gerenciar esses contêineres. Cada um dos contêineres terá diferentes pontos de interação. Por exemplo, timescalevocê pode trabalhar com um contêiner da mesma maneira que trabalha com bancos de dados. Ou seja, permite executar as seguintes ações:

Entre no shell do Postgres.
Importar e exportar tabelas.
Crie uma pg_dumptabela ou banco de dados.

O contêiner de um aplicativo Express.js ,, expressjspode ter os seguintes recursos:

A saída de dados atualizados do log do sistema.
Digite o shell para executar determinados comandos.

Interação de contêiner

Depois de configurar a conexão entre os contêineres usando o Docker Compose, é hora de estabelecer interação com esses contêineres. Como parte do sistema Docker Compose, há um comando docker-composeque suporta uma opção -fque permite transferir um arquivo para o sistema docker-compose.yml.

Usando os recursos desta opção, você pode limitar a interação com o sistema apenas para os contêineres mencionados no arquivo docker-compose.yml.

Veja como são as interações do contêiner ao usar comandos docker-compose. Se imaginarmos que precisamos entrar no shell psql, os comandos correspondentes podem ser assim:

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

O mesmo comando para o qual não docker-compose, mas é usado docker, pode se parecer com isso:

docker exec -it  edp_timescale_1 psql -Upostgres

Observe que, nesses casos, é sempre preferível usar não um comando docker, mas um comando docker-compose, pois isso elimina a necessidade de lembrar os nomes dos contêineres.

Ambos os comandos acima não são tão complicados. Mas se usássemos um "wrapper" de uma forma Makefileque nos desse uma interface na forma de comandos simples e chamasse comandos tão longos, então os mesmos resultados poderiam ser alcançados assim:

make db-shell

É óbvio que o uso Makefilesimplifica bastante o trabalho com contêineres!

Exemplo de trabalho

Com base no diagrama do projeto acima, crie 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 descritos, crie 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 o uso da opção c=permite limitar o escopo do comando a um contêiner.

Depois de Makefilepronto, você pode usá-lo assim:

make help- emitindo uma lista de todos os comandos disponíveis para make.

Ajuda de comandos disponíveis

make build- montagem da imagem de Dockerfile. No nosso exemplo, usamos imagens timescalee ping. Mas apiqueremos coletar a imagem localmente. Isso é exatamente o que será feito após a execução deste comando.

Montagem de contêiner do Docker

make start- lançamento de todos os contêineres. Para iniciar apenas um contêiner, você pode usar o comando do formulário make start c=timescale.

Iniciar contêiner de escala de tempo

Iniciar o contêiner de ping

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

Executando o bash no contêiner de escala de tempo

make db-shell- Efetue login no psqlcontêiner timescalepara executar consultas SQL no banco de dados.

Executando psql no contêiner timescaledb

make stop - parar recipientes.

Parando o contêiner da escala de tempo

make down- pare e remova os recipientes. Para excluir um contêiner específico, você pode usar este comando com o contêiner especificado. Por exemplo - make down c=timescaleou make down c=api.

Pare e exclua todos os contêineres

Sumário

Apesar do sistema Docker Compose nos fornecer um conjunto extenso de comandos projetados para gerenciar contêineres, algumas vezes esses comandos se tornam longos e, como resultado, podem ser difíceis de lembrar.

A metodologia de uso Makefilenos ajudou a estabelecer uma interação rápida e fácil com os contêineres do arquivo docker-compose.yml. Ou seja, estamos falando sobre o seguinte:

, docker-compose.yml, .
, , make help .
, . , docker-compose -f docker-compose.yml exec timescale psql -Upostgres make db-shell.
Makefile , , . , .
Makefile, .

PS No nosso mercado, há uma imagem do Docker , instalada em um clique. Você pode verificar a operação de contêineres no VPS . Todos os novos clientes recebem 3 dias gratuitamente para testes.

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

Docker Compose: Simplifique usando Makefile