Docker Compose

Docker Compose é uma ferramenta poderosa que simplifica a definição e a execução de aplicações multi-contêiner Docker, permitindo que desenvolvedores orquestrem e gerenciem facilmente ambientes complexos. Utilizando um único arquivo de configuração em YAML, conhecido como docker-compose.yml, os usuários podem especificar todos os serviços que compõem sua aplicação, incluindo imagens, variáveis de ambiente, volumes e redes. Isso facilita o desenvolvimento, teste e implantação, pois o Docker Compose permite iniciar todos os contêineres com um único comando (docker compose up), garantindo que todos os serviços necessários sejam configurados e executados de forma coerente. Além disso, a capacidade de escalar serviços, compartilhar configurações entre ambientes e integrar com ferramentas de CI/CD torna o Docker Compose uma escolha popular em fluxos de trabalho modernos de desenvolvimento de software.

Conceitos Fundamentais

1. Definição

Docker Compose é uma ferramenta que permite definir e executar aplicações Docker compostas por múltiplos contêineres. Ele utiliza um arquivo de configuração (geralmente chamado de docker-compose.yml) onde você descreve os serviços que compõem sua aplicação.

2. Arquivo `docker-compose.yml`

O arquivo docker-compose.yml é onde você define todos os serviços, redes e volumes necessários para sua aplicação. A sintaxe é baseada em YAML, o que torna a configuração bastante legível.

Estrutura Básica do `docker-compose.yml`

services:     # Definição dos serviços
  web:        # Nome do serviço
    image: nginx:latest  # Imagem a ser utilizada
    ports:
      - "80:80"  # Mapeamento de portas
  db:         # Outro serviço (banco de dados)
    image: postgres:latest
    environment:  # Variáveis de ambiente
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password

Principais Componentes

1. Serviços

Cada serviço no docker-compose.yml representa um contêiner. Você pode especificar a imagem a ser usada, configurações de rede, variáveis de ambiente, volumes e muito mais.

2. Redes

O Compose cria uma rede padrão para os serviços se comunicarem entre si. Você pode personalizar redes, permitindo que serviços em diferentes redes se comuniquem ou isolem serviços conforme necessário.

3. Volumes

Volumes permitem que você persista dados gerados por contêineres. Eles são armazenados fora do ciclo de vida do contêiner, garantindo que os dados não sejam perdidos quando um contêiner é removido ou atualizado.

Comandos Principais do Docker Compose

1. `docker compose up`

Este comando cria e inicia todos os serviços definidos no arquivo docker-compose.yml.
Exemplo:
```
docker compose up
```

2. `docker compose down`

Para de todos os serviços e remove os contêineres, redes e volumes associados.
Exemplo:
```
docker compose down
```

3. `docker compose build`

Este comando constrói ou reconstrói os serviços definidos no Compose file.
Exemplo:
```
docker compose build
```

4. `docker compose logs`

Mostra os logs de todos os serviços em execução, permitindo que você monitore a saída dos contêineres.
Exemplo:
```
docker compose logs
```

5. `docker compose exec`

Permite que você execute comandos em um contêiner em execução.
Exemplo:
```
docker compose exec web bash
```

Vantagens do Docker Compose

1. Simplicidade

O Docker Compose simplifica o gerenciamento de aplicações multi-contêiner, permitindo que você defina todos os serviços em um único arquivo de configuração.

2. Consistência

A configuração da aplicação pode ser facilmente compartilhada entre diferentes ambientes (desenvolvimento, teste, produção), garantindo que todos estejam usando a mesma configuração.

3. Facilidade de Uso

Docker Compose fornece uma interface de linha de comando intuitiva que torna fácil iniciar, parar e gerenciar aplicações complexas.

4. Orquestração

Embora o Docker Compose não seja uma ferramenta de orquestração completa como o Kubernetes, ele fornece funcionalidades básicas de orquestração para aplicações que não exigem a complexidade de uma solução mais robusta.

Exemplo de Docker Compose para o Projeto

Abaixo está um exemplo de como o Docker Compose é utilizado no nosso projeto para orquestrar os microserviços:

services:
  db:
    image: postgres:latest
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: root
      POSTGRES_DB: feedback
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data

  usermanagement:
    build:
      context: ./java_backend
      args:
        APP_NAME: usermanagement
    environment:
      - DB_HOST=db
      - DB_PORT=5432
      - DB_USER=postgres
      - DB_PASS=root
      - JWT_SECRET_KEY=4Z^XrroxR@dWxqf$!@#qGr4P
      - JWT_ISSUER=user-api
    depends_on:
      - db

  feedbackrequest:
    build:
      context: ./java_backend
      args:
        APP_NAME: feedbackrequest
    environment:
      - DB_HOST=db
      - DB_PORT=5432
      - DB_USER=postgres
      - DB_PASS=root
      - JWT_SECRET_KEY=4Z^XrroxR@dWxqf$!@#qGr4P
      - JWT_ISSUER=user-api
    depends_on:
      - db

  feedbackresponse:
    build:
      context: ./java_backend
      args:
        APP_NAME: feedbackresponse
    environment:
      - DB_HOST=db
      - DB_PORT=5432
      - DB_USER=postgres
      - DB_PASS=root
      - JWT_SECRET_KEY=4Z^XrroxR@dWxqf$!@#qGr4P
      - JWT_ISSUER=user-api
    depends_on:
      - db

  feedbackresponseview:
    build:
      context: ./python_backend
      args:
        APP_NAME: feedbackresponseview
    environment:
      - DATABASE_URL=postgresql://postgres:root@db:5432/feedback
    depends_on:
      - db

  nginx:
    image: nginx:alpine
    volumes:
      - ./gateway/nginx.conf:/etc/nginx/conf.d/default.conf
    ports:
      - "80:80"
    depends_on:
      - usermanagement
      - feedbackrequest
      - feedbackresponse
      - feedbackresponseview

volumes:
  postgres_data:

Este arquivo Docker Compose define:

Um serviço de banco de dados PostgreSQL
Quatro microserviços (usermanagement, feedbackrequest, feedbackresponse, feedbackresponseview)
Um serviço Nginx como API Gateway
Um volume para persistir os dados do PostgreSQL

Cada serviço tem suas próprias configurações, como variáveis de ambiente, dependências e mapeamentos de porta. O Docker Compose gerencia a criação, inicialização e interconexão desses serviços, permitindo que a aplicação completa seja executada com um único comando.

Conclusão

Docker Compose é uma ferramenta essencial para o desenvolvimento e implantação de aplicações baseadas em microserviços. Ele simplifica significativamente o processo de configuração e gerenciamento de múltiplos contêineres, permitindo que os desenvolvedores se concentrem mais na lógica de negócios e menos na infraestrutura.

No contexto do nosso projeto, o Docker Compose permite que todos os microserviços, o banco de dados e o API Gateway sejam configurados e executados de forma consistente em qualquer ambiente, facilitando o desenvolvimento, teste e implantação da aplicação.