Disons que vous payez dans un magasin avec votre carte. Vous êtes maintenant chez vous, vous n'êtes pas sorti depuis un moment et vous recevez un message de votre banque indiquant que vous avez débité 20000 120 $. Comment? Ce que vous avez acheté ne vous a coûté que XNUMX $ ! Cela impliquera un long processus de vérifications auprès de votre banque, et la banque peut prendre des mois pour retrouver et résoudre la transaction frauduleuse.
Ce serait beaucoup plus facile si un mécanisme de détection des fraudes était intégré au système afin qu'il détermine les transactions invalides et les échoue en temps réel. Cependant, cette décision doit être instantanée et le système doit s'entraîner en permanence en fonction des comportements passés de l'utilisateur. Par conséquent, vous ne pouvez pas vous attendre à ce que les clients attendent au comptoir pendant que votre système de détection de fraude prend du temps à détecter toute anomalie. Vous avez besoin d'un système efficace et plus rapide. Cela est possible si vous stockez les données en mémoire à l'aide d'un cache tel que NCache et traitez-le en quelques millisecondes.
Généralement, un système de détection de fraude contient trois sous-systèmes, comme illustré à la figure 1 :
- Système en temps quasi réel (NRT) : Ce système traite l'entrée et les résultats sont générés à l'aide de modèles et de règles prédéfinis, au lieu d'effectuer le calcul proprement dit. De plus, les résultats doivent être en millisecondes car il répond directement à l'utilisateur. L'objectif principal de ce système est un débit élevé avec une faible latence, ce qui signifie que ce système devrait idéalement être dans la mémoire locale pour obtenir des performances plus élevées.
- Système de traitement des entrées : Ce système peut prendre de quelques minutes à plusieurs heures pour traiter l'entrée et ajuster les paramètres du système NRT. Ces informations mises à jour sont transmises au système de traitement hors ligne, qui traite ensuite les algorithmes d'apprentissage automatique.
- Système de traitement hors ligne Ce système peut prendre des heures à des mois, pour répondre. Ce système améliore le modèle, entraîne les données et renvoie ces données mises à niveau au système NRT pour de meilleurs résultats.
NCache en tant que cache en mémoire et bus de messagerie Pub/Sub
NCache est un cache distribué en mémoire qui offre une puissante messagerie Pub/Sub et d'autres fonctionnalités telles que les structures de données distribuées. En gardant à l'esprit les systèmes impliqués dans un système de détection de fraude, NCache s'intègre parfaitement dans le système en temps quasi réel car il nécessite des résultats extrêmement rapides. Ceci est possible comme NCache peut être utilisé pour la communication entre plusieurs éléments ainsi que pour stocker les données les plus proches de votre application, ce qui réduit encore les appels réseau pour récupérer les données.
Nous avons créé un exemple de système de détection de fraude dans .NET qui comprend NCache pour améliorer les performances et le débit. Vous pouvez trouver l'échantillon de travail ici sur GitHub.
À un niveau supérieur, l'application fonctionne comme telle :
- L'application cliente communique avec le gestionnaire de demande de transaction qui gère la transaction du client donné.
- Les informations sur la transaction sont publiées sous forme de message au Sujet Pub/Sub.
- Le gestionnaire de détection de fraude s'abonne à ce sujet et reçoit le message de transaction.
- La logique de détection de fraude est effectuée sur l'article et le résultat est envoyé au gestionnaire de transaction qui est renvoyé à l'application cliente.
- Les informations client sont ensuite stockées dans le cache à l'aide de Structures de données distribuées telles que les listes. Cela aidera à prendre des décisions sur les transactions futures beaucoup plus facilement.
- Les données sont conservées dans la base de données à l'aide de Écriture derrière.
Gérer les transactions avec Pub/Sub
Le Transaction Request Manager est initialisé avec le cache. Transaction Request Manager crée la transaction sous forme de message et la publie dans sa rubrique.
1 2 3 4 5 |
public void CreateRelevantSubscription() { MessageReceivedCallback transactionmessageReceivedCallback = new TransactionCompletedMessage(this).MessageReceivedCallback; transactionSubscription = base.CreateRelevantSubscriptions(Topics.REPLIESTOPICS, transactionmessageReceivedCallback); } |
Chaque fois qu'une transaction est effectuée via le gestionnaire de demandes de transaction, il crée d'abord un message à partir des informations client, puis le publie sous forme de message sur le sujet de la transaction. Cette rubrique est souscrite par le Fraud Detection Manager, qui reçoit le message et exécute la logique de détection de fraude sur le message entrant et renvoie les résultats au Transaction Request Manager.
1 2 3 4 5 |
// Sending messages on the respective topic if (customer != null) { ncache.PublishMessageOnTopic(Topics.TRANSACTIONTOPICS, CreateTransactionFromCustomer(customer), null); } |
Détecter la fraude en temps réel
Le détecteur de fraude contient une logique complète pour vérifier si une transaction est valide ou non. Il se comporte comme un gestionnaire pour effectuer toutes les transactions et établir une connexion avec le stockage en cache. Le gestionnaire de détection de fraude est initialisé en créant un sujet dans NCache et abonnez-vous à ce sujet. Le rappel pour la rubrique du gestionnaire de détection de fraude existe dans la logique du gestionnaire de demande de transaction car il renvoie les résultats de la logique de détection de fraude au gestionnaire de demande de transaction.
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); } |
Dans la logique de détection de fraude, d'abord, une donnée client est extraite de la mémoire, si elle y est présente, nous vérifions si une dernière transaction en mémoire était frauduleuse, si oui, nous déclarons également cette transaction comme un échec. Si aucune information de ce type n'est reçue et que toutes les transactions en mémoire sont valides, nous exécutons la logique déjà apprise sur ces données.
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; } |
Dans cette logique apprise, nous utilisons plusieurs facteurs pour déterminer la validité de la transaction. Nous vérifions si une transaction provient d'une adresse IP valide et d'une adresse e-mail valide qui se trouve dans un domaine approprié. De plus, l'e-mail ne doit pas exister dans une série d'e-mails suspects. Il est également vérifié si la transaction provient d'un endroit suspect. Si l'un des critères ci-dessus échoue, le poids d'échec est incrémenté. Si le poids d'échec est supérieur au poids de décision, la transaction est invalide. Vous pouvez trouver le code pour cela logique sur GitHub.
Mettre en cache les résultats et les conserver dans la base de données
Une fois le résultat déclaré, le résultat est ajouté/mis à jour dans le cache.
1 2 |
FraudRequest fraudRequest = CreateFraudRequest(transactionMessage, result); ncache.UpdateCustomerInfoInCache(customerkey, fraudRequest); |
Le cache est configuré pour la source de données. Pour stocker les informations client dans le cluster en mémoire, nous avons utilisé NCache's listes distribuées, qui sont l'une des structures de données distribuées. Les informations des clients sont également conservées dans la base de données à l'aide de Écriture derrière, qui met à jour de manière asynchrone les informations client.
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); } |
Une fois mis en cache, un nouveau message est créé à partir de ce résultat et republié sur le sujet souscrit par le gestionnaire de demandes de transaction. Il reçoit le message et publie le résultat dans l'application cliente.
Conclusion
NCache est un cache .NET en mémoire distribué doté de plusieurs fonctionnalités telles que Pub/Sub, des structures de données distribuées, des fournisseurs de sources de données, etc. Le but du stockage et du traitement des données dans la mémoire locale est d'éliminer le coût du transfert réseau, car tout le traitement est effectué via le cache et les résultats sont ensuite mis à jour sur la base de données.
J'ai bien aimé lire l'article ci-dessus, explique vraiment tout en détail, l'article est très intéressant et efficace. Merci et bonne chance pour les prochains articles.