NCache, un cache distribué en mémoire, conserve vos données intactes dans un stockage temporaire pour une expérience plus rapide des opérations de lecture et d'écriture. Nous avons vu NCache faire des merveilles avec la vitesse quand il s'agit d'effectuer opérations sur le magasin de cache. Cependant, en gardant NCache synchronisée avec la source de données principale est un défi majeur en matière de cohérence des données. La source de données peut être n'importe quelle base de données ; cependant, ce blog concerne la synchronisation de votre cache avec PostgreSQL.
Points clés à retenir
Le projet : Il est essentiel de maintenir la cohérence entre un cache en mémoire et une base de données PostgreSQL afin d'éviter que les applications ne servent des données obsolètes.
Synchronisation événementielle : NCache Usages NotifyExtensibleDependency pour tirer parti des fonctionnalités natives de PostgreSQL LISTEN/NOTIFY mécanisme permettant à la base de données d'envoyer des mises à jour en temps réel au cache.
Invalidation immédiate : Lorsqu'une modification survient dans la base de données, un déclencheur envoie une notification à NCache, qui supprime immédiatement l'élément correspondant afin de garantir l'exactitude des données.
Capacité de rechargement automatique : En combinant les dépendances avec un ReadThruProvider et ResyncOptions, NCache peut automatiquement récupérer et recharger les dernières données de PostgreSQL instantanément après invalidation.
Pourquoi la synchronisation du cache avec PostgreSQL est-elle essentielle ?
La pile de votre application fonctionne avec NCache comme le cache réside en tant que couche de mise en cache entre la base de données et l'application. Votre application est directement connectée au cache, envoyant ainsi tous les appels d'opération directement au cache tels que la lecture ou l'écriture. Supposons qu'un autre utilisateur modifie quelque chose dans la base de données sans en informer le cache. Désormais, les données de la base de données sont différentes des données résidant dans le cache. Les deux copies séparées des données entraînent une incohérence des données, ce qui est un grand défi.
NCache DÉTAILS NCache Docs Synchroniser le cache avec PostgreSQL
NCache Synchronisation des données
Compte tenu du problème d'incohérence des données, NCache se précipite avec un correctif pour cela comme tout le reste. Ce que vous devez faire est de synchroniser votre cache avec la base de données en utilisant NCache synchronisation de la base de données techniques. La base de données discutée dans ce blog, comme mentionné précédemment, est PostgreSQL - une base de données relationnelle objet open source avec un ensemble de fonctionnalités bien développé et des performances et une fiabilité élevées. Nous avons une solution créée et téléchargée sur GitHub sur Synchronisation du cache avec PostgreSQL qui montre comment votre cache peut améliorer l'évolutivité et la cohérence des données.
Le schéma ci-dessous montre comment fonctionne NCache vous aider à garder les données synchronisées avec votre base de données PostgreSQL.
Figure 1 : Synchroniser le cache avec PostgreSQL
Méthodes de synchronisation NCache avec PostgreSQL
| Fonctionnalité | NotifyExtensibleDependency | Fournisseur ReadThru |
| Action principale | Supprime immédiatement l'élément du cache lorsque les données changent dans PostgreSQL. | Recharge automatiquement l'élément mis à jour depuis PostgreSQL dans le cache immédiatement après une modification. |
| Mécanisme | Utilise les fonctions natives LISTEN/NOTIFY et Pub/Sub de PostgreSQL pour recevoir des événements en temps réel. | Utilise une connexion directe à la base de données au sein de la logique du fournisseur pour récupérer des données actualisées. |
| Disponibilité des données | Les données sont supprimées, ce qui provoque un échec de cache lors de la requête suivante et déclenche alors une nouvelle récupération. | Les données restent disponibles et à jour sans provoquer d'erreur de cache, garantissant ainsi une interruption de lecture continue. |
| Meilleur cas d'utilisation | Idéal pour les données fréquemment modifiées mais consultées occasionnellement, car cela permet d'économiser de la mémoire. | Idéal pour les données de référence très demandées qui doivent toujours être présentes et à jour. |
NCache vous permet de garder vos données synchronisées avec PostgreSQL en utilisant NotifyExtensibleDependency, c'est une technique de synchronisation fournie par NCache pour garder le cache et la base de données synchronisés. NotifyExtensibleDependency est utilisé pour implémenter la technique d'invalidation des données à l'aide du système de notification de dépendance PostgreSQL. La dépendance PostgreSQL est construite sur le mécanisme LISTEN/NOTIFY qui est similaire au Modèle pub/sous.
En plus de la dépendance à la base de données, Fournisseur ReadThru est utilisé pour communiquer directement avec la source de données. NCache appelle le fournisseur pour charger les données de la source de données directement à l'aide de votre logique personnalisée. Cela permet de maintenir les données synchronisées et actualisées pour éviter des problèmes tels que les données obsolètes, tout en offrant une évolutivité améliorée et des opérations de lecture plus rapides.
Ainsi, les composants de base impliqués sont:
-
- NotifyExtensibleDependency : NCache s'enregistre auprès d'un canal spécifique en appelant LISTEN dans NotifyExtensibleDependency
Initializeméthode. Sur la base de données, une fonction TRIGGER est invoquée qui envoie une charge utile au canal et lors de l'écoute, en cas d'incohérence des données, les données sont supprimées du cache. - ReadThruProvider : ce fournisseur obtient automatiquement les données mises à jour, directement à partir de la base de données lors de la modification des données dans la base de données.
- NotifyExtensibleDependency : NCache s'enregistre auprès d'un canal spécifique en appelant LISTEN dans NotifyExtensibleDependency
NCache DÉTAILS Lire à travers Dépendance basée sur les notifications
Synchroniser le cache à l'aide de NotifyExtensibleDependency
NotifyExtensibleDependency est utilisé pour invalider les données en utilisant le mécanisme de PostgreSQL Dependency, qui fonctionne sur le modèle de Messagerie Pub/Sub et le modèle s'appelle Écouter/Notifier. Selon ce mécanisme, toute mise à jour dans la base de données est transmise au client écoutant sur un canal spécifique via une commande NOTIFY avec une charge utile supplémentaire contenant les informations. Le client dans notre cas spécifique est NCache et sur notification de tout changement dans la base de données, l'élément correspondant est supprimé du cache.
Regardons le code ci-dessous pour voir comment un élément est ajouté avec la dépendance PostgreSQL :
|
1 2 3 4 5 6 7 8 9 10 11 |
const string connectionString = "your-connection-string"; var customer = new Customer(); var cacheItem = new CacheItem(customer) { Dependency = new PostGreSQLDependency(connectionString, customer.customerid, "public", "customers", "customer_channel") }; var key = customer.customerid; var cache = CacheManager.GetCache("democache"); cache.Insert(key, cacheItem); |
Cependant, vous devez comprendre la mise en œuvre de PostgreSQLDependency et le code ci-dessous vous aidera. Le Initialize contient une chaîne de connexion pour se connecter à la base de données et s'enregistre pour notification lors de toute modification de données dans les données spécifiques.
Implémentation de la dépendance PostgreSQL dans .NET
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 |
public PostGreSQLDependency(string connectionString, string dependencyKey, string schema, string table, string channel) { _connectionString = connectionString.Trim(); _dependencyKey = dependencyKey.Trim(); _schema = schema.Trim(); _table = table.Trim(); _channel = channel.Trim(); } public override bool Initialize() { connection = new NpgsqlConnection(_connectionString); connection.Open(); ((NpgsqlConnection)connection).Notification += (o, e) => { var entity = JsonConvert.DeserializeObject(e.AdditionalInformation); if (entity.DependencyKey == _dependencyKey && entity.Table == _table && entity.Schema == _schema) { done = true; } }; using (var cmd = new NpgsqlCommand($"LISTEN {_channel};", (NpgsqlConnection)connection)) { cmd.ExecuteNonQuery(); } task = Task.Run(() => { while (true) { ((NpgsqlConnection)connection).Wait(); if (done) { break; } } this.DependencyChanged.Invoke(this); }); return true; } |
NCache DÉTAILS NCache Docs Synchroniser le cache avec PostgreSQL
Rechargement automatique des données à l'aide de la lecture
En utilisant la dépendance, chaque fois que les données sont modifiées dans la source de données, elles sont effacées du cache. Cependant, nous devons également recharger ces données dans le cache et pour cela NCache a une fonctionnalité appelée Source de sauvegarde. Nous offrons au fournisseur Read-Through la liberté d'ajouter votre logique personnalisée dans l'implémentation. Dans le cas spécifié, le fournisseur Read-Through charge les données de la base de données PostgreSQL. Vous devez configurer le fournisseur de lecture directe utiliser les outils de gestion auparavant.
L'utilisation des options de resynchronisation dans le fournisseur de lecture continue permet de synchroniser les données avec la base de données. Cependant, à l'intérieur du ProviderCacheItem, le CacheItem a une dépendance ajoutée avec lui, ce qui signifie que le nouvel élément ajouté dans le cache est livré avec une dépendance déjà ajoutée. Cela vous évite d'avoir à ajouter des dépendances encore et encore. Regarde le LoadFromSource méthode à l'intérieur du fournisseur Read-Through pour examiner l'implémentation :
Configuration de la logique de rechargement automatique
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
public ProviderCacheItem LoadFromSource(string key) { var query = $"SELECT customerid, address, country, city FROM customers WHERE customerid = '{key}'"; // Define a query returning a single row result set NpgsqlCommand command = new NpgsqlCommand(query, _connection as NpgsqlConnection); var reader = command.ExecuteReader(); ProviderCacheItem providerCacheItem = null; while (reader.Read()) { if (providerCacheItem == null) { var customer = new Customer() { customerid = reader[0] as string, address = reader[1] as string, country = reader[2] as string, city = reader[3] as string, }; providerCacheItem = new ProviderCacheItem(customer) { Dependency = new PostGreSQLDependency(_connectionString, customer.customerid, "public", "customers", "customer_channel"), ResyncOptions = new ResyncOptions(true) }; } } } |
L'ajout de l'élément avec lecture immédiate charge simplement les éléments modifiés directement dans le cache à l'aide de dépendance de la base de données. Par conséquent, votre cache reste synchronisé avec la base de données PostgreSQL et tous vos problèmes de données obsolètes disparaissent.
Conclusion
Pour tout mettre dans le blog en termes simples, votre cache et votre base de données doivent rester synchronisés les uns avec les autres. Si le cache n'est pas au courant des modifications apportées à la base de données, votre application peut continuer à fonctionner et à travailler avec des données de cache obsolètes. Ce problème est résolu très efficacement avec NCache Fonctionnalité de dépendance PostgreSQL. Il y a des tonnes d'autres fonctionnalités intéressantes que vous pouvez voir en allant simplement sur NCache site.
NCache DÉTAILS Comparaison Des Éditions NCache Télécharger
Questions fréquentes
Q: Comment NCache Détecter les modifications dans PostgreSQL sans interrogation ?
A: NCache utilise l' NotifyExtensibleDependency classe pour s'inscrire en tant que client sur le serveur PostgreSQL LISTEN/NOTIFY Des canaux permettent à la base de données d'envoyer des notifications de mise à jour au cache en temps réel, évitant ainsi la surcharge de performance liée à une interrogation constante de la base de données.
Q : Quelle est la différence entre l'invalidation et la lecture directe ?
A : L'invalidation supprime simplement les données obsolètes du cache lorsque la base de données est modifiée. Lecture directe, en particulier avec ResyncOptions, va encore plus loin en récupérant et en rechargeant automatiquement les nouvelles données dans le cache immédiatement après l'invalidation, garantissant ainsi la disponibilité permanente des données.
Q : Dois-je modifier ma base de données PostgreSQL ?
A : Oui, vous devrez créer un TRIGGER Fonction dans PostgreSQL qui envoie une notification à un canal spécifique chaque fois que des données sont insérées, mises à jour ou supprimées dans les tables surveillées.
Q : Cette solution est-elle évolutive pour les applications à haut volume de transactions ?
R : Oui. Parce qu'il utilise un modèle Pub/Sub asynchrone appelé PostgreSQL Dependency plutôt que des requêtes fréquentes à la base de données, il minimise la charge sur le serveur de base de données et s'adapte efficacement aux environnements d'entreprise.
