Diciamo che paghi in un mercato usando la tua carta. Ora sei a casa, non esci da un po' e ricevi un messaggio dalla tua banca che ti informa che hai addebitato $ 20000. Come? Quello che hai acquistato ti è costato solo $ 120! Ciò comporterà un lungo processo di verifica con la tua banca e la banca potrebbe impiegare mesi per rintracciare e risolvere la transazione fraudolenta.
Sarebbe molto più semplice se nel sistema fosse incorporato un meccanismo di rilevamento delle frodi in modo da determinare le transazioni non valide e fallire in tempo reale. Tuttavia, questa decisione deve essere istantanea e il sistema dovrebbe allenarsi continuamente in base ai comportamenti passati dell'utente. Quindi, non puoi aspettarti che i clienti aspettino allo sportello mentre il tuo sistema di rilevamento delle frodi impiega tempo a rilevare eventuali anomalie. È necessario disporre di un sistema efficiente e più veloce. Ciò è possibile se si archiviano i dati in memoria utilizzando una cache come NCache ed elaborarlo in millisecondi.
In genere, un sistema di rilevamento delle frodi contiene tre sottosistemi, come illustrato nella Figura 1:
- Sistema Near Real-Time (NRT): Questo sistema elabora l'input ei risultati vengono generati utilizzando schemi e regole predefiniti, invece di eseguire il calcolo effettivo. Inoltre, i risultati devono essere in millisecondi poiché risponde direttamente all'utente. Lo scopo principale di questo sistema è un'elevata velocità effettiva con bassa latenza, il che significa che questo sistema dovrebbe idealmente essere nella memoria locale per ottenere prestazioni più elevate.
- Sistema di elaborazione degli input: Questo sistema può richiedere da minuti a ore per l'elaborazione dell'input e la regolazione dei parametri del sistema NRT. Queste informazioni aggiornate vengono inviate al sistema di elaborazione offline, che elabora ulteriormente algoritmi di apprendimento automatico su di esso.
- Sistema di elaborazione offline Questo sistema può richiedere da ore a mesi per rispondere. Questo sistema migliora il modello, addestra i dati e invia questi dati aggiornati al sistema NRT per ottenere risultati migliori.
NCache come cache in memoria e bus di messaggistica Pub/Sub
NCache è una cache distribuita in memoria che offre potenti messaggi Pub/Sub e altre funzionalità come le strutture dati distribuite. Tenendo sotto controllo i sistemi coinvolti in un sistema di rilevamento delle frodi, NCache si adatta perfettamente al sistema Near-Real-Time System poiché richiede risultati rapidissimi. Questo è possibile come NCache può essere utilizzato per la comunicazione tra più elementi e per archiviare i dati più vicini all'applicazione, riducendo ulteriormente le chiamate di rete per recuperare i dati.
Abbiamo creato un sistema di rilevamento delle frodi di esempio in .NET che include NCache per migliorare le prestazioni e la produttività. Puoi trovare il campione di lavoro qui su GitHub.
A un livello superiore, l'applicazione funziona come tale:
- L'applicazione client comunica con il Transaction Request Manager che gestisce la transazione del cliente specificato.
- Le informazioni sulla transazione vengono pubblicate come messaggio al Argomento Pub/Sub.
- Il Fraud Detection Manager si iscrive a questo argomento e riceve il messaggio di transazione.
- La logica di rilevamento delle frodi viene eseguita sull'articolo e il risultato viene inviato al gestore delle transazioni che viene rispedito all'applicazione client.
- Le informazioni sul cliente vengono quindi archiviate nella cache utilizzando Strutture dati distribuite come Liste. Questo aiuterà a prendere decisioni sulle transazioni future molto più facilmente.
- I dati vengono mantenuti nel database utilizzando Scrivi dietro.
Gestione delle transazioni con Pub/Sub
Il Transaction Request Manager viene inizializzato con la cache. Transaction Request Manager crea la transazione come messaggio e la pubblica nel relativo argomento.
1 2 3 4 5 |
public void CreateRelevantSubscription() { MessageReceivedCallback transactionmessageReceivedCallback = new TransactionCompletedMessage(this).MessageReceivedCallback; transactionSubscription = base.CreateRelevantSubscriptions(Topics.REPLIESTOPICS, transactionmessageReceivedCallback); } |
Ogni volta che una transazione viene effettuata tramite il Gestore delle richieste di transazione, crea prima un messaggio dalle informazioni sul cliente e quindi lo pubblica come messaggio sull'argomento della transazione. Questo argomento è sottoscritto dal Fraud Detection Manager, che riceve il messaggio ed esegue la logica di rilevamento delle frodi sul messaggio in arrivo e invia i risultati al Transaction Request Manager.
1 2 3 4 5 |
// Sending messages on the respective topic if (customer != null) { ncache.PublishMessageOnTopic(Topics.TRANSACTIONTOPICS, CreateTransactionFromCustomer(customer), null); } |
Rilevamento delle frodi in tempo reale
Il rilevatore di frodi contiene una logica completa per verificare se una transazione è valida o meno. Si comporta come un gestore per eseguire tutte le transazioni e stabilire una connessione con la memoria cache. Il Fraud Detection Manager viene inizializzato creando un argomento in NCache e iscrivendoti a questo argomento. Il callback per l'argomento Gestore rilevamento frode esiste nella logica Gestore richiesta transazione poiché invia i risultati della logica rilevamento frode al Gestore richiesta transazione.
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); } |
Nella logica di rilevamento delle frodi, in primo luogo, i dati di un cliente vengono recuperati dalla memoria, se è presente, verifichiamo se l'ultima transazione in memoria è stata fraudolenta, se sì, dichiariamo anche questa transazione come un errore. Se non vengono ricevute tali informazioni e tutte le transazioni in memoria sono valide, eseguiamo la logica già appresa su questi dati.
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; } |
In questa logica appresa, utilizziamo più fattori per determinare la validità della transazione. Verifichiamo se una transazione ha avuto origine da un indirizzo IP valido e un indirizzo email valido che si trova in un dominio appropriato. Inoltre, l'e-mail non dovrebbe esistere in una gamma di e-mail sospette. Viene inoltre verificato se la transazione ha avuto origine da una posizione sospetta. Se uno dei criteri precedenti non riesce, il peso del fallimento viene incrementato. Se il peso dell'errore è maggiore del peso della decisione, la transazione non è valida. Puoi trovare il codice per questo logica su GitHub.
Memorizzazione nella cache dei risultati e mantienili nel database
Una volta dichiarato il risultato, il risultato viene aggiunto/aggiornato nella cache.
1 2 |
FraudRequest fraudRequest = CreateFraudRequest(transactionMessage, result); ncache.UpdateCustomerInfoInCache(customerkey, fraudRequest); |
La cache è configurata per l'origine dati. Per archiviare le informazioni sui clienti nel cluster in memoria, abbiamo utilizzato NCache'S liste distribuite, che sono una delle strutture dati distribuite. Le informazioni sui clienti vengono mantenute anche nel database che utilizza Scrivi dietro, che aggiorna in modo asincrono le informazioni sul 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); } |
Una volta memorizzato nella cache, viene creato un nuovo messaggio da questo risultato e ripubblicato sull'argomento sottoscritto dal Transaction Request Manager. Riceve il messaggio e pubblica il risultato nell'applicazione client.
Conclusione
NCache è una cache .NET in memoria distribuita che include molteplici funzionalità come Pub/Sub, strutture dati distribuite, provider di origini dati e altro ancora. Lo scopo dell'archiviazione e dell'elaborazione dei dati nella memoria locale è l'eliminazione del costo del trasferimento di rete, poiché tutta l'elaborazione viene eseguita tramite la cache e i risultati vengono successivamente aggiornati sul database.
Mi è piaciuto leggere l'articolo sopra, spiega davvero tutto in dettaglio, l'articolo è molto interessante ed efficace. Grazie e buona fortuna con i prossimi articoli.