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 do Docker Compose para criar um container PostgreSQL e também um cluster que isola os microsserviços do acesso externo, criando um ambiente seguro — a camada confiável (trusted layer).

Um arquivo do 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, dos microsserviços e 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
22
23
name: store

services:

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

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

1
2
3
4
DB_USER=store
DB_PASSWORD=5t0r3
DB_NAME=store
VOLUME_DB=./volume/db

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.

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

docker compose up -d --build

E, para verificar se a aplicação está em execução, podemos rodar 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.

Repository