O Compose sim­pli­fica o di­men­si­o­na­mento e a im­plan­ta­ção de apli­ca­ti­vos no Docker au­to­ma­ti­zando o ge­ren­ci­a­mento de con­têi­ne­res **. Nosso tutorial dá uma olhada detalhada na con­fi­gu­ra­ção e no uso do Docker Compose para sim­pli­fi­car o processo de im­plan­ta­ção de apli­ca­ti­vos.

O que é o Docker Compose?

O Docker Compose é usado para gerenciar apli­ca­ti­vos e aumentar a efi­ci­ên­cia no de­sen­vol­vi­mento de con­têi­ne­res. As con­fi­gu­ra­ções são definidas em um único arquivo YAML, fa­ci­li­tando a criação e o di­men­si­o­na­mento dos apli­ca­ti­vos. O Docker Compose é fre­quen­te­mente usado para con­fi­gu­rar um ambiente local. No entanto, ele também pode fazer parte de um fluxo de trabalho de in­te­gra­ção contínua/entrega contínua. Os de­sen­vol­ve­do­res podem definir uma versão es­pe­cí­fica do contêiner para testes ou fases es­pe­cí­fi­cas do pipeline. Isso facilita a iden­ti­fi­ca­ção de problemas e a correção de bugs antes que o apli­ca­tivo entre em produção.

Re­qui­si­tos do Docker Compose

Para a or­ques­tra­ção de con­têi­ne­res, você precisa do Docker Engine e do Docker Compose. Verifique se você tem um dos seguintes itens ins­ta­la­dos em seu sistema:

  • Docker Engine e Docker Compose: Podem ser ins­ta­la­dos como binários autônomos.
  • Docker Desktop: Ambiente de de­sen­vol­vi­mento com interface gráfica de usuário, incluindo o Docker Engine e o Docker Compose.
Dica

Descubra como instalar o Docker Compose em di­fe­ren­tes sistemas ope­ra­ci­o­nais em nossos tutoriais:

Guia passo a passo de como usar o Docker Compose

A seguir, de­mons­tra­mos como usar o Docker Compose com um apli­ca­tivo Web Python simples **que utiliza um contador de ocor­rên­cias. Para fazer isso, usamos a estrutura Python Flask e o banco de dados Redis na memória. Não é ne­ces­sá­rio instalar o Python ou o Redis, pois eles são for­ne­ci­dos como imagens do Docker.

Etapa 1: criar arquivos de projeto

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

$ mkdir composedemo
shell

Mude para o diretório.

$ cd composedemo
shell

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)
python

Em nossa con­fi­gu­ra­ção, uti­li­za­mos redis como o nome do host e a porta padrão 6379 para a conexão com o serviço Redis. Além disso, es­pe­ci­fi­ca­mos que a função get_hit_count() deve fazer várias ten­ta­ti­vas de conexão com o serviço. Isso é re­co­men­dado quando o Redis pode não estar ime­di­a­ta­mente dis­po­ní­vel quando o apli­ca­tivo é iniciado ou quando pode haver problemas de conexão in­ter­mi­ten­tes durante o tempo de execução.

Crie o arquivo re­qui­re­ments.txt com as de­pen­dên­cias:

flask
redis
plaintext

Etapa 2: con­fi­gu­rar o Doc­ker­file

O Doc­ker­file é usado para a imagem do Docker. Isso es­pe­ci­fica todas as de­pen­dên­cias que o apli­ca­tivo 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"]
shell

Ins­truí­mos o Docker a utilizar a imagem do Python 3.7. Além disso, definimos as variáveis de ambiente ne­ces­sá­rias para o comando flask. Ao usar o apk add, ins­ta­la­mos de­pen­dên­cias es­sen­ci­ais, inclusive o gcc. Para permitir que o contêiner monitore a porta 5000, es­pe­ci­fi­ca­mos EXPOSE. Usando COPY, trans­fe­ri­mos 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, es­co­lhe­mos flask run.

Verifique se o Doc­ker­file foi salvo sem uma extensão de arquivo, pois alguns editores acres­cen­tam au­to­ma­ti­ca­mente o sufixo .txt .

Etapa 3: criar arquivo YAML

Em docker-compose.yml con­fi­gu­ra­mos os serviços “redis” e “web”.

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

O serviço da Web é criado usando a imagem do Docker criada pelo Doc­ker­file. Ele associa o contêiner e o com­pu­ta­dor host à porta 8000, enquanto o servidor da Web do Flask é executado na porta 5000. A imagem do Redis, por outro lado, é obtida di­re­ta­mente do Docker Hub oficial.

Etapa 4: executar o apli­ca­tivo com o Compose

Inicie o apli­ca­tivo na pasta do seu projeto.

docker compose up
shell

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

Você verá a seguinte mensagem:

Imagem: Docker Compose Application: Output the number of visits in the browser
Você verá o número de vezes que visitou o navegador.

Atualize a página. O número de vi­su­a­li­za­ções agora deve ter aumentado em 1.

Imagem: Chamando o aplicativo Docker Compose novamente
O número de visitas aumentou em 1.

In­ter­rompa o apli­ca­tivo usando:

$ docker compose down
shell

Para in­ter­rom­per a execução do apli­ca­tivo, basta pres­si­o­nar 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"
yaml

Na seção Volumes , es­pe­ci­fi­ca­mos a anexação da pasta do projeto atual ao diretório /code dentro do contêiner. Isso permite al­te­ra­ções contínuas no código sem a ne­ces­si­dade de recriar a imagem. A variável FLASK_DEBUG diz flask run para ser executada no modo de de­sen­vol­vi­mento.

Etapa 6: Re­cons­truir e executar o apli­ca­tivo

Digite o seguinte comando no terminal para re­cons­truir o arquivo Compose:

docker compose up
shell

Etapa 7: Atualizar o apli­ca­tivo

Agora que você está usando um bind mount para seu apli­ca­tivo, pode modificar seu código e ver au­to­ma­ti­ca­mente as al­te­ra­ções sem re­cons­truir a imagem.

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

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

Atualize o navegador para testar se as al­te­ra­ções foram aplicadas.

Imagem: Aplicativo Docker Compose: texto de boas-vindas modificado
O texto de boas-vindas no apli­ca­tivo Python foi mo­di­fi­cado

Etapa 8: outros comandos

A opção --help lista os comandos dis­po­ní­veis do Docker Compose:

docker compose --help
shell

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

docker compose up -d
shell

Use down para remover todos os con­têi­ne­res. A opção --volumes exclui os volumes usados pelo contêiner Redis.

docker compose down --volumes
shell
Ir para o menu principal