Publicado em

Arquitetura Orientada a Eventos: Repensando Como Sistemas se Comunicam

--
Autores
  • avatar
    Nome
    Ergito Vilanculos

Tem uma mudança fundamental acontecendo em como construímos sistemas. Ao invés de serviços constantemente perguntando uns aos outros "ei, aconteceu alguma coisa?", eles simplesmente anunciam "ei, isso aconteceu!" e quem se importar pode reagir.

Isso é arquitetura orientada a eventos, e é um game changer.

Request-Response vs Eventos

Arquitetura tradicional é tipo uma ligação telefônica:

Serviço A: "Ei B, processa esse pedido"
Serviço B: "OK, processando... pronto"
Serviço A: "Valeu, agora posso continuar"

Orientada a eventos é tipo um grupo de WhatsApp:

Serviço A: "Pedido novo criado!" (posta no canal)
Serviço B: (vê a mensagem) "Vou cuidar do estoque"
Serviço C: (vê a mensagem) "Vou mandar email de confirmação"
Serviço D: (vê a mensagem) "Vou atualizar analytics"

No primeiro modelo, Serviço A tem que esperar por B. No segundo, A só anuncia e segue em frente.

Por que Ir Event-Driven?

1. Baixo Acoplamento

Serviços não precisam saber sobre os outros.

Request-Response:
OrderService precisa conhecer:
  - InventoryService
  - EmailService
  - AnalyticsService
  - PaymentService

Event-Driven:
OrderService só emite "OrderCreated"
Outros serviços assinam os eventos que interessam

Adicionando um serviço novo? Só assina os eventos que você precisa. Sem mudanças nos serviços existentes.

2. Escalabilidade

Cada consumidor pode escalar independentemente.

Volume alto de email? Escala o serviço de email.
Carga alta de analytics? Escala o serviço de analytics.
O serviço de pedidos nem liga.

3. Resiliência

Se o serviço de email tá fora, pedidos ainda são processados. Emails são enviados quando ele volta.

Tradicional:
OrderService → EmailService (fora) → Pedido falha ❌

Event-Driven:
OrderService → Fila de Eventos → (espera) → EmailService (voltou) → Email enviado ✓

4. Trilha de Auditoria

Eventos naturalmente criam um histórico de tudo que aconteceu.

OrderCreated { orderId: 123, userId: 456, items: [...] }
PaymentProcessed { orderId: 123, amount: 99.99 }
InventoryReserved { orderId: 123, items: [...] }
OrderShipped { orderId: 123, trackingNumber: "..." }

Tipos de Eventos

Eventos de Domínio

Algo aconteceu no seu domínio de negócio.

// Exemplos
{
  type: "OrderCreated",
  data: { orderId: "123", customerId: "456", items: [...] }
}

{
  type: "PaymentFailed",
  data: { orderId: "123", reason: "insufficient_funds" }
}

{
  type: "UserRegistered",
  data: { userId: "789", email: "user@example.com" }
}

Eventos de Integração

Eventos feitos pra sistemas externos ou bounded contexts.

// Publicado pra outros microserviços
{
  type: "OrderReadyForShipment",
  data: { orderId: "123", warehouse: "SP", priority: "high" }
}

Eventos de Sistema

Eventos de nível de infraestrutura.

{
  type: "ServiceStarted",
  data: { service: "order-service", version: "1.2.3" }
}

{
  type: "DatabaseConnectionLost",
  data: { database: "orders-db", timestamp: "..." }
}

Anatomia de um Evento

Um evento bem estruturado:

{
  // Metadata
  eventId: "uuid-aqui",           // Identificador único
  eventType: "OrderCreated",      // O que aconteceu
  timestamp: "2025-01-22T10:30:00Z",
  version: "1.0",                 // Versão do schema
  source: "order-service",        // Quem emitiu

  // Correlação
  correlationId: "request-123",   // Rastrear entre serviços
  causationId: "event-456",       // O que causou esse evento

  // Payload
  data: {
    orderId: "order-789",
    customerId: "cust-123",
    items: [...]
  }
}

Padrões

Event Notification

Só diz que algo aconteceu. Consumidor busca detalhes se precisar.

// Evento leve
{ type: "OrderCreated", data: { orderId: "123" } }

// Consumidor chama de volta pra detalhes
GET /api/orders/123

Prós: Eventos pequenos, dados sempre frescos Contras: Chamadas de API extras, acoplamento

Event-Carried State Transfer

Inclui todos os dados relevantes no evento.

// Evento gordo
{
  type: "OrderCreated",
  data: {
    orderId: "123",
    customer: { id: "456", name: "João", email: "..." },
    items: [...],
    totals: { subtotal: 99, tax: 8, total: 107 }
  }
}

Prós: Consumidor tem tudo, sem callbacks Contras: Eventos maiores, dados podem estar desatualizados

Event Sourcing

Armazena estado como uma sequência de eventos. Mais sobre isso num artigo dedicado!

// Ao invés de guardar estado atual:
{ balance: 150 }

// Guarda eventos:
AccountCreated { amount: 100 }
MoneyDeposited { amount: 100 }
MoneyWithdrawn { amount: 50 }
// Estado atual = replay dos eventos = 150

Abordagens de Implementação

Simples: Eventos em Memória

Bom pra monolitos ou pra começar.

class EventBus:
    def __init__(self):
        self.handlers = {}

    def subscribe(self, event_type, handler):
        if event_type not in self.handlers:
            self.handlers[event_type] = []
        self.handlers[event_type].append(handler)

    def publish(self, event):
        for handler in self.handlers.get(event['type'], []):
            handler(event)

# Uso
bus = EventBus()
bus.subscribe("OrderCreated", send_confirmation_email)
bus.subscribe("OrderCreated", update_inventory)
bus.publish({"type": "OrderCreated", "data": {...}})

Produção: Message Broker

Use Kafka, RabbitMQ, ou serviços de cloud.

# Publicando
def create_order(order_data):
    order = save_to_database(order_data)

    event = {
        "type": "OrderCreated",
        "data": {"orderId": order.id, ...}
    }

    kafka.publish("orders", event)

    return order

# Consumindo
@kafka.consumer("orders")
def handle_order_events(event):
    if event["type"] == "OrderCreated":
        send_confirmation_email(event["data"])

Desafios

Consistência Eventual

Dados não ficam imediatamente consistentes entre serviços.

Usuário cria pedido → Serviço de pedidos salva
                   → Evento publicado
                   → Serviço de estoque processa (depois)

Por um momento, estoque acha que item está disponível
quando na verdade já está reservado.

Soluções:

  • Aceita (na maioria dos casos tá ok)
  • Padrão Saga pra fluxos complexos
  • UI mostra estado "processando"

Ordenação de Eventos

Eventos podem chegar fora de ordem.

OrderCreated (às 10:00)
OrderUpdated (às 10:01)
OrderCancelled (às 10:02)

E se OrderCancelled chega antes de OrderCreated?

Soluções:

  • Use particionamento (mesmo pedido → mesma partição)
  • Inclua números de sequência
  • Handlers idempotentes

Eventos Duplicados

Problemas de rede podem causar duplicatas.

OrderCreated → processado
(retry de rede)
OrderCreated → processado de novo?

Soluções:

  • Handlers idempotentes (mesmo evento = mesmo resultado)
  • Rastrear IDs de eventos processados
def handle_order_created(event):
    event_id = event["eventId"]

    # Verifica se já foi processado
    if redis.sismember("processed_events", event_id):
        return  # Pula duplicata

    # Processa
    create_inventory_reservation(event["data"])

    # Marca como processado
    redis.sadd("processed_events", event_id)

Quando NÃO Usar Eventos

  • Apps CRUD simples: Exagero
  • Requisitos síncronos: Usuário precisa de resposta imediata
  • Consistência forte necessária: Transferências bancárias entre contas
  • Time/projeto pequeno: Complexidade adicional pode não valer

Arquitetura orientada a eventos não é sobre substituir toda comunicação por eventos. É sobre reconhecer quando comunicação assíncrona e desacoplada faz mais sentido do que chamadas síncronas.

Comece com as partes do seu sistema onde serviços não precisam de respostas imediatas, e expanda dali.

No próximo, vamos mergulhar nas ferramentas que tornam isso possível: Kafka, RabbitMQ, e mais.

Dúvidas? Manda nos comentários!

Até a próxima!