# 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.

Dica Descubra como instalar o Docker Compose em diferentes sistemas operacionais em nossos tutoriais:

- [Instalar o Docker Compose no Ubuntu](https://www.ionos.com/pt-br/digitalguide/servidor/configuracao/docker-compose-no-ubuntu/)
- [Instalar o Docker Compose no macOS](https://www.ionos.com/pt-br/digitalguide/servidor/configuracao/docker-compose-no-mac/)
- [Instalar o Docker Compose no Windows](https://www.ionos.com/pt-br/digitalguide/servidor/configuracao/instalar-o-docker-compose-no-windows/)

## 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.

```shell
$ mkdir composedemo
```

Mude para o diretório.

```shell
$ cd composedemo
```

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

```python
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:

```plaintext
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.

```shell
# 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”.

```yaml
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.

```shell
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:

[![Imagem: Docker Compose Application: Output the number of visits in the browser](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/d/1/csm_docker-compose-hit-counter_f6e8af7148.webp "Docker Compose Application: Output the number of visits in the browser")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/docker-compose-hit-counter.png) Você verá o número de vezes que visitou o navegador. Atualize a página. O número de visualizações agora deve ter aumentado em 1.

[![Imagem: Chamando o aplicativo Docker Compose novamente](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/7/8/csm_docker-compose-hit-counter-updated_58c6be39f6.webp "Chamando o aplicativo Docker Compose novamente")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/docker-compose-hit-counter-updated.png) O número de visitas aumentou em 1. Interrompa o aplicativo usando:

```shell
$ 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*.

```yaml
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:

```shell
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***.

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

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

[![Imagem: Aplicativo Docker Compose: texto de boas-vindas modificado](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/9/3/csm_docker-compose-hit-counter-text-modified_a210964afe.webp "Aplicativo Docker Compose: texto de boas-vindas modificado")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/docker-compose-hit-counter-text-modified.png) O texto de boas-vindas no aplicativo Python foi modificado ### Etapa 8: outros comandos

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

```shell
docker compose --help
```

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

```shell
docker compose up -d
```

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

```shell
docker compose down --volumes
```

Dica Para começar a usar o Docker, confira nosso [Tutorial do Docker](https://www.ionos.com/pt-br/digitalguide/servidor/configuracao/tutorial-docker/) e nossa visão geral dos Comandos do Docker.


This is a markdown version of: [https://www.ionos.com/pt-br/digitalguide/servidor/configuracao/tutorial-do-docker-compose/](https://www.ionos.com/pt-br/digitalguide/servidor/configuracao/tutorial-do-docker-compose/) for AI/LLM consumption.