Digamos que paga en un centro comercial con su tarjeta. Ahora estás en casa, no has salido por un tiempo y recibes un mensaje de tu banco que dice que has debitado $20000. ¿Cómo? ¡Lo que compraste te costó solo $ 120! Esto implicará un largo proceso de verificaciones con su banco, y el banco puede tardar meses en rastrear y resolver la transacción fraudulenta.
Sería mucho más fácil si se incorporara un mecanismo de detección de fraude en el sistema para que determine las transacciones no válidas y las falle en tiempo real. Sin embargo, esta decisión debe ser instantánea y el sistema debe entrenarse continuamente en función de los comportamientos anteriores del usuario. Por lo tanto, no puede esperar que los clientes esperen en el mostrador mientras su sistema de detección de fraude tarda en detectar cualquier anomalía. Necesita tener un sistema eficiente y más rápido. Esto es posible si almacena los datos en la memoria utilizando un caché como NCache y procesarlo en milisegundos.
Generalmente, un sistema de detección de fraude contiene tres subsistemas, como se ilustra en la Figura 1:
- Sistema de tiempo casi real (NRT): Este sistema procesa la entrada y los resultados se generan utilizando patrones y reglas predefinidos, en lugar de realizar el cálculo real. Además, los resultados deben ser en milisegundos ya que responde directamente al usuario. El objetivo principal de este sistema es un alto rendimiento con baja latencia, lo que significa que, idealmente, este sistema debería estar en la memoria local para lograr un mayor rendimiento.
- Sistema de procesamiento de entrada: Este sistema puede tardar de minutos a horas en procesar la entrada y ajustar los parámetros del sistema NRT. Esta información actualizada se alimenta al sistema de procesamiento fuera de línea, que procesa más algoritmos de aprendizaje automático en él.
- Sistema de procesamiento fuera de línea Este sistema puede tardar desde horas hasta meses en responder. Este sistema mejora el modelo, entrena los datos y envía estos datos actualizados al sistema NRT para obtener mejores resultados.
NCache como caché en memoria y bus de mensajería Pub/Sub
NCache es una memoria caché distribuida en memoria que ofrece potentes mensajes Pub/Sub y otras funciones, como estructuras de datos distribuidos. Teniendo en cuenta los sistemas involucrados en un sistema de detección de fraude, NCache encaja perfectamente en el sistema de tiempo casi real, ya que requiere resultados ultrarrápidos. Esto es posible como NCache se puede usar para la comunicación entre múltiples elementos, así como para almacenar datos más cerca de su aplicación, lo que reduce aún más las llamadas de red para obtener datos.
Hemos creado un sistema de detección de fraude de muestra en .NET que incluye NCache para mejorar el rendimiento y el rendimiento. Puede encontrar la muestra de trabajo aquí en GitHub.
En un nivel superior, la aplicación funciona como tal:
- La aplicación del cliente se comunica con el Administrador de solicitudes de transacciones que gestiona la transacción del cliente dado.
- La información de la transacción se publica como un mensaje al Tema de Pub/Sub.
- Fraud Detection Manager se suscribe a este tema y recibe el mensaje de transacción.
- La lógica de detección de fraude se realiza en el artículo y el resultado se envía al administrador de transacciones que se envía de vuelta a la aplicación del cliente.
- Luego, la información del cliente se almacena en el caché usando Estructuras de datos distribuidos como Listas. Esto ayudará a tomar decisiones sobre transacciones futuras mucho más fácil.
- Los datos se conservan en la base de datos utilizando escribir detrás.
Administrar transacciones con Pub/Sub
El Administrador de solicitudes de transacciones se inicializa con la memoria caché. Transaction Request Manager crea la transacción como un mensaje y la publica en su tema.
1 2 3 4 5 |
public void CreateRelevantSubscription() { MessageReceivedCallback transactionmessageReceivedCallback = new TransactionCompletedMessage(this).MessageReceivedCallback; transactionSubscription = base.CreateRelevantSubscriptions(Topics.REPLIESTOPICS, transactionmessageReceivedCallback); } |
Cada vez que se realiza una transacción a través del Administrador de solicitudes de transacción, primero crea un mensaje a partir de la información del cliente y luego lo publica como un mensaje sobre el tema de la transacción. Este tema está suscrito por el Administrador de detección de fraudes, que recibe el mensaje y realiza la lógica de detección de fraudes en el mensaje entrante y envía los resultados al Administrador de solicitudes de transacciones.
1 2 3 4 5 |
// Sending messages on the respective topic if (customer != null) { ncache.PublishMessageOnTopic(Topics.TRANSACTIONTOPICS, CreateTransactionFromCustomer(customer), null); } |
Detección de fraude en tiempo real
El Fraud Detector contiene una lógica completa para verificar si una transacción es válida o no. Se comporta como un controlador para realizar todas las transacciones y establecer una conexión con el almacenamiento en caché. El Administrador de detección de fraude se inicializa creando un tema en NCache y suscribiéndote a este tema. La devolución de llamada para el tema del Administrador de detección de fraudes existe en la lógica del Administrador de solicitudes de transacciones, ya que envía los resultados de la lógica de detección de fraudes al Administrador de solicitudes de transacciones.
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); } |
En la lógica de detección de fraude, primero, los datos de un cliente se extraen de la memoria, si están presentes allí, verificamos si alguna última transacción en memoria fue fraudulenta, en caso afirmativo, también declaramos esta transacción como una falla. Si no se recibe dicha información y todas las transacciones en memoria son válidas, realizamos la lógica ya aprendida en estos datos.
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; } |
En esta lógica aprendida, utilizamos múltiples factores para determinar la validez de la transacción. Verificamos si una transacción se originó a partir de una dirección IP válida y una dirección de correo electrónico válida que se encuentra en un dominio adecuado. Además, el correo electrónico no debería existir en un rango de correos electrónicos sospechosos. También se comprueba si la transacción se originó en algún lugar sospechoso. Si alguno de los criterios anteriores falla, se incrementa el peso de falla. Si el peso de falla es mayor que el peso de decisión, la transacción no es válida. Puedes encontrar el código para esto. lógica en GitHub.
Almacenamiento en caché de resultados y conservarlos en la base de datos
Una vez que se ha declarado el resultado, el resultado se agrega/actualiza en el caché.
1 2 |
FraudRequest fraudRequest = CreateFraudRequest(transactionMessage, result); ncache.UpdateCustomerInfoInCache(customerkey, fraudRequest); |
La memoria caché está configurada para el origen de datos. Para almacenar la información del cliente en el clúster en memoria, hemos utilizado NCache, listas distribuidas, que son una de las estructuras de datos distribuidos. La información de los clientes también se persiste en la base de datos utilizando Escritura posterior, que actualiza de forma asíncrona la información del 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 vez almacenado en caché, se crea un nuevo mensaje a partir de este resultado y se vuelve a publicar en el tema suscrito por Transaction Request Manager. Recibe el mensaje y publica el resultado en la aplicación cliente.
Conclusión
NCache es un caché .NET en memoria distribuido que viene con múltiples características como Pub/Sub, estructuras de datos distribuidas, proveedores de fuentes de datos y más. El propósito de almacenar y procesar datos en la memoria local es eliminar el costo de la transferencia de red, ya que todo el procesamiento se realiza a través del caché y los resultados se actualizan posteriormente en la base de datos.
Disfruté leyendo el artículo anterior, realmente explica todo en detalle, el artículo es muy interesante y efectivo. Gracias y suerte con los próximos artículos.