Questa è una versione PDF del contenuto. Per la versione completa e aggiornata, visita:
Verrai reindirizzato automaticamente...
No panorama Fintech de 2026, a expectativa do utilizador é o imediatismo. Já não é aceitável esperar dias por um feedback preliminar sobre um pedido de financiamento. Aqui entra em jogo a Event-Driven Architecture: Gestão em Tempo Real do processamento de processos, um paradigma que transforma processos bancários monolíticos e lentos em fluxos de dados reativos e escaláveis. Este artigo técnico explora como conceber um sistema distribuído capaz de gerir o ciclo de vida de um crédito habitação, garantindo resiliência e consistência dos dados.
Tradicionalmente, a orquestração de um processo de crédito habitação ocorria através de arquiteturas monolíticas ou microsserviços acoplados via HTTP (REST/gRPC). Esta abordagem apresenta críticas estruturais:
Numa arquitetura orientada a eventos, os microsserviços não falam diretamente entre si. Em vez disso, produzem e consomem eventos. Um evento é um facto imutável ocorrido no passado (ex: MortgageApplicationSubmitted).
Para o nosso caso de uso, compararemos dois backbones tecnológicos dominantes:
Decisão Arquitetural: Para um sistema de crédito habitação complexo que requer historicização e auditorias rigorosas, utilizaremos Apache Kafka como Event Bus central, integrando padrões de Schema Registry (ex: Avro ou Protobuf) para garantir a compatibilidade dos contratos de dados.
A gestão de um processo de crédito habitação é um Long-Running Process. Devemos decidir como coordenar os serviços:
Utilizaremos uma abordagem híbrida: Coreografia para os eventos de estado (pub/sub) e Orquestração (através do padrão Saga) para a gestão da consistência transacional.
Num sistema distribuído, não podemos usar as transações ACID da base de dados local para processos que atravessam vários serviços. Devemos abraçar a Eventual Consistency. Mas o que acontece se o Bank Gateway recusar o processo depois de o Scoring Service o ter aprovado?
Devemos implementar o Padrão Saga para gerir os rollbacks (transações de compensação).
Imaginemos o fluxo ideal e o fluxo de falha:
O utilizador envia o pedido. O Application Service publica o evento:
{
"eventId": "uuid-1234",
"eventType": "MortgageApplicationSubmitted",
"payload": {
"applicationId": "M-999",
"amount": 200000,
"applicant": "Mario Rossi"
}
}O Scoring Service e o Document Service escutam o evento.
O Scoring Service aprova e publica CreditScoreApproved.
O Document Service valida os PDFs e publica DocumentsValidated.
O Bank Gateway aguarda ambos os eventos. Uma vez recebidos, tenta finalizar o processo no mainframe bancário.
Se o mainframe responder com um erro (ex: “Fundos insuficientes” ou “Timeout”), o Bank Gateway publica o evento MortgageFinalizationFailed.
Neste ponto, são acionadas as Compensating Transactions:
No Kafka, a entrega exactly-once é complexa. É mais seguro projetar os consumidores para serem idempotentes. Se o Notification Service receber duas vezes o evento MortgageApproved, deve ser capaz de perceber (através de um ID único do evento guardado no Redis ou DB) que já enviou o email e descartar o duplicado.
O que acontece se um evento estiver malformado e fizer o consumidor falhar? Não podemos bloquear a fila. O evento problemático deve ser movido para uma Dead Letter Queue após X tentativas falhadas, permitindo à equipa de engenharia analisá-lo manualmente sem parar o fluxo dos outros processos.
Os processos de crédito habitação mudam com o tempo (novas normativas, novos campos de dados). Utilizar um Schema Registry é fundamental. Os produtores e os consumidores devem concordar sobre o esquema (ex: Avro). Se adicionarmos o campo taxa_juro_bonificada, os consumidores antigos não devem falhar (backward compatibility).
Aqui está um exemplo de como configurar um consumer que suporta a gestão de transações num contexto Spring Cloud Stream:
@Bean
public Consumer<MortgageEvent> mortgageProcessor() {
return event -> {
if (event.getType().equals("MortgageApplicationSubmitted")) {
try {
scoringService.calculate(event.getPayload());
} catch (Exception e) {
// Lógica de envio para DLQ ou retry automático
throw new AmqpRejectAndDontRequeueException(e);
}
}
};
}Passar para uma arquitetura de eventos para a gestão de crédito habitação não é apenas um exercício de estilo tecnológico, mas uma necessidade de negócio. Permite desacoplar as equipas de desenvolvimento (a equipa “Documentos” pode lançar atualizações sem se coordenar com a equipa “Banca”), escalar os serviços de forma independente (mais recursos para o Scoring durante os picos de pedidos) e oferecer ao utilizador final uma experiência fluida e transparente.
A complexidade introduzida pela gestão da consistência eventual e pelos padrões de compensação é o preço a pagar para obter um sistema resiliente, capaz de gerir volumes elevados sem os gargalos das bases de dados relacionais centralizadas.
Esta arquitetura supera os limites dos sistemas monolíticos eliminando o acoplamento temporal e o polling ineficiente. Permite transformar processos lentos em fluxos reativos, garantindo escalabilidade independente dos serviços e fornecendo feedback imediato ao utilizador, em vez de o deixar à espera em frente a um carregamento infinito.
O Padrão Saga gere a consistência dos dados através de uma série de transações locais coordenadas. Se um passo falhar, como uma recusa do gateway bancário, o sistema executa transações de compensação para anular as operações anteriores, garantindo que o estado final do sistema permaneça coerente sem bloquear os recursos.
O Apache Kafka é preferível quando é necessária uma rigorosa historicização e a capacidade de reprocessar os eventos passados, funcionalidades essenciais para os audit trails bancários. Ao contrário do EventBridge, que é ótimo para o routing serverless, o Kafka gere melhor payloads elevados e garante a persistência imutável dos dados on-premise ou híbridos.
A idempotência é a capacidade de um sistema gerir o mesmo evento várias vezes sem produzir efeitos colaterais duplicados. É crucial em arquiteturas como o Kafka, onde a entrega «exactly-once» é complexa; os consumidores devem reconhecer eventos já processados para evitar, por exemplo, enviar notificações duplas ao cliente.
Para evitar que um evento errado bloqueie toda a fila de processamento, utilizam-se as Dead Letter Queues (DLQ). Após um número definido de tentativas falhadas, o evento problemático é movido para esta fila especial para ser analisado manualmente pelos engenheiros, permitindo que o fluxo principal dos processos continue sem interrupções.