Módulo 13: Spring Cloud e Microsserviços
🎯 Objetivos do Módulo
Ao final deste módulo, você será capaz de:
- ✅ Compreender a arquitetura de microsserviços vs monolítica
- ✅ Configurar um Service Discovery com Eureka
- ✅ Centralizar a configuração com Spring Cloud Config
- ✅ Criar uma API Gateway com Spring Cloud Gateway
- ✅ Implementar a comunicação entre serviços com Feign
- ✅ Aplicar padrões de resiliência com Resilience4j
- ✅ Compreender os padrões: Circuit Breaker, Retry, Rate Limiter
📋 Pré-requisitos
Antes de começar este módulo, certifique-se de dominar:
- ✅ Módulo 1-6: Fundamentos de Spring Boot e Spring Data JPA
- ✅ Módulo 7: Transações e configuração
- ✅ Módulo 8: Spring Security (para proteger os serviços)
- ✅ Módulo 12: Docker e deploy (para orquestrar os serviços)
- ✅ Conceitos de REST API
- ✅ Docker e Docker Compose (essencial!)
🏗️ Arquitetura do Módulo
📚 Plano do Módulo
Capítulos Teóricos
| # | Capítulo | Duração | Descrição |
|---|---|---|---|
| 1 | Introdução aos Microsserviços | 45 min | Monolito vs Microsserviços, patterns, 12-Factor App |
| 2 | Service Discovery - Eureka | 1h | Eureka Server/Client, Load Balancing |
| 3 | Configuração Centralizada | 1h | Spring Cloud Config, Git backend, Refresh |
| 4 | API Gateway | 1h15 | Spring Cloud Gateway, Rotas, Filtros |
| 5 | Comunicação entre Serviços | 1h30 | Feign, Resilience4j, Circuit Breaker |
Trabalhos Práticos
| # | TP | Duração | Descrição |
|---|---|---|---|
| 1 | Eureka Server e Clients | 1h30 | Criar o registro de serviços |
| 2 | Config Server | 1h | Configuração centralizada Git |
| 3 | API Gateway | 1h30 | Gateway com routing e filtros |
| 4 | Feign + Resilience4j | 2h | Comunicação resiliente |
Duração total estimada: ~12 horas
🎬 Antes / Depois deste Módulo
❌ ANTES (Arquitetura Monolítica)
┌─────────────────────────────────────────────┐
│ MONOLITH APPLICATION │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ Users │ │Products │ │ Orders │ │
│ └─────────┘ └─────────┘ └─────────┘ │
│ ┌─────────────────────────────────┐ │
│ │ SINGLE DATABASE │ │
│ └─────────────────────────────────┘ │
└─────────────────────────────────────────────┘
Problemas:
- Um bug = toda a aplicação fora do ar
- Escalabilidade: tudo ou nada
- Deploy: precisa redeployar tudo
- Tecnologias: apenas uma stack
- Times: conflitos de merge
✅ DEPOIS (Arquitetura de Microsserviços)
┌──────────┐ ┌──────────┐ ┌──────────┐
│ Users │ │ Products │ │ Orders │
│ Service │ │ Service │ │ Service │
│ :8081 │ │ :8082 │ │ :8083 │
└────┬─────┘ └────┬─────┘ └────┬─────┘
│ │ │
│ ┌─────────┴─────────┐ │
└────┤ Eureka Server ├────┘
│ :8761 │
└─────────┬─────────┘
│
┌─────────┴─────────┐
│ API Gateway │
│ :8080 │
└───────────────────┘
Vantagens:
- Isolamento de falhas
- Escalabilidade independente
- Deploy contínuo
- Polyglot (Java, Node, Python...)
- Times autônomos
🧩 Componentes Spring Cloud
🏢 Caso de Uso: Microsserviços E-Commerce
Ao longo deste módulo, construiremos uma plataforma de e-commerce:
Serviços a Criar
| Serviço | Responsabilidade | Porta | Banco de dados |
|---|---|---|---|
| eureka-server | Registro de serviços | 8761 | - |
| config-server | Configuração centralizada | 8888 | Git repo |
| api-gateway | Ponto de entrada único | 8080 | - |
| user-service | Gestão de usuários | 8081 | PostgreSQL |
| product-service | Catálogo de produtos | 8082 | PostgreSQL |
| order-service | Gestão de pedidos | 8083 | PostgreSQL |
| inventory-service | Estoque de produtos | 8084 | PostgreSQL |
| notification-service | Emails/SMS | 8085 | - |
Fluxo de um Pedido
🔑 Conceitos-Chave
1. Service Discovery (Por quê?)
Sem Service Discovery:
- URLs hardcoded: http://192.168.1.10:8081
- Se o serviço muda → tudo quebra
- Load balancing manual
Com Eureka:
- Serviços se registram: "Eu sou user-service"
- Clientes perguntam: "Onde está user-service?"
- Eureka responde com todas as instâncias
- Load balancing automático
2. Configuração Centralizada (Por quê?)
Sem Config Server:
- Cada serviço tem seu application.properties
- Alterar uma senha do banco = modificar 10 arquivos
- Redeploy de todos os serviços
Com Config Server:
- Configuração no Git
- Um único local para modificar
- Refresh sem reiniciar
- Criptografia de segredos
3. API Gateway (Por quê?)
Sem Gateway:
- Cliente conhece todos os serviços
- CORS precisa ser tratado em todos
- Auth implementada em todos
- Rate limiting impossível
Com Gateway:
- Ponto de entrada único
- Auth centralizada
- Rate limiting
- Logging centralizado
- Transformação de requests/responses
4. Circuit Breaker (Por quê?)
Sem Circuit Breaker:
- Serviço A chama Serviço B
- Serviço B está fora do ar
- Serviço A espera... timeout
- Falha em cascata → tudo fora do ar
Com Circuit Breaker:
- Detecta falhas
- "Abre" o circuito
- Retorna fallback imediato
- "Fecha" quando B volta
📦 Stack Técnica
Dependências Maven (BOM)
<!-- No POM pai -->
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>2023.0.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
Versões Compatíveis
| Spring Boot | Spring Cloud | Java |
|---|---|---|
| 3.2.x | 2023.0.x (Leyton) | 17+ |
| 3.1.x | 2022.0.x (Kilburn) | 17+ |
| 3.0.x | 2022.0.x (Kilburn) | 17+ |
⚠️ Quando Usar Microsserviços?
✅ Boas Razões
- Aplicação grande com múltiplos times
- Necessidade de escalabilidade diferente por componente
- Domínios de negócio bem definidos (Bounded Contexts)
- Necessidade de resiliência (isolamento de falhas)
- Deploys frequentes e independentes
❌ Más Razões
- "Está na moda"
- Projeto pequeno / time pequeno
- MVP / Protótipo
- Time sem experiência DevOps
- Infraestrutura limitada
💡 Regra de Ouro
"Se você não tem os problemas de um monolito, você não precisa de microsserviços."
— Martin Fowler
🗺️ Progressão do Módulo
🚀 Pronto para Começar?
Este módulo é avançado e requer bom domínio dos módulos anteriores. Se você está pronto:
- Instale o Docker (essencial para este módulo)
- Certifique-se de ter 16GB+ de RAM (vários serviços)
- Prepare uma IDE com suporte a Spring (IntelliJ recomendado)
Começar o Capítulo 1: Introdução aos Microsserviços →