Digamos que você pague em um mercado usando seu cartão. Agora você está em casa, não sai há algum tempo e recebe uma mensagem do seu banco informando que você debitou $ 20000. Como? O que você comprou lhe custou meros $ 120! Isso implicará em um longo processo de verificações com seu banco, e o banco pode levar meses para rastrear e resolver a transação fraudulenta.
Seria muito mais fácil se um mecanismo de detecção de fraude fosse incorporado ao sistema para determinar transações inválidas e falhas em tempo real. No entanto, essa decisão deve ser instantânea e o sistema deve se treinar continuamente com base nos comportamentos anteriores do usuário. Portanto, você não pode esperar que os clientes esperem no balcão enquanto seu sistema de detecção de fraudes demora para detectar qualquer anomalia. Você precisa ter um sistema eficiente, bem como mais rápido. Isso é possível se você armazenar os dados na memória usando um cache, como NCache e processá-lo em milissegundos.
Geralmente, um sistema de detecção de fraude contém três subsistemas, conforme ilustrado na Figura 1:
- Sistema quase em tempo real (NRT): Este sistema processa a entrada e os resultados são gerados usando padrões e regras pré-definidas, em vez de realizar o cálculo real. Além disso, os resultados devem ser em milissegundos, pois responde diretamente ao usuário. O objetivo principal deste sistema é alta taxa de transferência com baixa latência, o que significa que este sistema deve idealmente estar na memória local para obter maior desempenho.
- Sistema de Processamento de Entrada: Este sistema pode levar de minutos a horas para processar a entrada e ajustar os parâmetros do sistema NRT. Essas informações atualizadas são alimentadas ao sistema de processamento offline, que processa ainda mais os algoritmos de aprendizado de máquina nele.
- Sistema de Processamento Offline Esse sistema pode levar de horas a meses para responder. Esse sistema aprimora o modelo, treina os dados e alimenta esses dados atualizados de volta ao sistema NRT para obter melhores resultados.
NCache como cache na memória e barramento de mensagens do Pub/Sub
NCache é um cache distribuído na memória que oferece mensagens poderosas do Pub/Sub e outros recursos, como estruturas de dados distribuídas. Tendo em vista os sistemas envolvidos em um sistema de detecção de fraudes, NCache se encaixa perfeitamente no sistema Near-Real-Time, pois requer resultados extremamente rápidos. Isso é possível como NCache pode ser usado para comunicação entre vários elementos, bem como armazenar dados mais próximos de seu aplicativo, reduzindo ainda mais as chamadas de rede para buscar dados.
Criamos um exemplo de sistema de detecção de fraude em .NET que inclui NCache para melhorar o desempenho e o rendimento. Você pode encontrar a amostra de trabalho aqui no GitHub.
Em um nível superior, o aplicativo funciona assim:
- O aplicativo cliente se comunica com o Transaction Request Manager que gerencia a transação de um determinado cliente.
- As informações da transação são publicadas como uma mensagem para o Tópico do Pub/Sub.
- O Fraud Detection Manager assina este tópico e recebe a mensagem de transação.
- A lógica de detecção de fraude é realizada no item e o resultado é enviado ao gerenciador de transações que é enviado de volta ao aplicativo cliente.
- As informações do cliente são então armazenadas no cache usando Estruturas de dados distribuídos como Listas. Isso ajudará na tomada de decisões sobre transações futuras muito mais fácil.
- Os dados são persistidos no banco de dados usando write-behind.
Como gerenciar transações com o Pub/Sub
O Transaction Request Manager é inicializado com o cache. O Transaction Request Manager cria a transação como uma mensagem e a publica em seu tópico.
1 2 3 4 5 |
public void CreateRelevantSubscription() { MessageReceivedCallback transactionmessageReceivedCallback = new TransactionCompletedMessage(this).MessageReceivedCallback; transactionSubscription = base.CreateRelevantSubscriptions(Topics.REPLIESTOPICS, transactionmessageReceivedCallback); } |
Sempre que uma transação é feita por meio do Transaction Request Manager, ele primeiro cria uma mensagem a partir das informações do cliente e depois a publica como uma mensagem no tópico da transação. Este tópico é subscrito pelo Fraud Detection Manager, que recebe a mensagem e executa a lógica de detecção de fraude na mensagem recebida e envia os resultados de volta ao Transaction Request Manager.
1 2 3 4 5 |
// Sending messages on the respective topic if (customer != null) { ncache.PublishMessageOnTopic(Topics.TRANSACTIONTOPICS, CreateTransactionFromCustomer(customer), null); } |
Detecção de fraudes em tempo real
O Fraud Detector contém lógica completa para verificar se uma transação é válida ou não. Ele se comporta como um manipulador para realizar todas as transações e estabelecer uma conexão com o armazenamento em cache. O Fraud Detection Manager é inicializado criando um tópico no NCache e subscrevendo este tópico. O retorno de chamada para o tópico Fraud Detection Manager existe na lógica do Transaction Request Manager, pois ele envia os resultados da lógica de detecção de fraude de volta ao Transaction Request Manager.
1 2 3 4 5 6 7 8 9 10 11 12 13 |
public void InitiliazeFraudManager() { base.CreateRelaventTopics(Topics.REPLIESTOPICS); base.CreateRelaventTopics(Topics.TRANSACTIONTOPICS); CreateRelevantSubscription(); } public void CreateRelevantSubscription() { // Initializes the relevant subscribers with their callbacks MessageReceivedCallback transacionManagermessageReceivedCallback = new StartTransactionMessage(this).MessageReceivedCallback; transactionSubscription = base.CreateRelevantSubscriptions(Topics.TRANSACTIONTOPICS, transacionManagermessageReceivedCallback); } |
Na lógica de detecção de fraude, primeiro, os dados de um cliente são buscados na memória, se estiverem presentes lá, verificamos se alguma última transação na memória foi fraudulenta, se sim, declaramos essa transação como falha também. Se nenhuma dessas informações for recebida e todas as transações na memória forem válidas, executamos a lógica já aprendida nesses dados.
1 2 3 4 5 6 7 8 9 10 11 12 13 |
if (customerInfo != null) { if (learntLogic.FraudFoundInLastTransactions(transactionMessage, customerInfo)) { result = Result.Faliure; } } if (result != Result.Faliure) { bool isValid = learntLogic.IsTransactionValid(transactionMessage); if (!isValid) result = Result.Suspicious; } |
Nesta lógica aprendida, usamos vários fatores para determinar a validade da transação. Verificamos se uma transação foi originada de um endereço IP válido e um endereço de e-mail válido que esteja em um domínio adequado. Além disso, o e-mail não deve existir em uma série de e-mails suspeitos. Também é verificado se a transação teve origem em algum local suspeito. Se algum dos critérios acima falhar, o peso da falha será incrementado. Se o peso da falha for maior que o peso da decisão, a transação será inválida. Você pode encontrar o código para isso lógica no GitHub.
Armazenar resultados em cache e mantê-los no banco de dados
Uma vez declarado o resultado, o resultado é adicionado/atualizado no cache.
1 2 |
FraudRequest fraudRequest = CreateFraudRequest(transactionMessage, result); ncache.UpdateCustomerInfoInCache(customerkey, fraudRequest); |
O cache está configurado para a fonte de dados. Para armazenar informações do cliente no cluster na memória, usamos NCache'S listas distribuídas, que são uma das estruturas de dados distribuídas. As informações dos clientes também são mantidas no banco de dados usando Escrever atrás, que atualiza de forma assíncrona as informações do cliente.
1 2 3 4 5 6 7 8 9 10 11 |
IDistributedList list = cache.DataTypeManager.GetList(key); if (list == null) AddCustomerInCache(key, null, cutomerInfo); else { // Update info of a customer against its id list.WriteThruOptions = new WriteThruOptions(WriteMode.WriteBehind); list.Add(cutomerInfo); } |
Uma vez armazenada em cache, uma nova mensagem é criada a partir desse resultado e publicada de volta no tópico assinado pelo Transaction Request Manager. Ele recebe a mensagem e publica o resultado de volta no aplicativo cliente.
Conclusão
NCache é um cache .NET distribuído na memória que vem com vários recursos, como Pub/Sub, estruturas de dados distribuídas, provedores de fonte de dados e muito mais. O objetivo de armazenar e processar dados na memória local é eliminar o custo de transferência de rede, pois todo o processamento é feito através do cache e os resultados são posteriormente atualizados no banco de dados.
Gostei de ler o artigo acima, realmente explica tudo em detalhes, o artigo é muito interessante e eficaz. Obrigado e boa sorte com os próximos artigos.