Clean Architecture em Microsserviços: Lições de Construir 19 Serviços

O Desafio

Ao construir uma plataforma com 19 microsserviços, um dos maiores desafios é manter consistência e qualidade de código em todos os serviços, permitindo que cada time se mova rapidamente.

Clean Architecture fornece um framework que resolve isso ao estabelecer limites claros e regras de dependência.

Princípios Fundamentais Aplicados

1. A Regra de Dependência

A regra mais importante: dependências apontam para dentro. Sua lógica de negócio nunca deve depender de frameworks, bancos de dados ou serviços externos.

// Camada de domínio - lógica de negócio pura, sem dependências
interface OrderRepository {
  findById(id: string): Promise<Order | null>;
  save(order: Order): Promise<void>;
}

// Camada de aplicação - orquestra casos de uso
class CreateOrderUseCase {
  constructor(
    private orderRepo: OrderRepository,
    private eventBus: EventBus
  ) {}

  async execute(input: CreateOrderInput): Promise<Order> {
    const order = Order.create(input);
    await this.orderRepo.save(order);
    await this.eventBus.publish(new OrderCreatedEvent(order));
    return order;
  }
}

2. Separação CQRS

Separar leituras e escritas nos permitiu otimizar cada caminho independentemente:

• Commands passam pelo modelo de domínio completo com validação
• Queries acessam modelos de leitura otimizados, às vezes desnormalizados

3. Comunicação Event-Driven

Serviços se comunicam através de eventos via RabbitMQ, mantendo-os desacoplados:

// Cada serviço publica eventos de domínio
await eventBus.publish(new AppointmentScheduledEvent({
  appointmentId: appointment.id,
  clientId: appointment.clientId,
  scheduledAt: appointment.scheduledAt,
}));

Principais Aprendizados

1. Comece pelo modelo de domínio - entenda o negócio antes de escrever código de infraestrutura
2. Casos de uso são a API - eles documentam o que seu sistema pode fazer
3. Infraestrutura é substituível - trocamos bancos de dados duas vezes sem tocar na lógica de negócio
4. Eventos sobre chamadas síncronas - reduz acoplamento, melhora resiliência

Clean Architecture adiciona boilerplate inicial, mas paga dividendos conforme o sistema cresce. Depois de 19 serviços, os padrões se tornam segunda natureza para o time.