Se você começa microserviço assim:

um monte de API separada sem padrão, comunicação só via REST, sem mensageria

Você não tem microserviço. Você tem bagunça distribuída.

Aqui vamos montar uma base profissional de verdade.

1. Arquitetura final (visão geral)

[ Client ]
    ↓
[ API Gateway ]
    ↓
[ Auth Service ]
    ↓
[ User Service ] ←→ Kafka ←→ [ Order Service ]
    ↓
[ PostgreSQL (por serviço) ]

Cada serviço com seu banco - Comunicação assíncrona via Kafka - Gateway centralizando entrada

2. Tecnologias utilizadas

• Java 21+

• Spring Boot 3.4+

• Spring Cloud Gateway

• Apache Kafka

• PostgreSQL

• Docker + Docker Compose

3. Estrutura do projeto

microservices-base/
├── gateway/
├── auth-service/
├── user-service/
├── order-service/
├── docker-compose.yml

4. Criando serviços base (Spring Boot)

Criar projeto via Spring Initializr:

Dependências padrão:

• Spring Web

• Spring Data JPA

• PostgreSQL Driver

• Spring Security (para auth)

• Spring Kafka

5. Configurando banco (PostgreSQL)

application.yml

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/userdb
    username: postgres
    password: postgres
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true

Cada serviço tem seu próprio banco.

6. Configurando Kafka

Dependência

<dependency>
  <groupId>org.springframework.kafka</groupId>
  <artifactId>spring-kafka</artifactId>
</dependency>

application.yml

spring:
  kafka:
    bootstrap-servers: localhost:9092
    consumer:
      group-id: user-group
      auto-offset-reset: earliest
    producer:
      key-serializer: org.apache.kafka.common.serialization.StringSerializer
      value-serializer: org.apache.kafka.common.serialization.JsonSerializer

7. Producer (enviando evento)

@Service
@RequiredArgsConstructor
public class UserProducer {

    private final KafkaTemplate<String, Object> kafkaTemplate;

    public void sendUserCreated(User user) {
        kafkaTemplate.send("user-created-topic", user);
    }
}

8. Consumer (recebendo evento)

@Component
@KafkaListener(topics = "user-created-topic", groupId = "order-group")
public class UserConsumer {

    @KafkaHandler
    public void consume(User user) {
        System.out.println("Usuário recebido: " + user.getEmail());
    }
}

9. API Gateway

Dependência:

<artifactId>spring-cloud-starter-gateway</artifactId>

application.yml

spring:
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: http://user-service:8081
          predicates:
            - Path=/users/**

        - id: order-service
          uri: http://order-service:8082
          predicates:
            - Path=/orders/**

10. Auth Service (resumo)

👉 Já conectando com o outro post de JWT

Responsável por:

• login

• gerar token

• refresh token

11. Dockerizando os serviços

Dockerfile (padrão)

FROM eclipse-temurin:21-jdk
WORKDIR /app
COPY target/app.jar app.jar
ENTRYPOINT ["java", "-jar", "app.jar"]

12. Docker Compose completo

version: '3.8'

services:

  zookeeper:
    image: confluentinc/cp-zookeeper:latest
    environment:
      ZOOKEEPER_CLIENT_PORT: 2181

  kafka:
    image: confluentinc/cp-kafka:latest
    depends_on:
      - zookeeper
    ports:
      - "9092:9092"
    environment:
      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://kafka:9092

  postgres-user:
    image: postgres:15
    environment:
      POSTGRES_DB: userdb
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
    ports:
      - "5433:5432"

  postgres-order:
    image: postgres:15
    environment:
      POSTGRES_DB: orderdb
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
    ports:
      - "5434:5432"

  user-service:
    build: ./user-service
    depends_on:
      - postgres-user
      - kafka

  order-service:
    build: ./order-service
    depends_on:
      - postgres-order
      - kafka

  gateway:
    build: ./gateway
    ports:
      - "8080:8080"
    depends_on:
      - user-service
      - order-service

13. Subindo tudo

docker-compose up --build

14. Fluxo completo

1. Cliente chama /users

2. Gateway roteia

3. User Service salva no DB

4. User Service publica evento Kafka

5. Order Service consome evento

6. Processa lógica

Isso é microserviço de verdade.

15. Boas práticas (nível produção)

• ✔ Cada serviço com banco próprio

• ✔ Comunicação assíncrona sempre que possível

• ✔ Idempotência em consumidores

• ✔ Logs centralizados

• ✔ Health check nos serviços

• ✔ Circuit breaker (Resilience4j)

Erros comuns

• ❌ Compartilhar banco

• ❌ Chamar tudo via REST

• ❌ Não usar mensageria

• ❌ Não tratar falha de evento

• ❌ Acoplar serviços

Conclusão

Microserviço não é separar projeto.

É separar responsabilidade + comunicação inteligente.

Se fizer certo:

• escala fácil

• desacopla sistema

• ganha performance