Hands-on 1 — CRUD

O objetivo

• Uma API CRUD de contas — aqui Create, Read e Delete (criar, ler, excluir; sem atualizar).
• Construída com Spring Boot, seguindo Domain-Driven Design e Clean Architecture.
• Persistida no PostgreSQL, rodando no Docker Compose.
• É o modelo que todos os outros microsserviços da disciplina vão copiar.

Dois módulos

Arquitetura limpa: um objeto por camada

Request → Controller/Resource → Service → Repository → Database

Na volta: AccountModel → Account → AccountOut. AccountParser e AccountModel fazem as traduções.

Passo 1 — Controller: o contrato

@FeignClient(name = "account", url = "http://account:8080")
public interface AccountController {
    @PostMapping("/accounts")
    ResponseEntity<Void> create(@RequestBody AccountIn in);
    @GetMapping("/accounts")
    ResponseEntity<List<AccountOut>> findAll();
    @DeleteMapping("/accounts/{id}")
    ResponseEntity<Void> delete(@PathVariable String id);
    @GetMapping("/accounts/health-check")
    ResponseEntity<Void> healthCheck();
    @GetMapping("/accounts/{id}")
    ResponseEntity<AccountOut> findById(@PathVariable String id);
}

Os DTOs são records com @Builder do Lombok e @Accessors(fluent = true): AccountIn(name, email, password) e AccountOut(id, name, email) — a senha nunca sai.

Configuração do projeto

Cada módulo é um repositório git próprio, adicionado como submódulo:

git submodule add <repository_url> api/account
git submodule add <repository_url> api/account-service

Passo 2 — Service: fazer responder

AccountResource implementa AccountController; no início, só o health-check é de verdade.

@Controller
public class AccountResource implements AccountController {
    @Override
    public ResponseEntity<Void> healthCheck() {
        return ResponseEntity.ok().build();
    }
    // create, findAll, delete, findById: filled in later
}

mvn clean package spring-boot:run
curl -X GET http://localhost:8080/accounts/health-check   # 200 OK

Passo 3 — Containerização

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

services:
  db:
    image: postgres:17
    volumes:
      - ${VOLUME_DB}:/var/lib/postgresql/data
    environment:
      POSTGRES_USER: ${DB_USER:-store}
  account:
    build:
      context: ./account-service
    depends_on:
      - db

docker compose up -d --build · docker compose ps -a — os serviços vivem em uma camada confiável.

Passo 4 — Repository: ORM com JPA

@Entity
@Table(name = "accounts")
public class AccountModel {
    @Id
    @GeneratedValue(strategy = GenerationType.UUID)
    private String id;
    private String name;
    private String email;
    @Column(name = "hash_password")
    private String hashPassword;
}

public interface AccountRepository
    extends CrudRepository<AccountModel, String> {
    List<AccountModel> findAll();
}

Os endpoints prontos

create monta o cabeçalho Location com ServletUriComponentsBuilder.fromCurrentRequest().path("/{id}"); um id inexistente em findById lança ResponseStatusException(NOT_FOUND).

Executar e verificar

O compose.yaml passa DATABASE_HOST: db, DATABASE_PORT: 5432, DATABASE_DB, DATABASE_USERNAME, DATABASE_PASSWORD ao account.

docker compose up --build                     # build images and start db + account
docker compose ps -a                          # container names and status
docker compose logs -f account                # look for the Flyway migrations
docker compose exec db psql -U store -d store # open psql in the db container

Dentro do psql (ele roda no container db, não no account):

• \dn lista os esquemas — accounts precisa estar lá.
• \dt *.* lista as tabelas — accounts.accounts precisa estar lá.

Armadilhas comuns

• O Dockerfile copia target/*.jar: empacote antes do docker compose up --build.
• Dentro do Compose, os serviços se falam pelo hostname (db, account), não por localhost.
• Uma migração já aplicada é história: mude o esquema com um novo script V…__…sql.
• Mantenha a senha fora do AccountOut — o DTO de saída é a face pública do serviço.

Pontos-chave

1. Um microsserviço = um módulo de interface (account) + uma implementação (account-service).
2. Clean Architecture: DTO → entidade → modelo, com parsers entre as camadas.
3. @FeignClient na interface torna o contrato reutilizável por outros serviços.
4. O JPA mapeia AccountModel para uma tabela; o CrudRepository dá o CRUD de graça.
5. O Flyway versiona o esquema com scripts V…__…sql ordenados.
6. O Docker Compose roda o serviço e o PostgreSQL juntos, ligados por variáveis de ambiente.
7. Armazene um hash, nunca a senha — e nunca a retorne.