Con il rapido aumento delle applicazioni ad alto traffico, la scalabilità è la necessità di questa era. Per questo motivo, i sistemi di cache distribuita si sono fatti strada nel cuore e nell'anima delle applicazioni odierne. NCache – la principale cache distribuita per le applicazioni .NET, non fa eccezione.
Quando generalmente consideriamo un sistema di memorizzazione nella cache, è naturalmente considerato volatile e non persistente, che i dati archiviati nella cache non saranno più disponibili se la cache si riavvia.
Supponiamo che un negozio di e-commerce online con centinaia e migliaia di transazioni utente ogni giorno, salvi tutti i suoi dati in una cache distribuita, il che fa sì che gli utenti accedano a quei dati a una velocità molto rapida. Il negozio di e-commerce desidera salvare tutti i suoi dati in una cache distribuita non volatile e conservare i dati anche se la cache si arresta in modo anomalo o si riavvia a causa di circostanze impreviste.
Abbiamo una soluzione che utilizza NCachedistribuzioni lato server di per modificare la cache e renderla persistente. Puoi trovare la soluzione su GitHub come NCache cache persistente. Questa soluzione utilizza i provider Read-Thru e Write-Thru per alterare il comportamento della cache come cache persistente. Una cache persistente non è affatto un sostituto del tuo normale database, ma semplicemente un'estensione per renderlo più veloce e più accessibile. Può essere implementato con i due principali sistemi di database di NET, SQL e Cosmos DB, senza la necessità di alcun codice aggiuntivo. Diamo un'occhiata più dettagliata a questo.
utilizzando NCacheFunzionalità per una cache persistente
NCache l'archivio dati persistente consente di archiviare i dati per periodi di tempo più lunghi. Normalmente i dati vengono archiviati in un archivio persistente con un tempo di scadenza predefinito o fino a quando l'applicazione non invia un comando di eliminazione. L'archivio di persistenza si trova al di fuori della cache distribuita e tutti i dati archiviati nella cache verranno automaticamente salvati nell'archivio persistente per essere resi disponibili quando la cache viene cancellata a causa della sua natura volatile. Ad ogni richiesta di lettura effettuata dall'applicazione, se non ci sono dati richiesti nella cache, la cache recupererà automaticamente la voce dall'archivio persistente e nessun dato della cache verrà perso. Questo è mostrato nella Figura 1:
NCache l'archivio persistente fornisce le seguenti funzionalità di distribuzione lato server per garantire transazioni fluide e senza interruzioni quando i dati archiviati nella cache non sono disponibili.
- Caricatore di avvio persistente: Questo provider carica i dati nella cache dall'archivio permanente ogni volta che la cache si avvia. Con ogni operazione di scrittura eseguita nella cache, l'archivio persistente viene aggiornato e tutti i dati persistenti vengono caricati nella cache ogni volta che la cache viene riavviata. Quindi non ci sarà alcuna perdita di dati memorizzati nella cache anche dopo che l'intero cluster di cache si interrompe per qualsiasi motivo e quindi si riavvia.
- Provider di scrittura persistente: Questo provider viene chiamato automaticamente quando scrivi qualcosa nella cache persistente. Replica ciò che viene scritto nell'archivio permanente in modo che rimanga disponibile al riavvio della cache. Sono disponibili 2 opzioni per la configurazione di questo provider: Write-Thru e Write-Behind. Questi consentono all'utente di eseguire la replica in background o di replicare prima dell'operazione di scrittura.
Con Scrivi-Thru, ad ogni operazione di scrittura i dati vengono contemporaneamente salvati nell'archivio persistente e quindi il controllo viene restituito all'applicazione.
Con Scrivi dietro, NCache en-accoda l'operazione e lo fa in background, restituendo il flusso all'utente prima che vengano eseguite le operazioni del database. - Provider di lettura permanente: Questo provider viene chiamato nel caso in cui l'utente richieda dati che non sono disponibili nella cache. Il cluster di cache che utilizza il provider Read Through recupererà questi dati dall'archivio persistente e li conserverà nella cache.
Esempio rapido di persistenza WriteThru Provider
Diamo un'occhiata a un rapido esempio di come utilizzare una cache persistente con NCache. In questo esempio, aggiungeremo un elemento alla cache utilizzando il file Provider WriteThru. Quando l'utente aggiunge l'elemento alla cache, viene chiamato il provider di write-through distribuito con il server della cache e l'elemento viene contemporaneamente salvato all'interno dell'archivio dati persistente. Ora, nel caso in cui la cache si spenga o l'elemento venga rimosso dalla cache senza utilizzare Write-Thru, l'elemento verrà rimosso dalla cache ma non dall'archivio persistente; i dati non andranno persi poiché saranno all'interno dell'archivio persistente. Quando quell'elemento è richiesto, verrà recuperato dall'archivio persistente nella cache.
Ecco il codice di base che mostra l'interfaccia del provider Write-Thru.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
public class PersistenceWriteThruProvider : ProviderBase, IWriteThruProvider { public OperationResult WriteToDataSource(WriteOperation operation) { OperationResult operationResults = new OperationResult(operation, OperationResult.Status.Success); switch (operation.OperationType) { case WriteOperationType.Add: var items = new Dictionary<string, ProviderItemBase>(); items.Add(operation.Key, operation.ProviderItem); _persistenceProvider.Add(items); break; // Update and remove cases are similar and need to be handled } return operationResults; } } |
Ecco come è possibile inserire un elemento nella cache con la scrittura passante abilitata in modo che utilizzi l'implementazione di scrittura passante distribuita:
1 2 3 4 5 6 |
// Enable write through for the cacheItem created var writeThruOptions = new WriteThruOptions(); writeThruOptions.Mode = WriteMode.WriteThru; // Add the item in the cache with WriteThru enabled CacheItemVersion itemVersion = cache.Insert(key, cacheItem, writeThruOptions); |
NCache Dettagli Documenti di memorizzazione nella cache di scrittura
Provider ReadThru di persistenza
Supponiamo che l'applicazione desideri alcuni dati dalla cache. Questi dati sono stati precedentemente archiviati nella cache ma per qualche motivo non sono più disponibili. Normalmente se l'utente tenta di accedere a tali dati, la cache restituisce un valore null poiché la cache non contiene i dati richiesti e dovrebbe essere scritto codice aggiuntivo contenente query per recuperare i dati dal database. Ciò farà sì che la logica dell'applicazione diventi troppo complessa. La cache viene prima ricercata per l'elemento richiesto e, se non è disponibile, controllare il database e quindi caricare i dati.
Quando usiamo il NCache persistence data store, i dati rimossi dalla cache verrebbero comunque archiviati nel persistente data store e la cache chiamerebbe il file Leggi ThruProvider l'implementazione ei dati verrebbero richiamati nella cache e restituiti all'utente. Quindi ora otterrai i dati desiderati anche se sono stati eliminati dalla cache senza bisogno di codice aggiuntivo.
Ecco il codice di base che mostra l'interfaccia del provider Read-Thru:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
public class PersistenceReadThruProvider : ProviderBase, IReadThruProvider { public ProviderCacheItem LoadFromSource(string key) { return (ProviderCacheItem)(_persistenceProvider.Get(new string[] { key })[key]); } public ProviderDataTypeItem LoadDataTypeFromSource(string key, DistributedDataType dataType) { ... } public IDictionary<string, ProviderCacheItem> LoadFromSource(ICollection keys) { ... } } |
Puoi recuperare i dati dalla cache con il read-through abilitato, quindi se non esiste nella cache, lo recupererà dall'origine dati secondo la tua implementazione del provider di read-through.
1 2 3 4 5 6 |
// Specify the readThruOptions for read through operations var readThruOptions = new ReadThruOptions(); readThruOptions.Mode = ReadMode.ReadThru; // Retrieve the data of the corresponding item with reads thru enabled Product data = cache.Get(key, readThruOptions); |
NCache Dettagli Documenti di memorizzazione nella cache di lettura
Caricatore di avvio di persistenza
Come discusso in precedenza, una cache è volatile e tutti i dati in una cache vengono cancellati una volta che la cache si spegne. Al riavvio, la cache è vuota e deve essere ripopolata. Il caricamento di ciascuna voce quando è necessario utilizzando il provider Read-Thru rallenta il processo di recupero dei dati e delle operazioni. E se potessimo caricare tutti i dati nella cache all'avvio della cache? Con il Caricatore di cache interfaccia fornita da NCache, tutti i dati dall'archivio permanente vengono duplicati nella cache all'avvio, in modo che siano disponibili per l'utilizzo da parte dell'applicazione.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
public class PersistenceStartupLoader : ProviderBase, ICacheLoader { public LoaderResult LoadNext(object userContext) { if (persistentItems == null) persistentItems = _persistenceProvider.GetAll(); LoaderResult result = new LoaderResult(); foreach (var item in persistentItems) { result.Data.Add(new KeyValuePair<string, ProviderItemBase>(item.Key, item.Value)); } return result; } } |
NCache Dettagli Documenti del caricatore di avvio della cache
Elimina i dati dal datastore persistente
Nella soluzione che ho realizzato, l'archivio persistente è collegato alla tua cache, quindi eventuali modifiche apportate all'interno della cache verranno apportate anche all'interno dell'archivio persistente. Ad esempio, un elemento di dati viene archiviato nella cache e in un archivio persistente. Quando l'utente lo elimina dalla cache, verrà eliminato anche dall'archivio persistente, con l'aiuto del provider di write-through. Ciò garantirà che la cache principale rimanga sincronizzata con l'archivio dati persistente.
Tuttavia, questo è completamente flessibile, puoi modificarlo e avere elementi archiviati nell'archivio persistente anche se l'applicazione invia un comando di eliminazione.
Perché NCache?
NCache è una cache distribuita in memoria veloce e scalabile leader di mercato realizzata al 100% per .NET / .NET Core applicazioni. Fornisce funzionalità lato server per supportare la persistenza della cache e sono disponibili molte configurazioni che possono essere eseguite per utilizzare la persistenza della cache come richiesto. I dati possono essere mantenuti dalla cache a qualsiasi database di nostra scelta. NCache memorizza nella cache i dati delle applicazioni ed elimina i colli di bottiglia delle prestazioni relativi all'archiviazione dei dati e ai database. Ti consente di archiviare i tuoi dati nella cache per periodi di tempo più lunghi per assicurarti che i tuoi dati siano disponibili quando ne hai bisogno. NCache persistence datastore elimina la necessità di spostare i dati dal database alla cache ogni volta che la cache si avvia. Ciò garantisce l'elevata disponibilità dei tuoi dati senza la necessità di scrivere codice aggiuntivo!
Oltre al capo NCache Documenti per saperne di più su come implementare e utilizzare NCache datastore persistente insieme alla tua cache distribuita.