MongoDB est un NoSQL base de données, en particulier pour les bases de données modernes .NET applications. Cependant, il repose toujours sur disque, ce qui peut entraîner des problèmes de performances dans les situations de trafic important, malgré sa flexibilité. évolutivité, et puissant interroger capacités. C'est ici que NCache, une solution de mise en cache distribuée en mémoire, arrive.
Présentation NCache En tant que couche de cache pour MongoDB, elle permet aux applications .NET de réduire considérablement les requêtes de base de données, d'améliorer les temps de réponse et de gérer efficacement des volumes de transactions élevés. Cet article explique comment l'intégrer. NCache avec MongoDB, les meilleures pratiques pour la mise en cache des résultats de requêtes et les stratégies pour maintenir la synchronisation entre le cache et la base de données.
Ce guide explique quand mettre en cache les données MongoDB, quelles données ne doivent pas l'être et comment les applications .NET peuvent synchroniser en toute sécurité le cache et la base de données. Il est particulièrement utile pour les API à forte intensité de lecture, les tableaux de bord et les microservices à fort trafic. En bref : MongoDB reste le système d'enregistrement, tandis que NCache sert de couche de lecture en mémoire à haute vitesse.
Points clés à retenir
- MongoDB est basé sur disque, Ce qui constitue souvent un goulot d'étranglement en termes de performances pour les applications .NET à fort trafic. C'est là qu'une couche de cache en mémoire réduit considérablement la charge sur la base de données.
- NCache fait office de cache distribué en mémoire pour MongoDB, permettant ainsi de servir les données fréquemment consultées à partir du cache plutôt que de la base de données, ce qui se traduit par des performances plus rapides et une meilleure évolutivité.
- Le cache client dans NCache offre des vitesses InProc pour l'application car elle se situe à l'intérieur du processus de l'application tout en restant synchronisée avec le cache distribué.
- Le modèle Cache-Aside est couramment utilisé avec MongoDB, où l'application vérifie d'abord NCache pour les données, puis accède à MongoDB uniquement si les données ne sont pas trouvées dans le cache.
- Les flux de modifications de MongoDB peuvent être utilisés pour maintenir la synchronisation des données du cache. activer les mises à jour du cache en temps réel chaque fois que des documents sont insérés, mis à jour ou supprimés dans MongoDB.
- NCache permet d'effectuer des requêtes de type SQL sur les données MongoDB mises en cache, permettant de filtrer et de rechercher plus intelligemment les objets mis en cache sans interroger directement MongoDB.
- La mise en cache de collections entières ou de documents individuels dépend des modèles d'accès : La mise en cache en masse améliore les lectures par lots, tandis que la mise en cache au niveau de l'élément avec des étiquettes permet un contrôle précis et une invalidation sélective.
- NCache est parfaitement adapté aux applications .NET utilisant MongoDB, offrant une mise en cache native des objets .NET et des fonctionnalités de mise en cache côté serveur telles que la lecture directe et l'écriture différée.
Figure : Cache distribué utilisant MongoDB
Pourquoi la mise en cache est-elle essentielle aux performances de MongoDB ?
Il est bénéfique pour les applications .NET pour les raisons suivantes :
- Stockage flexible basé sur des documents:Cela simplifie l'organisation des données grâce à sa conception sans schéma.
- Architecture distribuée: Permet réplication et partitionnement pour l'évolutivité.
- Index & Cadre d'agrégation : Rend complexe requêtes efficace.
- Flux de changement : Capture les modifications de données en temps réel via les flux de modifications.
Goulots d'étranglement des performances de MongoDB
Il présente les problèmes de performances suivants :
- Latence de lecture/écriture et surcharge d'E/S disque : MongoDB étant une base de données sur disque, les opérations de lecture et d'écriture fréquentes entraînent une latence plus élevée que les solutions en mémoire. La surcharge des E/S disque augmente avec le volume de données, ce qui impacte les temps de réponse et les performances globales du système.
- Requêtes sur de grands ensembles de données : Avec l’augmentation de la taille de l’ensemble de données, le temps d’exécution des requêtes augmente car il faut plus de temps pour analyser et traiter davantage de documents. Index sont utiles à cet égard mais ne sont pas toujours suffisantes, notamment lors du filtrage ou de l’agrégation de grands volumes de données.
- Évolutivité Défis: Bien qu'il dispose d'un support intégré pour la mise à l'échelle horizontale à l'aide du sharding, la gestion de clusters volumineux peut présenter des problèmes de réplication, l'équilibrage de chargeet la complexité du réseau. L'optimisation des performances devient cruciale à mesure que le volume de trafic augmente.
- Latence élevée pour les données fréquemment consultées : Les requêtes portant sur des données fréquemment consultées peuvent entraîner une dégradation des performances si elles atteignent la base de données de manière répétée au lieu d'être traitées par une couche de stockage plus rapide. Cela entraîne une augmentation de l'utilisation des ressources et des retards dans les temps de réponse.
Avantages de l'utilisation NCache avec MongoDB
NCache, un cache distribué en mémoire, est la meilleure option pour votre application MongoDB :
- Performances en mémoire: NCache est une solution de mise en cache 100 % en mémoire, éliminant les E/S disque et garantissant une latence ultra-faible pour une récupération plus rapide des données.
- Cache client (vitesse InProc):Réside sur le serveur d'applications à l'intérieur du processus d'application, minimisant les appels réseau et garantissant un accès rapide.
- Évolutivité linéaire: Évolue de manière dynamique en ajoutant des serveurs de cache à mesure que la charge de données augmente, évitant ainsi les goulots d'étranglement et garantissant des performances élevées.
- Haute Disponibilité:Assure un accès ininterrompu avec réplication et basculement automatiques, gardant le cache opérationnel même en cas de panne du serveur.
Architecture : Comment fonctionne la mise en cache dans MongoDB avec NCache
NCache s'intègre parfaitement à votre application grâce à son architecture dynamique :
- accompagne Lire à travers et Réécriture mise en cache pour réduire les requêtes directes sur la base de données.
- S'intègre parfaitement à .NET 8 et environnements cloud (Azure, AWS, Kubernetes).
Étape par étape : implémenter la mise en cache MongoDB avec NCache
Vous pouvez facilement implémenter la mise en cache MongoDB avec NCache comme démontré ci-dessous :
Mise en cache des résultats de requête dans MongoDB
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
ICache cache = CacheManager.GetCache("MongoDBCache"); string cacheKey = "Customer:EINSTEIN"; Customer customer = cache.Get<Customer>(cacheKey); if (customer == null) { var collection = new MongoClient("mongodb://your-mongodb-url") .GetDatabase("ECommerceDB") .GetCollection<Customer>("Customers"); customer = await collection.Find(x => x.Id == "EINSTEIN").FirstOrDefaultAsync(); if (customer != null) { cache.Insert(cacheKey, new CacheItem(customer) { Expiration = new Expiration(ExpirationType.Absolute, TimeSpan.FromMinutes(5)) }); } } |
Mise en cache d'une collection MongoDB en tant qu'élément unique
Vous pouvez facilement mettre en cache les collections MongoDB. Stocker une collection entière comme un seul élément de cache permet une récupération rapide en une seule opération, réduisant ainsi les accès au cache et améliorant les performances du traitement par lots ou du rendu de l'interface utilisateur.
|
1 2 3 4 5 6 7 8 9 10 |
var customersInGermany = await collection.Find(x => x.Country == "Germany").ToListAsync(); if (customersInGermany.Count > 0) { ICache cache = CacheManager.GetCache("MongoDBCache"); var cacheItem = new CacheItem(customersInGermany) { Expiration = new Expiration(ExpirationType.Absolute, TimeSpan.FromMinutes(10)) }; cache.Insert("Customers:Germany", cacheItem); } |
Mise en cache séparée des éléments de collection MongoDB
Vous pouvez facilement mettre en cache les collections MongoDB. Le stockage séparé de chaque élément garantit un accès individuel, tandis que l'utilisation d'étiquettes pour regrouper les éléments apparentés accélère la récupération en masse et améliore les performances des requêtes.
|
1 2 3 4 5 6 7 8 9 |
foreach (var customer in customersInGermany) { var cacheItem = new CacheItem(customer) { Tags = new Tag[] { new Tag("Customer:Country:Germany") }, Expiration = new Expiration(ExpirationType.Absolute, TimeSpan.FromMinutes(10)) }; cache.Insert($"Customer:CustomerID:{customer.Id}", cacheItem); } |
Synchronisez le cache et la base de données grâce aux flux de modifications.
Pour assurer la cohérence des données entre MongoDB et le cache, les flux de modifications permettent une synchronisation en temps réel en détectant inserts, mises à jour et suppressions. Chaque fois que les données changent, NCache peut supprimer ou mettre à jour l'entrée de cache correspondante, évitant ainsi les problèmes de données obsolètes.
|
1 2 3 4 5 6 7 8 9 |
var pipeline = new EmptyPipelineDefinition<ChangeStreamDocument<Customer>>() .Match("{ operationType: { $in: ['insert', 'update', 'replace', 'delete'] } }"); var cursor = collection.Watch(pipeline); await cursor.ForEachAsync(change => { string cacheKey = $"Customer:CustomerID:{change.FullDocument.Id}"; cache.Remove(cacheKey); }); |
Interrogation des données mises en cache dans NCache
NCache Permet aux utilisateurs d'interroger les données mises en cache à l'aide de requêtes SQL, réduisant ainsi la charge de la base de données tout en améliorant les performances des applications. Les requêtes indexées accélèrent les recherches et le filtrage des objets mis en cache.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
// Connect to NCache ICache cache = CacheManager.GetCache("MongoDBCache"); // Define NCache search query string query = "SELECT * FROM Models.Customer WHERE Country = ?"; var queryCommand = new QueryCommand(query); queryCommand.Parameters.Add("Country", "Germany"); // Execute query on cache ICacheReader reader = cache.SearchService.ExecuteReader(queryCommand); while (reader.Read()) { string contactName = reader.GetValue<string>("ContactName"); Console.WriteLine($"Contact Name: {contactName}"); } |
Comment configurer NCache pour MongoDB ?
Configurer NCache pour MongoDB, suivez les étapes ci-dessous :
A. Install NCache Projet
Pour installer le NCache client dans une application .NET, utilisez NuGet pour ajouter le package requis :
|
1 |
Install-Package Alachisoft.NCache.SDK |
Une fois installée, configurez votre application pour l'utiliser NCache pour la mise en cache des données.
B. Install NCache Server
Pour installer NCache Serveur sous Linux :
|
1 2 3 |
docker pull alachisoft/ncache:latest docker run -d --name ncache-server --network host alachisoft/ncache:latest docker exec -it ncache-server ncache service start |
C. Configure NCache pour MongoDB
Pour intégrer MongoDB avec NCache, Suivez ces étapes:
- Créer et configurer le cache :
|
1 2 |
New-Cache -Name MongoDBCache -Size 1024 -Topology PartitionReplica -Server 192.168.1.2 Add-Node -CacheName MongoDBCache -Server 192.168.1.3 |
- Modifier l'application .NET à utiliser NCache:
|
1 2 3 4 5 6 7 8 9 10 11 12 |
ICache cache = CacheManager.GetCache("MongoDBCache"); var collection = new MongoClient("mongodb://your-mongodb-url") .GetDatabase("ECommerceDB") .GetCollection<Customer>("Customers"); var customer = await collection.Find(x => x.Id == "EINSTEIN").FirstOrDefaultAsync(); if (customer != null) { cache.Insert("Customer:EINSTEIN", new CacheItem(customer) { Expiration = new Expiration(ExpirationType.Absolute, TimeSpan.FromMinutes(10)) }); } |
Conclusion
L'utilisation de NCache Avec MongoDB, les performances des applications sont optimisées en réduisant la charge de la base de données, en améliorant les temps de réponse et en garantissant la cohérence des données en temps réel. Grâce à la mise en cache en mémoire, les applications bénéficient d'un accès aux données plus rapide, d'une latence réduite et d'une évolutivité fluide. NCacheL'architecture distribuée de offre une haute disponibilité et garantit la tolérance aux pannes, ce qui en fait un choix idéal pour les applications .NET modernes à fort trafic utilisant MongoDB.
Questions fréquentes
Q : Pourquoi utiliser NCache MongoDB est-il déjà évolutif ?
A: Bien que MongoDB offre une bonne scalabilité, les entrées/sorties disque finissent par constituer un goulot d'étranglement. NCache Elle décharge le trafic de lecture intensif vers la mémoire, ce qui est nettement plus rapide, permettant ainsi à la base de données de se concentrer sur les opérations d'écriture et les requêtes complexes.
Q : Comment le cache reste-t-il synchronisé avec la base de données ?
A: Comme indiqué en détail dans la section 6, NCache peut tirer parti des flux de modifications MongoDB pour écouter les mises à jour en temps réel dans la base de données et invalider ou mettre à jour les éléments mis en cache en conséquence, garantissant ainsi la cohérence des données.
Q : Puis-je utiliser SQL avec des données MongoDB ?
A: Vous ne pouvez pas exécuter directement des requêtes SQL sur MongoDB, mais une fois les objets à l'intérieur, c'est possible. NCache, Vous pouvez utiliser NCacheses capacités de requête SQL pour rechercher et filtrer des données à l'aide de la syntaxe SQL standard.
Q: est NCache mieux que Redis pour les applications .NET MongoDB ?
A: NCache est souvent préféré dans les environnements .NET car il est 100 % natif .NET, alors que Redis est basé sur Linux. Cela signifie NCache Il s'intègre parfaitement à l'écosystème Visual Studio, offre une meilleure sérialisation pour les objets .NET complexes et vous permet d'exécuter du code .NET côté serveur (comme les fournisseurs Read-Through/Write-Behind) directement sur les nœuds de cache. Redis ne peut pas le faire nativement.
Q : Dois-je convertir les documents BSON MongoDB avant la mise en cache ?
A: Oui. NCache MongoDB stocke des objets .NET natifs, et non des documents BSON. Vous devez désérialiser vos données BSON MongoDB en classes .NET standard (POCO) avant de les insérer dans le cache. Cela vous permet d'exploiter NCacheLes fonctionnalités d'interrogation et d'indexation SQL de , qui fonctionnent sur les attributs d'objet et non sur les octets BSON bruts.
Q: Peut NCache Écrire automatiquement les données dans MongoDB ?
A: Oui. Bien que ce guide se soit concentré sur le modèle « Cache-Aside » (où votre application met à jour manuellement la base de données), NCache supports Réécriture et Écriture derrière fournisseurs. Ceux-ci vous permettent de déléguer l'opération d'écriture à des prestataires. NCache, qui met ensuite à jour MongoDB de manière synchrone (Write-Through) ou asynchrone (Write-Behind) en arrière-plan, améliorant ainsi la latence de l'application.
Q : Que se passe-t-il si le NCache Le cluster tombe en panne ?
A: Votre application subira une dégradation progressive de ses performances tout en continuant de fonctionner. Le modèle standard « Cache-Aside » incluant une logique de repli (si le cache est vide, récupération des données depuis la base de données), votre application interrogera directement MongoDB. Les performances chuteront au niveau d'une application sans cache, mais aucune donnée ne sera perdue et l'application restera en ligne.
