Come utilizzare la memorizzazione nella cache con MongoDB per migliorare le prestazioni

MongoDB è un popolare NoSQL database, in particolare per i moderni .NET applicazioni. Tuttavia, è ancora basato su disco, il che potrebbe portare a problemi di prestazioni in situazioni con traffico significativo, nonostante la sua flessibilità, modulabilità e potente interrogazione capacità. Qui è dove NCache, una soluzione di caching distribuito in memoria.

Presentiamo NCache Come livello di caching per MongoDB, consente alle applicazioni .NET di ridurre drasticamente le query sul database, migliorare i tempi di risposta e gestire in modo efficiente elevati volumi di transazioni. Questo articolo spiega come integrare NCache con MongoDB, best practice per la memorizzazione nella cache dei risultati delle query e strategie per mantenere sincronizzati cache e database.

Questa guida spiega quando memorizzare nella cache i dati di MongoDB, quali dati non dovrebbero essere memorizzati nella cache e come le applicazioni .NET possono mantenere sincronizzati in modo sicuro cache e database. È particolarmente utile per API ad alta intensità di lettura, dashboard e microservizi ad alto traffico. In breve: MongoDB rimane il sistema di registrazione, mentre NCache funge da livello di lettura in memoria ad alta velocità.

Punti chiave

MongoDB è basato su disco, che spesso diventa un collo di bottiglia per le prestazioni delle applicazioni .NET ad alto traffico. È qui che un livello di caching in memoria riduce significativamente il carico sul database.
NCache agisce come una cache distribuita in memoria per MongoDB, consentendo di utilizzare i dati a cui si accede di frequente dalla cache anziché dal database, ottenendo prestazioni più rapide e una migliore scalabilità.
La cache del client in NCache fornisce velocità InProc per l'applicazione perché si trova all'interno del processo dell'applicazione e tuttavia rimane sincronizzato con la cache distribuita.
Il modello Cache-Aside è comunemente utilizzato con MongoDB, dove l'applicazione prima controlla NCache per i dati e poi passa a MongoDB solo se i dati non vengono trovati nella cache.
I flussi di modifiche MongoDB possono essere utilizzati per mantenere sincronizzati i dati della cache, abilitando gli aggiornamenti della cache in tempo reale ogni volta che i documenti vengono inseriti, aggiornati o eliminati in MongoDB.
NCache consente query in stile SQL sui dati MongoDB memorizzati nella cache, rendendo possibile filtrare e ricercare gli oggetti memorizzati nella cache in modo più intelligente senza dover interrogare direttamente MongoDB.
La memorizzazione nella cache di intere raccolte o di singoli documenti dipende dai modelli di accesso: La memorizzazione nella cache di massa migliora le letture in batch, mentre la memorizzazione nella cache a livello di elemento con tag consente un controllo dettagliato e un'invalidazione selettiva.
NCache è adatto per le applicazioni .NET che utilizzano MongoDB, offrendo funzionalità di caching nativo degli oggetti .NET e di caching lato server come Read-Through e Write-Behind.

Figura: Cache distribuita utilizzando MongoDB

Perché la memorizzazione nella cache è fondamentale per le prestazioni di MongoDB?

È vantaggioso per le applicazioni .NET per i seguenti motivi:

Archiviazione flessibile basata su documenti: Ciò semplifica l'organizzazione dei dati grazie alla sua progettazione senza schema.
Architettura distribuita: Consente replicazione di and partizionamento per la scalabilità.
Indici & Quadro di aggregazione: Rende complesso query efficiente.
Cambia flussi: Acquisisce modifiche ai dati in tempo reale tramite Change Streams.

Colli di bottiglia delle prestazioni di MongoDB

Presenta i seguenti problemi di prestazioni:

Latenza di lettura/scrittura e sovraccarico di I/O su disco: Poiché MongoDB è un database basato su disco, le frequenti operazioni di lettura e scrittura comportano una latenza maggiore rispetto alle soluzioni in memoria. Il sovraccarico di I/O su disco aumenta con l'aumentare del volume dei dati, influendo sui tempi di risposta e sulle prestazioni complessive del sistema.
Query su set di dati di grandi dimensioni: Con l'aumento delle dimensioni del set di dati, aumenta anche il tempo di esecuzione delle query, perché occorre più tempo per analizzare ed elaborare più documenti. Indici sono utili a questo proposito, ma non sempre sono sufficienti, soprattutto quando si filtrano o si aggregano grandi volumi di dati.
Scalabilità sfide: Sebbene abbia un supporto integrato per il ridimensionamento orizzontale tramite sharding, la gestione di cluster di grandi dimensioni può presentare problemi di replicazione, bilancio del caricoe complessità di rete. L'ottimizzazione delle prestazioni diventa critica man mano che aumenta il volume del traffico.
Elevata latenza per dati a cui si accede frequentemente: Le query per dati a cui si accede di frequente possono portare a un degrado delle prestazioni se colpiscono ripetutamente il database anziché essere servite da un livello di archiviazione più veloce. Ciò causa un aumento dell'utilizzo delle risorse e ritardi nei tempi di risposta.

I vantaggi dell'utilizzo di NCache con MongoDB

NCache, una cache distribuita in memoria, è l'opzione migliore per la tua applicazione MongoDB:

Prestazioni in memoria: NCache è una soluzione di caching al 100% in memoria, che elimina l'I/O su disco e garantisce una latenza estremamente bassa per un recupero più rapido dei dati.
Cache client (velocità InProc): Risiede sul server applicativo all'interno del processo applicativo, riducendo al minimo le chiamate di rete e garantendo un accesso rapido.
Scalabilità lineare: Si espande dinamicamente aggiungendo server cache man mano che aumenta il carico di dati, prevenendo colli di bottiglia e garantendo prestazioni elevate.
Alta disponibilità: Garantisce un accesso ininterrotto con replicazione e failover automatici, mantenendo la cache operativa anche in caso di guasti del server.

Architettura: come funziona la memorizzazione nella cache in MongoDB con NCache

NCache si adatta perfettamente alla tua applicazione grazie alla sua architettura dinamica:

supporti Leggi tutto and Scrivere attraverso memorizzazione nella cache per ridurre le query dirette al database.
Si integra perfettamente con .NET 8 e ambienti cloud (azzurro, AWS, kubernetes).

Procedura dettagliata: implementare la memorizzazione nella cache di MongoDB con NCache

È possibile implementare facilmente la memorizzazione nella cache di MongoDB con NCache come dimostrato di seguito:

Memorizzazione nella cache dei risultati delle query in MongoDB

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))

});

}

Memorizzazione nella cache della raccolta MongoDB come singolo elemento
È possibile memorizzare nella cache le collezioni MongoDB in modo semplice. Memorizzare un'intera collezione come un singolo elemento nella cache consente un rapido recupero in un'unica operazione, riducendo le ricerche nella cache e migliorando le prestazioni di elaborazione batch o di rendering dell'interfaccia utente.

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);

}

Memorizzazione nella cache separata degli elementi della raccolta MongoDB
È possibile memorizzare nella cache le raccolte MongoDB in modo semplice. Memorizzare ogni elemento separatamente garantisce l'accesso individuale, mentre l'utilizzo di tag per raggruppare gli elementi correlati velocizza il recupero in blocco e migliora le prestazioni delle query.

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);

}

Mantieni sincronizzati cache e database utilizzando flussi di modifiche

Per garantire la coerenza dei dati tra MongoDB e la cache, i flussi di modifiche consentono la sincronizzazione in tempo reale rilevando Inserti, aggiornamentie eliminazioniOgni volta che i dati cambiano, NCache può rimuovere o aggiornare la voce della cache corrispondente, prevenendo problemi di dati obsoleti.

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);

});

Interrogazione dei dati memorizzati nella cache in NCache

NCache consente agli utenti di interrogare i dati memorizzati nella cache tramite query SQL, riducendo il carico del database e migliorando le prestazioni dell'applicazione. Le query indicizzate consentono ricerche e filtri più rapidi sugli oggetti memorizzati nella cache.

// 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}");

}

Come configurare NCache per MongoDB?

Da configurare NCache per MongoDB, seguire i passaggi sottostanti:

A. Installare NCache .
Per installare il NCache client in un'applicazione .NET, utilizzare NuGet per aggiungere il pacchetto richiesto:

1	Install-Package Alachisoft.NCache.SDK

Una volta installata, configura l'applicazione per utilizzarla NCache per la memorizzazione dei dati nella cache.

B. Installare NCache server
Per installare NCache Server su Linux:

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. Configurare NCache per MongoDB
Per integrare MongoDB con NCache, Segui questi passi:

Crea e configura la 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

Modificare l'applicazione .NET da utilizzare NCache:

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))

});

}

Conclusione

utilizzando NCache con MongoDB migliora le prestazioni delle applicazioni riducendo il carico del database, migliorando i tempi di risposta e garantendo la coerenza dei dati in tempo reale. Sfruttando la memorizzazione nella cache in memoria, le applicazioni beneficiano di un accesso ai dati più rapido, di una latenza inferiore e di una scalabilità senza soluzione di continuità. NCacheL'architettura distribuita di fornisce elevata disponibilità e assicura tolleranza agli errori, rendendolo la scelta ideale per le moderne applicazioni .NET ad alto traffico che utilizzano MongoDB.

Domande frequenti (FAQ)

D: Perché usare NCache se MongoDB è già scalabile?
A: Sebbene MongoDB sia ben scalabile, l'I/O su disco alla fine diventa un collo di bottiglia. NCache scarica il traffico di lettura pesante sulla memoria, operazione notevolmente più rapida, consentendo al database di concentrarsi sulle operazioni di scrittura e sulle query complesse.

D: Come fa la cache a rimanere sincronizzata con il database?
A: Come dettagliato nella Sezione 6, NCache può sfruttare MongoDB Change Streams per ascoltare gli aggiornamenti in tempo reale nel database e invalidare o aggiornare di conseguenza gli elementi memorizzati nella cache, garantendo la coerenza dei dati.

D: Posso usare SQL con i dati MongoDB?
A: Non è possibile eseguire SQL direttamente su MongoDB, ma una volta che gli oggetti sono all'interno NCache, Puoi usare NCacheCapacità di query SQL per cercare e filtrare i dati utilizzando la sintassi SQL standard.

D: È NCache meglio Redis per le applicazioni .NET MongoDB?
A: NCache è spesso preferito negli ambienti .NET perché è .NET nativo al 100%, mentre Redis è basato su Linux. Ciò significa NCache si adatta perfettamente all'ecosistema di Visual Studio, offre una migliore serializzazione per oggetti .NET complessi e consente di eseguire codice .NET lato server (come i provider Read-Through/Write-Behind) direttamente sui nodi della cache, che Redis non può essere fatto in modo nativo.

D: Devo convertire i documenti MongoDB BSON prima di memorizzarli nella cache?
A: Sì. Le serrature scorrevoli portatili e i catenacci a superficie possono essere usati per mettere in sicurezza una porta a scomparsa dall'esterno. Alcuni kit con catena di sicurezza consentono anche il bloccaggio esterno con chiave o manopola girevole. NCache memorizza oggetti .NET nativi, non documenti BSON. È consigliabile deserializzare i dati BSON di MongoDB in classi .NET standard (POCO) prima di inserirli nella cache. Questo consente di sfruttare NCacheFunzionalità di query e indicizzazione SQL, che funzionano sugli attributi degli oggetti e non sui byte BSON grezzi.

D: Can NCache scrivere automaticamente i dati su MongoDB?
A: Sì. Sebbene questa guida si sia concentrata sul modello "Cache-Aside" (in cui l'app aggiorna manualmente il DB), NCache supporta Scrivere attraverso and Scrivi dietro provider. Questi consentono di delegare l'operazione di scrittura a NCache, che aggiorna MongoDB in modo sincrono (Write-Through) o asincrono (Write-Behind) in background, migliorando ulteriormente la latenza dell'applicazione.

D: Cosa succede se il NCache il cluster si blocca?
A: L'applicazione subirà un degrado graduale, ma continuerà a funzionare. Poiché il modello standard "Cache-Aside" include una logica di fallback (se la cache è nulla -> recupera dal database), l'applicazione inizierà semplicemente a interagire direttamente con MongoDB. Le prestazioni scenderanno a livelli non memorizzati nella cache, ma non verranno persi dati e l'applicazione rimarrà online.