Docker Compose: Simplifique seu trabalho com Makefile

A cada poucos anos, a indústria de desenvolvimento de software passa por uma mudança de paradigma. Um desses fenômenos pode ser reconhecido como o crescente interesse pelo conceito de microsserviços. Embora os microsserviços não sejam a tecnologia mais recente, apenas recentemente sua popularidade literalmente disparou.

Grandes serviços monolíticos agora estão sendo substituídos por microsserviços autônomos independentes. Um microsserviço pode ser pensado como um aplicativo que atende a um propósito único e muito específico. Por exemplo, pode ser um DBMS relacional, um aplicativo Express, um serviço Solr.

Atualmente, é 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.

Estivador

Plataforma Estivador, no desenvolvimento e implantação de microsserviços, tornou-se quase o padrão da indústria. No site do projeto, você pode aprender que o Docker é a única plataforma de conteinerização independente que permite que as organizações criem facilmente qualquer aplicativo, bem como distribuam e executem em qualquer ambiente - de nuvens híbridas a sistemas de ponta.

Docker Compose

Технология Docker Compose projetado para configurar aplicativos de vários contêineres. Um projeto do Docker Compose pode ter quantos contêineres do Docker o criador desse projeto precisar.

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

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

GNU Make

Programa make, em essência, é uma ferramenta para automatizar a montagem de programas e bibliotecas a partir do código-fonte. Em geral, pode-se dizer que make aplicável a qualquer processo que envolva a execução de comandos arbitrários para transformar algum material de origem em algum resultado final, para algum propósito. No nosso caso, os comandos docker-compose serão convertidos em alvos abstratos (alvos falsos).

Para dizer ao programa make sobre o que queremos dela, precisamos de um arquivo Makefile.

В нашем Makefile conterá os comandos usuais docker и docker-compose, que são projetados para resolver uma variedade de problemas. Ou seja, estamos falando de montar um contêiner, iniciá-lo, pará-lo, reiniciá-lo, organizar a entrada do usuário no contêiner, trabalhar com logs do contêiner e resolver outras tarefas semelhantes.

Casos de uso típicos do Docker Compose

Imagine uma aplicação web típica que tenha os seguintes componentes:

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

Este aplicativo precisará de 3 contêineres do Docker e um arquivo docker-composeA contendo instruções para gerenciar esses contêineres. Cada um dos contêineres terá diferentes pontos de interação. Por exemplo, com um recipiente timescale será possível trabalhar aproximadamente o mesmo que trabalhar com bancos de dados. Ou seja, permite que você faça o seguinte:

• Faça login no shell do Postgres.
• Importação e exportação de tabelas.
• criação pg_dump tabelas ou bancos de dados.

contêiner de aplicativo Express.js, expressjs, pode ter as seguintes características:

• Emissão de novos dados do log do sistema.
• Entrando em um shell para executar determinados comandos.

Interação com contêineres

Agora que configuramos a comunicação entre os contêineres usando o Docker Compose, é hora de se comunicar com esses contêineres. Dentro do sistema Docker Compose, existe um comando docker-compose, suportando a opção -f, que permite transferir o 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.

Vamos dar uma olhada em como são as interações com contêineres ao usar comandos docker-compose. Se imaginarmos que precisamos entrar no shell psql, os comandos correspondentes podem ter esta aparência:

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

O mesmo comando, que não é usado para executar docker-composeE docker, pode ser assim:

docker exec -it  edp_timescale_1 psql -Upostgres

Observe que nesses casos é sempre preferível não usar o comando docker, e o comando docker-compose, pois 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 o "wrapper" na forma Makefile, que nos daria uma interface na forma de comandos simples e chamaria comandos longos, então os mesmos resultados poderiam ser alcançados assim:

make db-shell

É claro que o uso Makefile simplifica muito o trabalho com containers!

Exemplo de trabalho

Com base no esquema de projeto 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, vamos criar 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 usando o c= permite limitar o escopo do comando a um único contêiner.

Depois Makefile pronto, você pode usar assim:

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

Ajuda para os comandos disponíveis

• make build - construir uma imagem de Dockerfile. Em nosso exemplo, usamos imagens existentes timescale и ping. mas a imagem api queremos construir localmente. Isso é exatamente o que será feito após a execução deste comando.

Construindo um contêiner do Docker

• make start - iniciar todos os contêineres. Para executar apenas um contêiner, você pode usar um comando como make start c=timescale.

Executando o contêiner de escala de tempo

Executando um contêiner de ping

• make login-timescale - faça login na sessão bash do contêiner timescale.

Executando o bash em um contêiner de escala de tempo

• make db-shell - entrada para psql em um recipiente timescale para executar consultas SQL no banco de dados.

Executando o psql em um container timescaledb

• make stop - parar os recipientes.

Parando o contêiner de escala de tempo

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

Pare e exclua todos os contêineres

Resultados de

Embora o sistema Docker Compose nos forneça um rico conjunto de comandos para gerenciar contêineres, às vezes esses comandos se tornam longos e difíceis de lembrar como resultado.

Método de uso Makefile nos ajudou a estabelecer uma interação rápida e fácil com contêineres de um arquivo docker-compose.yml. Ou seja, estamos falando do seguinte:

• O desenvolvedor interage apenas com os contêineres do projeto descritos em docker-compose.yml, outros contêineres em execução não interferem no trabalho.
• No caso de um determinado comando ser esquecido, você pode executar o comando make help e obter ajuda sobre os comandos disponíveis.
• Você não precisa se lembrar de longas listas de argumentos para executar coisas como obter novas entradas de log ou fazer login. Por exemplo, um comando como docker-compose -f docker-compose.yml exec timescale psql -Upostgres se transforma em make db-shell.
• arquivo Makefile Você pode, à medida que o projeto cresce, ajustar-se de forma flexível a ele. Por exemplo, é fácil adicionar um comando a ele para criar um backup de banco de dados ou executar qualquer outra ação.
• Se uma grande equipe de desenvolvimento usar o mesmo Makefile, isso simplifica a colaboração e reduz os erros.

PS В нашем Mercado há uma imagem Estivador, que é instalado com um clique. Você pode verificar os contêineres funcionam VPS. Todos os novos clientes recebem 3 dias de testes gratuitos.

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

Fonte: habr.com