Pular para conteúdo

d. Containerização

Como vimos no hands-on anterior, os microsserviços são implementados como aplicações Spring Boot. Para executá-los, precisamos preparar o ambiente instalando o banco de dados que vai persistir os dados. Para isso, vamos usar um arquivo Docker Compose para criar um container PostgreSQL, bem como um cluster que isola os microsserviços do acesso externo, criando um ambiente seguro — a camada confiável (trusted layer).

Um arquivo Docker Compose é um arquivo YAML que define como os containers Docker devem se comportar em produção. O arquivo contém a configuração do banco de dados, dos microsserviços e da rede.

O diagrama abaixo ilustra a arquitetura do sistema que será criada com o Docker Compose, na qual os microsserviços ficam isolados do acesso externo, formando uma camada confiável. Os microsserviços só acessam o banco de dados, e o acesso externo é bloqueado.

flowchart LR
    subgraph api [Camada confiável]
        account e3@==> db@{ shape: cyl, label: "Banco de dados" }
    end
    internet e1@==>|requisição| account:::red
    e1@{ animate: true }
    e3@{ animate: true }
    classDef red fill:#fcc

No diagrama, o microsserviço account é a camada de lógica de negócio que interage com o banco de dados.

A estrutura de diretórios do projeto fica mais ou menos assim:

📁 api/
├── 📁 account/
├── 📁 account-service/
│   ├── 📁 src/
│   └── Docker Dockerfile
├──  .env
└── YAML compose.yaml

O arquivo compose.yaml contém a configuração do banco de dados e dos microsserviços, bem como a configuração da rede. O arquivo .env contém as variáveis de ambiente do banco de dados, como o nome de usuário, a senha e o nome do banco. O arquivo Dockerfile contém a configuração do microsserviço, como a imagem base, as dependências e o comando para executar a aplicação.

O conteúdo dos arquivos é o seguinte:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
name: store

services:

  db:
    image: postgres:17
    volumes:
      - ${VOLUME_DB}:/var/lib/postgresql/data
    environment:
      POSTGRES_USER: ${DB_USER:-store}
      POSTGRES_PASSWORD: ${DB_PASSWORD:-store}
      POSTGRES_DB: ${DB_NAME:-store}

  account:
    build:
      context: ./account-service
      dockerfile: Dockerfile
    ports:
      - 8080:8080
    depends_on:
      - db

1


1
2
3
4
FROM eclipse-temurin:25
VOLUME /tmp
COPY target/*.jar /app.jar
ENTRYPOINT ["java", "-jar", "/app.jar"]

Nessa configuração, usamos a imagem postgres:17 para criar um container PostgreSQL e definimos as variáveis de ambiente do banco de dados por meio do arquivo .env. Só o account publica uma porta (8080); o banco não tem ports, então só é acessível de dentro da rede do Compose — a camada confiável.

Para executar a aplicação, precisamos rodar o seguinte comando:

docker compose up -d --build

E, para verificar se a aplicação está rodando, podemos executar o seguinte comando:

docker compose ps -a

Pronto! No próximo hands-on, vamos nos conectar ao banco de dados e executar algumas consultas para verificar se os dados estão sendo persistidos corretamente.

Repositório