Como usar o Docker Compose para aplicativos com vários contêineres

O Compose simplifica o dimensionamento e a implantação de aplicativos no Docker automatizando o gerenciamento de contêineres **. Nosso tutorial dá uma olhada detalhada na configuração e no uso do Docker Compose para simplificar o processo de implantação de aplicativos.

O que é o Docker Compose?

O Docker Compose é usado para gerenciar aplicativos e aumentar a eficiência no desenvolvimento de contêineres. As configurações são definidas em um único arquivo YAML, facilitando a criação e o dimensionamento dos aplicativos. O Docker Compose é frequentemente usado para configurar um ambiente local. No entanto, ele também pode fazer parte de um fluxo de trabalho de integração contínua/entrega contínua. Os desenvolvedores podem definir uma versão específica do contêiner para testes ou fases específicas do pipeline. Isso facilita a identificação de problemas e a correção de bugs antes que o aplicativo entre em produção.

Requisitos do Docker Compose

Para a orquestração de contêineres, você precisa do Docker Engine e do Docker Compose. Verifique se você tem um dos seguintes itens instalados em seu sistema:

• Docker Engine e Docker Compose: Podem ser instalados como binários autônomos.
• Docker Desktop: Ambiente de desenvolvimento com interface gráfica de usuário, incluindo o Docker Engine e o Docker Compose.

Guia passo a passo de como usar o Docker Compose

A seguir, demonstramos como usar o Docker Compose com um aplicativo Web Python simples **que utiliza um contador de ocorrências. Para fazer isso, usamos a estrutura Python Flask e o banco de dados Redis na memória. Não é necessário instalar o Python ou o Redis, pois eles são fornecidos como imagens do Docker.

Etapa 1: criar arquivos de projeto

Inicie o terminal e crie uma nova pasta para o projeto.

$ mkdir composedemo

Mude para o diretório.

$ cd composedemo

Crie o arquivo app.py nessa pasta e adicione o seguinte código a ele:

import time
import redis
from flask import Flask
app = Flask(__name__)
cache = redis.Redis(host='redis', port=6379)
def get_hit_count():
    retries = 5
    while True:
        try:
            return cache.incr('hits')
        except redis.exceptions.ConnectionError as exc:
            if retries == 0:
                raise exc
            retries -= 1
            time.sleep(0.5)
@app.route('/')
def hello():
    count = get_hit_count()
    return 'Hello World! I was here {} times.\n'.format(count)

Em nossa configuração, utilizamos redis como o nome do host e a porta padrão 6379 para a conexão com o serviço Redis. Além disso, especificamos que a função get_hit_count() deve fazer várias tentativas de conexão com o serviço. Isso é recomendado quando o Redis pode não estar imediatamente disponível quando o aplicativo é iniciado ou quando pode haver problemas de conexão intermitentes durante o tempo de execução.

Crie o arquivo requirements.txt com as dependências:

flask
redis

Etapa 2: configurar o Dockerfile

O Dockerfile é usado para a imagem do Docker. Isso especifica todas as dependências que o aplicativo Python requer.

# syntax=docker/dockerfile:1
FROM python:3.7-alpine
WORKDIR /code
ENV FLASK_APP=app.py
ENV FLASK_RUN_HOST=0.0.0.0
RUN apk add --no-cache gcc musl-dev linux-headers
COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt
EXPOSE 5000
COPY . .
CMD ["flask", "run"]

Instruímos o Docker a utilizar a imagem do Python 3.7. Além disso, definimos as variáveis de ambiente necessárias para o comando flask. Ao usar o apk add, instalamos dependências essenciais, inclusive o gcc. Para permitir que o contêiner monitore a porta 5000, especificamos EXPOSE. Usando COPY, transferimos o conteúdo da pasta atual para o diretório de trabalho /code dentro do contêiner. Por fim, como comando padrão para o contêiner, escolhemos flask run.

Verifique se o Dockerfile foi salvo sem uma extensão de arquivo, pois alguns editores acrescentam automaticamente o sufixo .txt .

Etapa 3: criar arquivo YAML

Em docker-compose.yml configuramos os serviços “redis” e “web”.

version: "3.9"
services:
    web:
        build: .
        ports:
            - "8000:5000"
    redis:
        image: "redis:alpine"

O serviço da Web é criado usando a imagem do Docker criada pelo Dockerfile. Ele associa o contêiner e o computador host à porta 8000, enquanto o servidor da Web do Flask é executado na porta 5000. A imagem do Redis, por outro lado, é obtida diretamente do Docker Hub oficial.

Etapa 4: executar o aplicativo com o Compose

Inicie o aplicativo na pasta do seu projeto.

docker compose up

Acesse http://localhost:8000 em seu navegador. Você também pode entrar em http://127.0.0.1:8000.

Você verá a seguinte mensagem:

Atualize a página. O número de visualizações agora deve ter aumentado em 1.

Interrompa o aplicativo usando:

$ docker compose down

Para interromper a execução do aplicativo, basta pressionar Ctrl + C no terminal.

Etapa 5: adicionar uma montagem bind

Se quiser adicionar um bind mount para o serviço da Web, você poderá fazer isso em docker-compose.yml.

version: "3.9"
services:
    web:
        build: .
        ports:
            - "8000:5000"
        volumes:
            - .:/code
        environment:
            FLASK_DEBUG: "true"
    redis:
        image: "redis:alpine"

Na seção Volumes , especificamos a anexação da pasta do projeto atual ao diretório /code dentro do contêiner. Isso permite alterações contínuas no código sem a necessidade de recriar a imagem. A variável FLASK_DEBUG diz flask run para ser executada no modo de desenvolvimento.

Etapa 6: Reconstruir e executar o aplicativo

Digite o seguinte comando no terminal para reconstruir o arquivo Compose:

docker compose up

Etapa 7: Atualizar o aplicativo

Agora que você está usando um bind mount para seu aplicativo, pode modificar seu código e ver automaticamente as alterações sem reconstruir a imagem.

Escreva um novo teste de boas-vindas em app.py.

return 'Hello from Docker! I was here {} times.\n'.format(count)

Atualize o navegador para testar se as alterações foram aplicadas.

Etapa 8: outros comandos

A opção --help lista os comandos disponíveis do Docker Compose:

docker compose --help

Para executar o Docker Compose em segundo plano, você pode adicionar o argumento -d :

docker compose up -d

Use down para remover todos os contêineres. A opção --volumes exclui os volumes usados pelo contêiner Redis.

docker compose down --volumes