💰 Finanças Microservices

Arquitetura de microserviços para um sistema de gestão financeira pessoal

Sistema desenvolvido utilizando Spring Boot, Spring Cloud, Netflix Eureka e Spring Cloud Gateway, seguindo uma arquitetura moderna baseada em microserviços.

📖 Sobre o Projeto

O Finanças Microservices é uma aplicação de gestão financeira pessoal desenvolvida com uma arquitetura baseada em microserviços independentes.

O projeto foi estruturado para demonstrar conceitos fundamentais de sistemas distribuídos, como:

Separação de responsabilidades
Service Discovery
API Gateway
Autenticação centralizada
Comunicação entre serviços
Persistência independente
Segurança baseada em JWT
Containerização com Docker

Cada serviço possui uma responsabilidade específica e pode ser executado, escalado e evoluído de forma independente.

🏗️ Arquitetura

                                ┌──────────────────────┐
                                │     API Gateway      │
                                │      Porta 8080      │
                                └──────────┬───────────┘
                                           │
              ┌────────────────────────────┼────────────────────────────┐
              │                            │                            │
              ▼                            ▼                            ▼
      ┌───────────────┐          ┌──────────────────┐          ┌────────────────┐
      │ Auth Service  │          │ Transaction      │          │ Report Service │
      │ Porta 8081    │          │ Service          │          │ Porta 8083    │
      │               │          │ Porta 8082       │          │                │
      └───────────────┘          └──────────────────┘          └────────────────┘
              │                            │                            │
              └────────────────────────────┼────────────────────────────┘
                                           │
                                           ▼
                                ┌──────────────────────┐
                                │   Service Registry   │
                                │  Netflix Eureka 8761 │
                                └──────────────────────┘
                                           │
                                           ▼
                                ┌──────────────────────┐
                                │      PostgreSQL       │
                                └──────────────────────┘

Fluxo de requisição

Cliente
   │
   ▼
API Gateway
   │
   ├──► Auth Service
   │
   ├──► Transaction Service
   │
   └──► Report Service
            │
            ▼
       PostgreSQL

O Netflix Eureka atua como Service Registry, permitindo que os microserviços sejam registrados e descobertos dinamicamente.

🚀 Microserviços

Serviço	Porta	Responsabilidade
🌐 API Gateway	8080	Entrada da aplicação, roteamento e autenticação
🔐 Auth Service	8081	Cadastro, login e autenticação
💳 Transaction Service	8082	Receitas, despesas e movimentações financeiras
📊 Report Service	8083	Relatórios e indicadores financeiros
📡 Service Registry	8761	Registro e descoberta dos serviços

🛠️ Tecnologias

Backend

Java 17
Spring Boot 3.1.5
Spring Cloud
Spring Cloud Gateway
Netflix Eureka
Spring Security
JWT
Spring Data JPA
Hibernate
Maven

Banco de Dados

PostgreSQL 16

Infraestrutura

Docker
Docker Compose

📂 Estrutura do Projeto

financas-microservicos/
│
├── api-gateway/
├── service-registry/
├── auth-service/
├── transaction-service/
├── report-service/
│
├── docker-compose.yml
├── start-all.ps1
├── start-all.sh
└── README.md

Organização

Projeto	Responsabilidade
`api-gateway`	Gateway de entrada e roteamento
`service-registry`	Registro e descoberta dos microserviços
`auth-service`	Autenticação, usuários e geração de tokens
`transaction-service`	Gerenciamento de receitas e despesas
`report-service`	Relatórios e indicadores financeiros
`docker-compose.yml`	Infraestrutura de banco e containers
`start-all.ps1`	Inicialização automatizada no Windows
`start-all.sh`	Inicialização automatizada no Linux

🚀 Como Executar

Pré-requisitos

Antes de iniciar o projeto, certifique-se de possuir:

Java 17+
Maven 3.9+
Docker
Docker Compose
Git

1. Clonar o repositório

git clone https://github.com/adanwilliamdev/financas-microservicos.git

cd financas-microservicos

2. Subir o PostgreSQL

Execute:

docker compose up -d

Verifique os containers:

docker compose ps

3. Compilar os microserviços

Execute na raiz do projeto:

mvn clean install -DskipTests

4. Iniciar os microserviços

Windows

.\start-all.ps1

Linux / macOS

./start-all.sh

Os serviços serão iniciados de acordo com suas respectivas portas.

🌐 Serviços

Após iniciar a aplicação, os serviços estarão disponíveis em:

Aplicação	URL
📡 Eureka Dashboard	http://localhost:8761
🌐 API Gateway	http://localhost:8080
🔐 Auth Service	http://localhost:8081
💳 Transaction Service	http://localhost:8082
📊 Report Service	http://localhost:8083

O ponto de entrada recomendado para os clientes da aplicação é o API Gateway, disponível na porta 8080.

🔑 Usuários de Teste

O projeto possui usuários de demonstração para facilitar os testes:

Usuário	Senha
`admin@financas.com`	`admin123`
`usuario@financas.com`	`usuario123`

Importante: essas credenciais são destinadas apenas ao ambiente de desenvolvimento e demonstração. Não utilize essas senhas em produção.

📡 API

🔐 Auth Service

Método	Endpoint	Descrição
`GET`	`/api/auth/health`	Verifica o status do serviço
`POST`	`/api/auth/register`	Cadastra um usuário
`POST`	`/api/auth/login`	Realiza autenticação

Exemplo de login

POST /api/auth/login
Content-Type: application/json

{
  "email": "usuario@financas.com",
  "password": "usuario123"
}

💳 Transaction Service

Método	Endpoint	Descrição
`GET`	`/api/transacoes`	Lista transações
`POST`	`/api/transacoes`	Cria uma transação
`GET`	`/api/transacoes/saldo`	Consulta o saldo

📊 Report Service

Método	Endpoint	Descrição
`GET`	`/api/relatorios/resumo`	Resumo financeiro
`GET`	`/api/relatorios/categorias`	Indicadores por categoria

🔐 Segurança

A aplicação utiliza mecanismos de segurança baseados no Spring Security e JWT.

Recursos implementados

🔑 Autenticação baseada em JWT
🛡️ Spring Security
🌐 API Gateway
🔒 Validação de tokens
🔐 Senhas protegidas com BCrypt
🚪 Controle de acesso às APIs

Fluxo de autenticação

┌──────────────┐
│    Cliente   │
└──────┬───────┘
       │
       │ Login
       ▼
┌──────────────┐
│ Auth Service │
└──────┬───────┘
       │
       │ JWT
       ▼
┌──────────────┐
│    Cliente   │
└──────┬───────┘
       │
       │ Authorization: Bearer <token>
       ▼
┌──────────────┐
│ API Gateway  │
└──────┬───────┘
       │
       ▼
┌───────────────────────┐
│ Microserviço destino  │
└───────────────────────┘

🐳 Docker

Subir os containers

docker compose up -d

Parar os containers

docker compose down

Visualizar logs

docker compose logs -f

Verificar status

docker compose ps

🧩 Desenvolvimento

Cada microserviço possui seu próprio projeto Spring Boot e pode ser desenvolvido de forma independente.

Para executar um serviço individualmente:

cd auth-service

mvn spring-boot:run

O mesmo padrão pode ser utilizado para os demais serviços:

api-gateway
service-registry
transaction-service
report-service

📈 Roadmap

Arquitetura

Próximas funcionalidades

🎯 Objetivos Técnicos

O projeto foi desenvolvido para demonstrar conhecimentos práticos em:

Arquitetura de microserviços
Spring Boot
Spring Cloud
Service Discovery
API Gateway
Spring Security
JWT
Persistência com JPA/Hibernate
PostgreSQL
Docker
Docker Compose
Maven
Arquitetura distribuída
Separação de responsabilidades
Segurança de APIs

🤝 Contribuição

Contribuições são bem-vindas.

1. Faça um Fork

2. Crie uma branch

git checkout -b feature/minha-feature

3. Faça suas alterações

4. Commit

git add .

git commit -m "feat: adiciona nova funcionalidade"

5. Envie para o repositório

git push origin feature/minha-feature

6. Abra um Pull Request

📄 Licença

Este projeto está licenciado sob a licença MIT.