Ridimensionamento ASP.NET Core App con NCache
Webinar registrato
Di Ron Hussain e Zack Khan
ASP.NET è una tecnologia molto popolare per lo sviluppo di applicazioni web. Ora la sua ultima versione ASP.NET Core sta rapidamente guadagnando popolarità tra le organizzazioni ansiose di spostare le proprie app Web su ASP.NET Core. Ma, ASP.NET Core incontra problemi di scalabilità e prestazioni quando viene sottoposto a un carico utente pesante. Ciò accade perché l'archiviazione dei dati diventa un collo di bottiglia. Tuttavia, esiste un modo per aggirare questo collo di bottiglia in termini di prestazioni e scalabilità se si utilizza la memorizzazione nella cache distribuita. Scopri come ottimizzare il tuo ASP.NET Core prestazioni e scalabilità per prestazioni con carichi di transazione estremi.
Ecco di cosa tratta questo webinar:
- Panoramica di ASP.NET Core scalabilità e colli di bottiglia delle prestazioni
- Come la cache distribuita risolve questi problemi
- Memorizzazione nella cache dei dati delle app tramite ASP.NET Core Interfaccia IDistributedCache e Direct NCache API
- ASP.NET Core Archiviazione sessione con NCache
- ASP.NET Core Memorizzazione nella cache delle risposte con NCache
- Alcuni importanti NCache funzionalità di cache distribuita
Nel webinar di oggi faremo una panoramica di ASP.NET Core i colli di bottiglia di scalabilità e prestazioni e il modo in cui la memorizzazione nella cache distribuita risolve tali colli di bottiglia e altri problemi. Parleremo di ASP.NET Core applicazioni, quali sono i colli di bottiglia di prestazioni e scalabilità e poi parleremo di come risolvere tali colli di bottiglia di prestazioni e scalabilità con l'aiuto di NCache sistema di cache distribuito.
NCache è un sistema di memorizzazione nella cache distribuito in memoria per .NET e .NET Core applicazioni. È scritto in .NET e principalmente per .NET e .NET Core applicazioni, ma principalmente l'obiettivo di oggi sarà l'ASP.NET Core app Web e ho alcune funzionalità di esempio disponibili. Ho anche preparato alcune applicazioni di esempio. Quindi, sarà un webinar pratico in cui condividerò alcuni dettagli a livello di funzionalità di diversi casi d'uso che puoi acquisire e funzionalità che sono lì per aiutare ad affrontare quei casi d'uso e dimostrerò anche questi esempi. Iniziamo.
Quindi, le nostre prime diapositive sono diapositive introduttive su ASP.NET Core piattaforma in generale. Sono abbastanza sicuro che tutti sappiano cosa ASP.NET Core è. È la nuova piattaforma applicativa web ASP. È pulito, leggero, modulare. È principalmente l'architettura MVC, per quanto riguarda l'approccio alle applicazioni web. Sai, il popolare front-end Angular, React è principalmente un front-end basato su JavaScript e quindi l'architettura MVC per eseguirne il backup. È multipiattaforma. Puoi eseguirlo su Windows, Linux e qualsiasi altro sistema operativo, come macOS. E, in genere, è qualcosa che è molto compatibile anche con le applicazioni ASP.NET 4.0 legacy.
Se si dispone di un'applicazione ASP.NET MVC, ora è possibile eseguire la migrazione da quella e quindi iniziare a utilizzare ASP.NET Core tecnologia del resto, che è architettura molto veloce, molto robusta e molto leggera e pulita, in generale.
Che cos'è la scalabilità?
Prima cosa di cui parleremo ASP.NET Core piattaforma è richiede scalabilità. Quindi, definiamo cos'è la scalabilità? Qualsiasi applicazione in esecuzione con un normale carico utente e per normalizzata intendo che alcuni utenti sono presenti. Diciamo che da 5 a 10 utenti hanno effettuato l'accesso e stanno eseguendo determinate transazioni, determinate operazioni, richieste di lettura e scrittura. In genere l'idea qui è che la tua applicazione sarebbe super veloce con un carico utente basso. Ma, non appena il carico dell'applicazione aumenta e questo è un requisito anche per l'azienda, è necessario che sempre più utenti accedano alle tue applicazioni. È allora che le tue applicazioni tendono a rallentare. Potrebbero esserci prestazioni lente con carichi di picco.
Se la tua applicazione non è in grado di mantenere le stesse prestazioni che aveva con un numero basso di utenti e quindi quando ha un numero elevato di utenti se è in grado di mantenere le stesse prestazioni, quell'applicazione verrebbe classificata come un'applicazione molto scalabile. L'architettura ha la capacità di scalare in orizzontale ed essere in grado di gestire il carico maggiore degli utenti finali. Quindi, prestazioni elevate con carichi di picco sono ciò che definisce effettivamente il fattore di scalabilità.
Ecco un grafico. In genere la scalabilità si ottiene all'interno di ASP.NET e ASP.NET Core piattaforma tramite più Web o App Server.
Puoi distribuire il carico dell'applicazione. Devi semplicemente distribuire la tua applicazione su più server Web o app e in base a ciò distribuisci semplicemente il carico utente dell'applicazione su quei server e man mano che aggiungi più server ottieni un miglioramento lineare nella capacità di gestione delle richieste. Più server significano più capacità di gestione delle richieste dalla tua applicazione.
Ecco una scalabilità non lineare in cui, anche dopo aver aggiunto più server, l'architettura non è progettata in modo tale che, sebbene tu stia aggiungendo molti server Web o server app, ma le tue applicazioni non si espandono, poiché il carico utente è in crescita.
Quindi, i tuoi requisiti di transazione stanno crescendo e stai aggiungendo server, stai facendo tutti i passaggi giusti ma non sei ancora in grado di ottenere la capacità di cui hai bisogno per far fronte all'aumento del carico di richieste. Quindi, quel problema è in genere associato alle origini dati di back-end e ne parlerò.
Quindi, prima di tutto vediamo quali applicazioni necessitano di scalabilità. Quali sono i diversi tipi di applicazioni? All'interno di ASP.NET e .NET Core abbiamo app Web e applicazioni Web MVC, che gestiscono l'attività principale, alcuni servizi Web, alcune chiamate di servizio, alcuni microservizi, questa è la nuova architettura e potrebbe essere qualsiasi altro .NET generale o .NET Core Applicazione.
Tutto ciò richiede scalabilità, perché potresti avere molti utenti interni o esterni o richiedere che si verifichi un carico, che deve essere soddisfatto dall'architettura dell'applicazione.
Il problema della scalabilità
Ho detto che puoi creare una Web farm. Puoi distribuire il carico dell'applicazione su più server. Quindi, dove si trova esattamente il problema della scalabilità? Come puoi vedere, se aggiungi server dovresti essere in grado di gestire un carico di richieste sempre maggiore, perché ti offre una scalabilità lineare per quanto riguarda App farm o Web farm.
Ma quando esattamente inizi a vedere una scalabilità non lineare o nessuna scalabilità? Questo è in genere con i database relazionali. Il livello dell'applicazione si ridimensiona bene, giusto. Puoi aggiungere più server. Puoi creare più istanze della stessa applicazione sulla stessa scatola o puoi avere scatole separate che ospitano le tue applicazioni. Ma tutte queste applicazioni normalmente parlano con un database relazionale di back-end e il database relazionale è molto buono per l'archiviazione, ma quando si tratta di gestire una quantità estrema di carico di richieste, ad esempio, si ha molto carico transazionale sulle applicazioni, quel database diventa un collo di bottiglia. Prima di tutto rallenterà le cose, quindi è un collo di bottiglia delle prestazioni e quindi non ha la capacità di aumentarne la scalabilità. Non ha alcuna capacità di aumentare la capacità. Ti darebbe solo la capacità del server specificato in cui è ospitato il database.
Potrebbe anche essere un database mainframe. Potrebbe essere un file system. Tutte queste origini rappresentano un collo di bottiglia della scalabilità per la tua applicazione ed è qui che le tue applicazioni rallentano. Le tue richieste iniziano a mettersi in coda e l'esperienza complessiva dell'utente finale ne risente. NoSQL non è la risposta. Sai, lo capisco molto NoSQL i prodotti ci sono. Abbiamo anche un prodotto chiamato NosDB, Che è un NoSQL database. Ma il problema principale con NoSQL databases è che le tue applicazioni richiederebbero una ri-architettura, in cui smetti di utilizzare un database relazionale e inizi a utilizzare a NoSQL origine dati non strutturata a confronto.
Quindi, anche la ri-architettura dell'applicazione non è facile, giusto. Quindi, questo è un altro problema che devi affrontare. Quindi, nel complesso, le tue applicazioni non sono scalabili, principalmente a causa delle origini dati di back-end.
La soluzione: NCache Cache distribuita
Qual'è la soluzione? È molto semplice iniziare a utilizzare un sistema di memorizzazione nella cache distribuito come NCache. È in memoria, quindi è super veloce rispetto al database. Quindi, questo è il primo vantaggio che ne ottieni. Quindi, con l'accesso in memoria, rispetto all'accesso basato su disco NCache è super veloce in confronto. Quindi, primo vantaggio, le tue normali richieste di applicazione vanno a NCache rispetto al database, saranno super veloci e si alleggeriranno anche dal database salvando i viaggi nelle origini dati di back-end. Quindi, il tuo database è libero di fare anche altre cose. Il secondo vantaggio è che è molto scalabile. È linearmente scalabile nel suo modello. Non è solo un singolo server. Esistono più server che puoi utilizzare per ospitare il tuo cluster di cache. È un cluster di cache. Quindi, il team di server lavora in combinazione tra loro e aiuta a soddisfare le richieste dei tuoi clienti. Più server significano più capacità di gestione delle richieste fuori NCache ed è qui che ti offre enormi vantaggi, in cui non solo ottieni risposte super veloci NCache, è super veloce, a bassa latenza e ti offre anche un throughput elevato e una scalabilità estremamente elevata. Puoi continuare ad aggiungere più server e puoi aumentare linearmente tale capacità ogni volta che il carico dell'utente aumenta, senza modificare nulla all'interno dell'architettura dell'applicazione.
E, cosa bella NCache è che lo usi in aggiunta a un database di back-end. Non è una sostituzione delle tradizionali origini dati relazionali. Non è necessario riprogettare l'applicazione per iniziare a utilizzarla NCache. Puoi sempre usare NCache in combinazione con un'origine dati back-end, in cui alcuni o la maggior parte dei tuoi dati si trovano all'interno NCache e il database ne ha una copia master. Ma, per alcuni casi d'uso, la cache conterrebbe tutti i dati. Ad esempio, per le sessioni e per altri casi d'uso.
NCache Numeri di scalabilità
Ecco i nostri numeri di throughput. Abbiamo condotto questi test nel nostro laboratorio AWS. Si trattava di dati applicativi reali, simulati nel nostro laboratorio AWS. Quindi, non sono dati touch and go. Dati applicativi effettivi simulati, nel nostro ambiente. Dove abbiamo usato 5 NCache server e siamo stati in grado di ottenere 2 milioni di richieste al secondo NCache.
Quindi, questo è il tipo di miglioramento delle prestazioni che hai se tu o i numeri di scalabilità che hai, se hai sempre più server aggiunti. Quindi, 2 milioni di richieste al secondo con solo 5 NCache server ed è stata una tendenza in aumento molto lineare e dovrebbe continuare ad aumentare, se si continua ad aggiungere più server.
Questi sono pubblicati anche sul nostro sito web. C'è un dimostrazione video disponibile anche.
Architettura di distribuzione
Ecco la nostra architettura di distribuzione. In genere, ecco come NCache viene distribuito il sistema di cache distribuita. È supportato in tutti gli ambienti on-premise e nel cloud. Puoi, hai solo bisogno di .NET o NET Core Framework per essere disponibile. Questo è l'unico prerequisito per NCache e puoi distribuirlo su Windows così come su server Linux. Potrebbero essere le tue scatole fisiche o virtuali in sede o potrebbe essere qualsiasi cloud pubblico o privato, in cui hai .NET o .NET Core installato su Windows o Linux. Quindi, questi sono due requisiti.
Oltre a quello NCache è supportato su ogni piattaforma. È disponibile in Azure Marketplace, così come, AWS e stiamo anche realizzando un modello basato su SaaS o la distribuzione di NCache nelle nostre prossime versioni.
Sono disponibili due opzioni di distribuzione. Uno è che dovresti usare server dedicati per la memorizzazione nella cache e le tue applicazioni si connettono in un modello di server client. Questo è il modello preferito anche nel cloud in cui non hai macchine virtuali lato client ma hai una distribuzione lato server.
E, la seconda opzione di distribuzione è che utilizzi le caselle delle applicazioni esistenti come tue NCache anche i server. Questo è principalmente in locale dove hai già il livello dell'applicazione. Configurazioni più piccole, potresti voler usare NCache da installare sulla stessa scatola, stesso set di server.
In entrambi i casi NCache gestisce la maggior parte del tuo traffico. Si consiglia il 100% e una parte del traffico può sempre andare al database di back-end e queste potrebbero essere le operazioni di lettura e scrittura delle operazioni transazionali che è possibile gestire tramite la cache alle origini dati di back-end.
Quindi puoi utilizzare la cache come modello del sito in cui la tua applicazione ha dati e aggiorna i dati o recupera i dati dalla cache e dal database insieme l'uno con l'altro oppure puoi utilizzare l'approccio read through e write through che è anche disponibile con NCache.
Usi comuni della cache distribuita
Parlerò di alcuni casi d'uso e poi passeremo direttamente al nostro ASP.NET Core memorizzazione nella cache specifica caratteristiche. Quindi, parliamo di alcuni casi d'uso comuni di NCache. Ci sono molti casi d'uso. E, da un punto di vista tecnico, ne ho elencati alcuni e questi sono specifici per ASP.NET Core applicazioni, ma in generale per qualsiasi .NET o ASP.NET o ASP.NET Core or .NET Core. Potrebbe essere un'applicazione Web, un'applicazione back-end, alcuni flussi di lavoro, alcuni servizi Windows, che qualsiasi applicazione può utilizzare NCache e ci sono molti casi d'uso tra cui puoi scegliere.
-
Memorizzazione nella cache dei dati dell'app
In primo luogo, per ASP.NET Core, punteremo alla memorizzazione nella cache dei dati dell'app e in questo abbiamo due opzioni. Puoi usare Interfaccia IDistributedCache. Se stai già utilizzando IDistributedCache nelle tue applicazioni, puoi semplicemente collegarti NCache come fornitore per questo. Quindi, questa è la prima opzione. La seconda opzione è che usi direct NCache Le API e la memorizzazione nella cache dei dati dell'app memorizzano nella cache quasi tutto all'interno dell'applicazione. Potrebbero essere i tuoi oggetti di dominio, raccolte, set di dati, qualsiasi dato che vorresti utilizzare più di una volta e non vuoi andare al database di back-end, hai recuperato quei dati e ora puoi conservarli nel cache e puoi continuare a utilizzare il repository della cache e salvare i viaggi nel database.
ASP.NET Core Cache di sessione e SignalR Backplane
Il secondo caso d'uso è ASP.NET Core memorizzazione nella cache specifica. Queste sono le nostre funzionalità di memorizzazione nella cache del front-end web. Su questo fronte, abbiamo molte funzionalità. Puoi usare l'ASP.NET Core stato della sessione. Sai, è una sessione a sito singolo ea più siti. NCache è un cluster di cache distribuita. Quindi, le tue sessioni sono archiviate in modo distribuito all'interno NCache. È anche un'opzione senza modifica del codice, quasi con una riga di modifica del codice nel metodo di estensione in cui si collega NCache. Non sono necessarie modifiche estese al codice per utilizzare questo e questi sono molto affidabili all'interno NCache perché le sessioni vengono replicate su più server. Pertanto, qualsiasi server inattivo non avrebbe alcuna perdita di dati o tempi di inattività dell'applicazione da parte tua.
La seconda caratteristica qui è ASP.NET Core memorizzazione nella cache delle risposte. Se hai pagine statiche. Storicamente in ASP.NET avevamo la memorizzazione nella cache dell'output. Nel nuovo ASP.NET Core piattaforma, puoi utilizzare la cache delle risposte, in cui definisci le intestazioni a livello di pagina e in base a quelle tutte quelle pagine gli output delle pagine sono memorizzati nella cache NCache. Quindi, le risposte vengono memorizzate nella cache. Se emetti di nuovo le stesse identiche richieste, ottieni la risposta pre-cache resa disponibile. Quindi, questa è una caratteristica all'interno NCache, che è anche un'opzione di non modifica del codice che puoi utilizzare su ASP.NET Core livello di cache front-end.
E poi, se stai usando SignalR e hai una web farm, hai bisogno di un backplane come must. Così, SignalR Backplane è necessario se si passa da un singolo server a una distribuzione di Web farm e in tal caso NCache può fungere da ASP.NET Core backplane, SignalR Backplane per le tue applicazioni SignalR. Sta usando Pub/Sub Messaging dietro le quinte, che sono guidati dagli eventi. Molto veloce, molto scalabile. Quindi, ottieni i vantaggi di prestazioni e scalabilità elevate e disponibilità e affidabilità elevate, se esegui il plug-in NCache come ASP.NET Core SignalR Backplane.
Messaggistica Pub/Sub
Infine, il terzo caso d'uso è Pub/Sub Messaging. Messaggistica Pub/Sub è anche un caso d'uso separato. Per SignalR, dietro le quinte che stiamo usando c'è Pub/Sub Messaging. Ma Pub/Sub Messaging può essere utilizzato come caso d'uso separato all'interno NCache anche. Per l'applicazione di microservizi questo ha molto senso, dove si hanno applicazioni semplici definite nell'architettura di microservizi. Quelli sono responsabili di un compito dedicato. Uno scopo molto importante che stanno servendo. Quindi, è molto difficile organizzare la comunicazione tra quei Microservizi e NCache può risolvere quel problema. Non è necessario implementare personalmente alcuna comunicazione all'interno delle applicazioni di microservizi. Puoi fare affidamento su NCache piattaforma di comunicazione per questo e qualsiasi applicazione ad essa collegata può inviare e ricevere messaggi e non deve avere alcun degrado delle prestazioni mentre lo stanno facendo.
Puoi avere un modello di abbonato editore. Laddove gli editori pubblicano i dati nella cache e quindi la cache archivia e inoltra quei messaggi a tutti gli abbonati. È un meccanismo basato su eventi Async. Quindi, editore e abbonati non devono nemmeno conoscersi. Quindi, non ci sono latenza, nessuna attesa coinvolta, nessuna chiamata sincrona coinvolta. Quindi, è un'architettura molto robusta, molto veloce, ad accoppiamento lasco e tutto è gestito da NCache, per quanto riguarda questa piattaforma.
Demo pratica
Quindi, abbiamo coperto queste funzionalità di alto livello. Successivamente ti mostrerò il prodotto reale in azione. Dove creerò un cluster di cache. Provalo. Mostrarti alcuni aspetti di monitoraggio e poi parleremo di tutte queste funzionalità che puoi utilizzare in ASP.NET Core uno per uno. Quindi, ho messo in fila alcune applicazioni di esempio per questo. Quindi, sto accedendo al mio ambiente demo.
Quindi, qui ne abbiamo due NCache server che userò e la mia scatola fungerebbe da macchina client da cui eseguirei tutte queste applicazioni di esempio. Quindi, l'idea qui è che userò il strumento di gestione basato sul web e strumento di monitoraggio.
Quindi, questo strumento di gestione basato sul Web ti consente di gestire e monitorare tutto da un unico punto. Potrebbe essere qualsiasi richiesta web, richiesta http da qualsiasi luogo, dal tuo ambiente a uno dei tuoi NCache server o client e dovrebbe consentire di gestire e monitorare tutto in remoto tramite il web.
Crea una cache raggruppata
Quindi, localhost, puoi fornire un indirizzo IP e puoi semplicemente accedere a questa risorsa da qualsiasi luogo su Internet. Quindi, andrò avanti e creerò una nuova cache. Diciamo "aspcorecache". Tutte le cache devono essere nominate. Puoi anche creare più cluster di cache e puoi trovare qualsiasi nome di cache significativo secondo necessità.
La modalità di serializzazione potrebbe essere binaria o JSON. Quindi, attaccherò binario, mi atterrò a binario e quindi anche JSON è molto flessibile, quindi, se desideri usarlo, sceglierò la partizione della topologia della cache di replica.
Nel quadro di NCache ci sono molti topologie di memorizzazione nella cache. Se ti porto velocemente verso la fine. Quindi, abbiamo molte topologie di memorizzazione nella cache tra cui scegliere. Abbiamo partizionato e quindi abbiamo il partizionamento con i backup. Quindi, in questo abbiamo ogni server che mantiene due partizioni. Una partizione dati attiva, in cui i client sono connessi e una partizione di replica passiva di un altro server. Come puoi vedere, il server uno è attivo, il backup è su due e il server due è attivo, il backup è sul server uno. Nel caso in cui un server si interrompa, il backup viene attivato e ottieni tutti i dati da qui. In condizioni normali, queste partizioni hanno un'equa distribuzione dei dati.
I client sono connessi a tutti i server, quindi le richieste di lettura e scrittura sono super veloci e se si aggiungono più server si ottiene più capacità di gestione delle richieste di lettura e scrittura perché tutti quei server lavorano in combinazione tra loro. Quindi, questa è la topologia che sto scegliendo la partizione della replica.
E poi l'opzione di replica asincrona. Tra attivo e backup, puoi scegliere sincronizzazione o asincrono. La sincronizzazione è più affidabile. L'asincrono è più veloce. Quindi, vado avanti con quello.
La taglia 1024 è abbastanza buona per questa demo, ma puoi trovare qualsiasi taglia che ti sembra significativa.
parametri TCP.
Domanda: Stiamo attualmente utilizzando NCache, c'è un modo per evitare un file client.ncc o nc conf o qualcosa che hai nella pipeline di sviluppo?
Sì. È assolutamente possibile. client.ncconf ti consente di specificare le configurazioni per la connessione a un server cache, dove è in esecuzione il cluster di cache, giusto. Nel mio caso, ho due caselle e un nome cache. Quindi, client.ncconf ha il nome della cache e i server in cui è configurata questa cache. Se vuoi evitare client.ncconf, puoi fornire tutte queste impostazioni in linea. Abbiamo parametri di inizializzazione della cache. Li chiamiamo cache init parametri. Quelli sono che l'oggetto ti consente di specificare tutte queste configurazioni all'interno del codice dell'applicazione. Quindi sì. Per rispondere a questa domanda, è necessario utilizzare i parametri di inizializzazione della cache.
Domanda: Possiamo schierare NCache in azzurro?
Assolutamente. Ne ho discusso mentre condividevamo i dettagli sull'architettura di distribuzione. NCache è completamente supportato in Microsoft Azure e AWS e qualsiasi altro cloud pubblico o privato. Solo prerequisito per NCache è .NET o .NET Core, dipende dal sistema operativo scelto. Stiamo anche realizzando il nostro modello SaaS all'interno di Azure e AWS. Quindi, è completamente supportato. Viene pubblicata anche la nostra immagine del mercato. Quindi, ci sono molti modi in cui puoi usare NCache in azzurro.
NCache è un protocollo di clustering della cache basato su TCP/IP. Quindi, richiede un indirizzo IP e una porta. Quindi, manterrò tutto predefinito sullo schermo.
Se la mia cache si riempie, ho due opzioni, posso rifiutare i nuovi aggiornamenti e continuare a utilizzare la cache per la lettura oppure posso attivare gli sfratti e rimuoverebbe automaticamente alcuni dati per fare spazio agli elementi più recenti.
Per le sessioni, per lo stato di visualizzazione, per la memorizzazione nella cache delle risposte e persino per la memorizzazione nella cache degli oggetti, se i dati sono di natura importante, consiglio vivamente di disattivare l'eliminazione e fornire una dimensione del gas sufficientemente grande in modo che non si riempia mai e anche se diventa piena puoi modificare la dimensione della cache in fase di esecuzione. Ma se va bene permettersi va bene perdere effettivamente alcuni dati, se te lo puoi permettere, quindi, in tal caso puoi abilitare gli sfratti e quando la cache si riempie rimuoverà automaticamente alcuni dati e lascerà spazio ai dati più recenti. Quindi, questo è ciò che fa lo sfratto.
Avvia questa cache al termine e avvia automaticamente questa cache all'avvio del servizio. Quindi, ogni volta che il mio server viene riavviato, la cache viene avviata automaticamente e il gioco è fatto. Ecco com'è facile configurare un cluster di cache a due nodi con NCache.
Simula lo stress e monitora le statistiche della cache
Quindi, la nostra cache è attiva e funzionante. È anche attivato, quindi andrò rapidamente avanti e lo testerò. Finestra delle statistiche. Quindi, questi mi mostrano perfmon contatori di entrambi i server e quindi monitorano gli aspetti di NCache.
Molto buona. Quindi, mi offre anche la visualizzazione del rapporto dashboard lato server e lato client. Quindi, tutti i parametri ci sono.
La prossima cosa è testare questa cache. Nessuna applicazione è connessa, quindi andrò avanti e lo farò. Questo è il nome della cache e dietro le quinte sta usando le configurazioni lato client per connettersi e si connetterebbe al mio cluster di cache e inizierebbe a simulare le richieste. Come puoi vedere, il contatore delle richieste al secondo e il contatore delle operazioni in microsecondo medio per cache che mostra l'attività. Abbiamo anche aggiunte, recuperi, aggiornamenti e abbiamo il contatore delle dimensioni della cache visualizzato, CPU, memoria e abbiamo IP client che sono attualmente collegati alla cache.
Fammi andare avanti ed eseguire un'altra istanza di questo strumento.
Domanda: Un'altra domanda, mentre stavi facendo questo, è: possiamo monitorare tutti i client collegati alle nostre cache?
Assolutamente. Questa è una delle funzionalità molto potenti all'interno NCache. Posso mostrarlo con l'aiuto di questo esempio. Ora che abbiamo due client collegati. Prima di tutto, posso vedere i dashboard dei client. Quindi, questi due client vengono eseguiti da 107 e posso vedere le operazioni di lettura eseguite da questa casella client. Se eseguo applicazioni dalla mia casella, cosa che farei, qui vedresti anche le statistiche della mia casella e allo stesso modo possiamo anche vedere i processi, i loro ID di processo, le porte, i byte inviati e ricevuti anche da qui. Ma penso che la cosa principale che stai cercando sia diversi aspetti di monitoraggio dal lato client. Quindi, abbiamo Operazioni di lettura al secondo, Aggiunte al secondo, Aggiornamenti al secondo, Recupero.
Quindi, abbiamo un set completo di contatori lato client, che sono disponibili come parte di NCache, a destra e l'integrità della cache e questi sono tutti contatori lato server, ma tutti questi contatori, che stai mostrando sul lato client, possono essere aggiunti e puoi rivederli anche per i server delle applicazioni client.
Così, NCache è molto ampio nel suo supporto per il monitoraggio lato client. Spero che risponda alla tua domanda.
Ora, ho eseguito, in realtà sono in grado di eseguire due istanze dello strumento di stress test e puoi vedere da 800 a 900 richieste al secondo ciascuna NCache server. Quindi vengono gestite in media circa 1500 Richieste al secondo.
Quindi, quella è stata una rapida demo. Fermerò questi strumenti. Successivamente, ti mostrerò le funzionalità effettive che puoi effettivamente utilizzare. Quindi, abbiamo speso una buona quantità di tempo a spiegare come NCache è molto scalabile.? Come viene distribuito? Come configurare e creare un cluster di cache?
Ora, la prossima cosa che vorrei evidenziare è come utilizzare NCache nell'ASP.NET Core applicazioni e quali sono i casi d'uso principali. Abbiamo coperto diversi casi d'uso. Quindi, inizierò con i casi d'uso della memorizzazione nella cache del front-end Web all'interno di ASP.NET Core.
NCache ASP.NET Core Cache di sessione
Quindi, la prima caratteristica che evidenzierò è NCache ASP.NET Core cache di sessione. Abbiamo due opzioni qui. Puoi utilizzare, se stai già utilizzando sessioni e la maggior parte delle possibilità è che utilizzerai IDistributedCache Interface. Quindi, puoi collegarti NCache come provider per la memorizzazione nella cache di sessione tramite IDistributedCache. Hai un provider in memoria autonomo. Hai un provider di server SQL. Standalone è un singolo punto di errore. Non è scalabile. Il server SQL è anche un singolo punto di errore in alcuni casi. Non è scalabile ed è molto lento.
NCache il fornitore è super veloce. È in memoria. È molto scalabile. Non è un singolo punto di errore e aumenti la capacità in fase di esecuzione. Quindi, puoi aggiungere sempre più server e puoi sapere ottenere una scalabilità illimitata NCache. Quindi, IDistributedCache, esaminiamolo rapidamente. Quindi, ecco il nostro gioco di ipotesi, IDistributedCache.
public void ConfigureServices(IServiceCollection services)
{
//Add framework services
services.AddMvc();
services.AddNCacheDistributedCache(configuration =>
{
configuration.CacheName = "MyNCacheCache";
configuration.EnableLogs = true;
configuration.ExceptionsEnabled = true;
});
}
public void Configure(IApplicationBuilder app)
{
app.UseNCacheSession();
}
Tutto quello che devi fare è aggiungere i servizi NCache Cache distribuita e poi pronuncia l'app Usa NCache Session ed ecco un'applicazione di esempio che farà proprio questo.
public IConfigurationRoot Configuration { get; }
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
// Add framework services.
services.AddMvc();
//To test sessions with NCache Distributed Cache, uncomment the following lines and comment the line after it
services.AddNCacheDistributedCache(Configuration.GetSection("NCacheSettings"));
services.AddSession();
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
loggerFactory.AddConsole(Configuration.GetSection("Logging"));
loggerFactory.AddDebug();
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
app.UseBrowserLink();
}
else
{
app.UseExceptionHandler("/Home/Error");
}
app.UseStaticFiles();La seconda opzione qui è NCache provider di sessione che ha funzionalità avanzate e ho anche un'applicazione di esempio per questo. Quindi, concentriamoci davvero su questo. In primo luogo, perché il nostro provider è molto più ricco di funzionalità rispetto a IDistributedCache, quindi vorrei evidenziare questo e come parte di ciò vedresti tutte le funzionalità che ti offre anche il provider IDistributedCache.
Quindi, tornando qui. Prima di tutto, hai bisogno NCache Pacchetto NuGet, che ho già aggiunto all'interno di questo. Quindi, se lo abbiamo AspNetCore.Sessions.NCache, Giusto. Quindi, questo è il pacchetto NuGet e lasciami tornare rapidamente qui e rivedere anche la sessione qui e questo è successo NCache.Microsoft.Estensioni.Memorizzazione nella cache. Quindi, i pacchetti NuGet della sessione IDistributedCache sono leggermente diversi da quelli NCache fornitore di sessione effettivo.
Quindi, mi concentrerò su questo proprio qui. Tutto quello che devi fare è…. Prima di tutto vieni su Startup.cs. Hai servizi.AggiungiNCacheSessione e ci vuole NCache impostazioni nella configurazione.
...
public IConfigurationRoot Configuration { get; }
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
// Add framework services.
services.AddMvc();
//To test sessions with NCache Distributed Cache, uncomment the following lines and comment the line after it
//services.AddNCacheDistributedCache(Configuration.GetSection("NCacheSettings"));
//services.AddSession();
services.AddNCacheSession(Configuration.GetSection("NCacheSettings"));
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
loggerFactory.AddConsole(Configuration.GetSection("Logging"));
loggerFactory.AddDebug();
... E, all'interno della configurazione, specifichi tutto NCache impostazioni del fornitore. Ad esempio, sto usando ASP.NET Core cache. SessionAppId è un attributo dell'ID app a cui l'app viene aggiunta con la chiave dell'elemento della cache. Il tuo ID sessione diventa la chiave della cache e questo attributo verrebbe aggiunto ad essa. Quindi, puoi visualizzare in modo univoco le sessioni di diverse applicazioni all'interno NCache e quindi imposti un blocco di sessione. Puoi, se lo imposti su true. Va bene, quindi, se lo imposti su true, ciò ti consentirebbe semplicemente di bloccare la sessione, in modo che l'accesso simultaneo non sia consentito.
{
"Logging": {
"IncludeScopes": false,
"LogLevel": {
"Default": "Debug",
"System": "Information",
"Microsoft": "Information"
}
},
"NCacheSettings": {
"CacheName": "mycache", //Replace "myPartitionedCache" with the name of your cache
"SessionAppId": "GuessGame", //(Optional)Specifies an identifier to make sure that session ID remains unique in case multiple applications are using the same cache.
"EnableSessionLocking": false, //(Optional)If this flag is set, NCache Session Store Provider exclusively locks the session-store item for which multiple concurrent requests are made. The default is false.
"SessionLockingRetry": -1, //(Optional)If enableSessionLocking is true and this integer is not less than 0, NCache Session Store Provider will return empty session after sessionLockingRetry, which specify the number of retries to acquire a lock. The default is -1.
"EnableLogs": false, //(Optional)When this flag is set, store provider logs all error information. The log files are created in %NCHOME%/log-files/SessionStoreProvider. The default is false.
"EnableDetailLogs": false, //(Optional)When this flag is set, store provider logs all debugging information. The log files are created in %NCHOME%/log-files/SessionStoreProvider. The default is false.
"ExceptionsEnabled": false, //(Optional)Specifies whether exceptions from cache API are propagated to the page output. Setting this flag is especially helpful during development phase of application since exceptions provide more information about the specific causes of failure. The default is false.
"OperationRetry": 0, //It specifies the number of times server will retry the operation, in case connection is lost with a server while an operation is executing. Its default is zero.
"operationRetryInterval": 0 //It specifies the time interval between each operation retry, in case connection is lost with the server. Its default value is zero.
}
}Quindi, puoi solo leggere la sessione. L'accesso in scrittura è concesso solo alla richiesta corrente che ha il registro e quindi abbiamo i registri dettagliati disponibili. Sono disponibili sessioni mono e multisito. Quindi, tutte queste funzionalità sono disponibili solo se colleghi il nostro ASP.NET Core fornitore di sessioni. Le sessioni IDistributeCache sono supportate ma sono limitate. Quindi, eseguirò questo molto velocemente e simulerebbe un'applicazione che alla fine si collegherebbe a questo ASP.NET Core cache.
In realtà, lasciami fermare questo. Permettimi di aggiungere prima la mia casella come cliente. Quindi, qui tutto ciò che devo fare è aggiungere la casella client che è la mia casella proprio qui.
Ecco qua. Ho tutte le configurazioni ora e ora posso eseguire questa applicazione ancora una volta e dovrebbe essere consentito connettersi al mio cluster di cache. Molto buona. Quindi, ci vorrà del tempo per la prima istanziazione.
Quindi, questo creerebbe un oggetto sessione all'interno NCache. Vedrò, se vado all'aspetto di monitoraggio vedrei un client connesso. Una volta che il provider viene inizializzato, il client si connette a 107 e 108 e crea oggetti di sessione all'interno NCache. Al momento verrebbe creato un solo oggetto sessione perché quello è l'utente principale. Sarò l'unico utente che ha effettuato l'accesso, ma se hai più utenti dell'applicazione vedresti più sessioni create all'interno NCache. Ma, l'idea qui è, è molto semplice che tutto ciò che devi fare è aggiungere queste due righe di codici. Aggiungere NCache sessione e quindi pronuncia Usa NCache sessione.
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
// Add framework services.
services.AddMvc();
//To test sessions with NCache Distributed Cache, uncomment the following lines and comment the line after it
//services.AddNCacheDistributedCache(Configuration.GetSection("NCacheSettings"));
//services.AddSession();
services.AddNCacheSession(Configuration.GetSection("NCacheSettings"));
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
loggerFactory.AddConsole(Configuration.GetSection("Logging"));
loggerFactory.AddDebug();
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
app.UseBrowserLink();
}
else
{
app.UseExceptionHandler("/Home/Error");
}
app.UseStaticFiles();
//To test NCache Distributed Cache, uncomment this and comment the line below this
//app.UseSession();
app.UseNCacheSession();
... Questi metodi di estensione copriranno tutto. La prima istanza richiede un tempo leggermente più lungo, questo è quello che abbiamo visto in ASP.NET Core ma una volta che è, le applicazioni sono attive e funzionanti, dovremmo essere in grado di testarlo molto velocemente. Ecco qua. Un cliente è già connesso, quindi penso che ci siamo.
Nel frattempo, fammi eseguire un comando rapido che dice export. Questo strumento esegue il dump di tutte le chiavi della cache attualmente presenti.
Quindi, mi aspetto che un oggetto sessione venga aggiunto nella cache perché un client è connesso e ciò dovrebbe consentirmi di avere due sessioni. Uno del tentativo precedente e uno di questo, è già lì. Ecco qua.
Questo è un gioco di indovinelli che ti permette di indovinare un numero e aggiunge quei numeri all'interno della sessione e mostra anche quei numeri. Quindi, fammi solo indovinare un numero più grande ed è così che farà richiesta NCache.
Quindi, è un'applicazione piuttosto semplice, ma se torni qui, abbiamo due elementi nella cache che sono lì e devi aver visto quelle due richieste su cui ho appena fatto NCache lato server.
Quindi, questo completa la nostra prima dimostrazione, che puoi aggiungere NCache per la memorizzazione nella cache della sessione. Ci sono molte funzioni. Sono supportate sessioni a sito singolo e multisito. Il blocco della sessione è supportato. È disponibile un'ampia registrazione. È molto sicuro. Abbiamo sicurezza e crittografia in cima. Quindi, è un pacchetto completo, se hai intenzione di usarlo NCache per la memorizzazione nella cache della sessione.
ASP.NET Core Memorizzazione nella cache delle risposte
La seconda caratteristica qui è ASP.NET Core cache di risposta. In questo, abbiamo intestazioni http sulle applicazioni. Puoi scegliere di memorizzare nella cache gli output della pagina e utilizzarli NCache middleware di memorizzazione nella cache della risposta per la memorizzazione nella cache ed è di nuovo tramite l'interfaccia IDistributedCache. Quindi, se torno qui, abbiamo questo applicazione di esempio.
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.HttpsPolicy;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Alachisoft.NCache.Caching.Distributed;
namespace ResponseCaching
{
public class Startup
{
public Startup(IConfiguration configuration)
{
Configuration = configuration;
}
public IConfiguration Configuration { get; }
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddResponseCaching();
services.Configure<CookiePolicyOptions>(options =>
{
// This lambda determines whether user consent for non-essential cookies is needed for a given request.
options.CheckConsentNeeded = context => true;
options.MinimumSameSitePolicy = SameSiteMode.None;
});
#region Option1
// Reading NCacheSettings using appsettings.jsonQuindi, tutto ciò che devi fare per usarlo è usare questo pacchetto NuGet NCache.Microsoft.Estensioni.Memorizzazione nella cache. Questo riguarderà le sessioni, IDistributedCache per la memorizzazione nella cache degli oggetti e la memorizzazione nella cache delle risposte in un pacchetto NuGet.
E poi la prossima cosa che devi fare è servizi.AggiungereNCachecache distribuita.
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddResponseCaching();
services.Configure<CookiePolicyOptions>(options =>
{
// This lambda determines whether user consent for non-essential cookies is needed for a given request.
options.CheckConsentNeeded = context => true;
options.MinimumSameSitePolicy = SameSiteMode.None;
});
#region Option1
// Reading NCacheSettings using appsettings.json
services.AddNCacheDistributedCache(Configuration.GetSection("NCacheSettings"));
#endregion
#region Option2
// Reading NCacheSettings using hardcoded values
//services.AddNCacheDistributedCache(options =>
//{
// options.CacheName = "myPartitionedCache";
// options.EnableLogs = true;
// options.ExceptionsEnabled = true;
//});
#endregion
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
}Quindi, questa è un'interfaccia IDistributedCache che viene collegata ma la useremo per la memorizzazione nella cache delle risposte e nelle impostazioni dell'app abbiamo i nomi della cache e alcune impostazioni di registrazione che abbiamo impostato e se torno qui avresti la memorizzazione nella cache delle risposte configurato anche services.AddResponseCaching();
...
namespace ResponseCaching
{
public class Startup
{
public Startup(IConfiguration configuration)
{
Configuration = configuration;
}
public IConfiguration Configuration { get; }
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddResponseCaching();
services.Configure<CookiePolicyOptions>(options =>
{
// This lambda determines whether user consent for non-essential cookies is needed for a given request.
options.CheckConsentNeeded = context => true;
options.MinimumSameSitePolicy = SameSiteMode.None;
});
...Quindi questa applicazione si aspetta che venga eseguita la memorizzazione nella cache della risposta. Sarebbe finito NCache utilizzando l'interfaccia IDistributedCache. Quindi, lo eseguirò molto velocemente perché ci vuole del tempo e poi mi aspetto che sia in grado di connettersi effettivamente NCache e quindi ti mostreremo effettivamente i dati aggiunti.
Se ti mostro il codice Sai, puoi anche specificare le configurazioni in linea. Ad esempio, 'AggiungiNCacheDistributedCache' e puoi dire il nome della cache 'demoClusteredCache' o 'aspCoreCache' e puoi specificare tutte le impostazioni inline
public void ConfigureServices(IServiceCollection services)
{
...
services.AddNCacheDistributedCache(configuration =>
{
configuration.CacheName = "demoClusteredCache";
configuration.EnableLogs = true;
configuration.ExceptionsEnabled = true;
});
...
}
oppure puoi semplicemente usare il NCache impostazione e dare impostazioni attraverso NCache impostazioni, proprio qui. Potrebbe essere tramite la configurazione o tramite le impostazioni inline. Quindi, è molto semplice su quel fronte.
public void ConfigureServices(IServiceCollection services)
{
services.AddResponseCaching();
//remaining services here
...
//Add NCache services to the container
services.SetNCacheSessionConfiguration (
Configuration.GetSection("NCacheSettings"));
services.AddNCacheDistributedCache();
services.AddMvc();
}
Se torno qui ora, ci aspettiamo che due client siano connessi perché l'applicazione di memorizzazione nella cache delle risposte effettuerà anche una connessione a NCache e di conseguenza vedremmo alcuni elementi nella cache.
Domanda: In che modo esattamente i dati vengono crittografati e mantenuti al sicuro?
Lascia che ti mostri questo esempio di memorizzazione nella cache delle risposte e poi ti mostrerò le funzionalità di crittografia di sicurezza all'interno NCache. Quindi, abbiamo l'applicazione in esecuzione e, come puoi vedere, abbiamo aggiunto alcuni elementi. Se aggiorno semplicemente questo abbiamo i valori aggiornati da qui e questo è in corso, il contenuto di output di questa pagina è archiviato all'interno NCache attraverso la nostra cache di risposta e se ti mostro le chiavi della cache, ora abbiamo altri elementi nella cache. Quindi, due elementi oltre agli elementi della sessione che sono già presenti.
Ora, tornando a crittografia di sicurezza. Quelli sono molto ampi all'interno NCache. Abbiamo funzionalità di sicurezza e crittografia. Ci sono molti fornitori di sicurezza tra cui puoi scegliere. Abbiamo fornitori AES e DES. Molteplici di quelli. Disponiamo di provider di crittografia conformi a FIPS e supportiamo anche TLS 1.2. Quindi, è disponibile anche la sicurezza del livello di trasporto NCache. Quindi, questo è ciò che copre la tua crittografia. Dove puoi avere la crittografia end-to-end tra le tue caselle client e server e quindi dal punto di vista della sicurezza, puoi scegliere chi potrebbe essere l'amministratore della cache, chi potrebbe essere gli utenti della cache e abbiamo un provider di sicurezza della crittografia basato su LDAP basato su Active Directory che tu può collegarsi.
Quindi, se ci sono domande specifiche, puoi inviarci un'e-mail e lavoreremo con te e condivideremo tutti i dettagli su come configurarli. Ma abbiamo un supporto molto ampio all'interno NCache. Quindi, tornando qui. Quindi, questo copre il nostro ASP.NET Core Memorizzazione nella cache delle risposte.
ASP.NET Core SignalR Backplane
La prossima caratteristica è ASP.NET Core SignalR Backplane. In questo, se stai usando una web farm puoi usare NCache come backplane per esso e rispetto ai backplane convenzionali, NCache è molto più veloce, molto affidabile e anche molto scalabile.
Quindi, ecco il pacchetto NuGet che ho aggiunto. AspNetCore.SignalR.NCache che puoi cercare. È già installato. Tutto quello che devi fare, ancora una volta sta prendendo un nome cache tramite le impostazioni dell'app e quindi ecco il metodo di estensione. Quindi, se hai services.AddSignalR, su questo abbiamo un metodo di estensione in cui aggiunge NCache ha una SignalR Backplane per ASP.NET Core applicazioni.
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc();
services.Configure<NCacheConfiguration>(Configuration.GetSection("NCacheConfiguration"));
services.AddSignalR().AddNCache(ncacheOptions =>
{
ncacheOptions.CacheName = Configuration["NCacheConfiguration:CacheName"];
ncacheOptions.ApplicationID = Configuration["NCacheConfiguration:ApplicationID"];
// Uncomment in case of cache security enabled.
//ncacheOptions.UserID = Configuration["NCacheConfiguration:UserID"];
//ncacheOptions.Password = Configuration["NCacheConfiguration:Password"];
});
}Lo eseguirò molto velocemente perché ci vuole del tempo. Penso che molte cose stiano correndo. Quindi, eseguirò questo esempio. Quindi, questo farebbe girare un'applicazione di chat e la userebbe, dietro le quinte sta usando Pub/Sub Messaging di NCache. Quindi, quello che farò davvero è, tornerò qui e sul lato server ti mostrerei alcuni contatori delle prestazioni, che ti permetterebbero di gestire e monitorare in modo specifico i messaggi Pub/Sub e SignalR sta usando Pub/ Messaggistica secondaria dietro le quinte. Quindi, lasciami dire solo SignalR, giusto. Quindi, se noti qui, abbiamo una sezione di messaggistica proprio qui. Dove possiamo vedere le dimensioni dell'archivio messaggi, il conteggio dei messaggi, il numero di consegna al secondo, la scadenza al secondo, il numero di argomenti pubblicati.
Gli argomenti ti consentono di avere la separazione delle preoccupazioni. Molteplici applicazioni che utilizzano NCache come SignalR Backplane avrebbero più argomenti creati all'interno NCache. Quindi, argomenti di un messaggio di natura simile possono essere assegnati a un argomento separato. Ad esempio, puoi creare un argomento per gli ordini. È possibile creare un argomento per i messaggi ai clienti. Quindi, puoi avere messaggi diversi in argomenti diversi e agli abbonati collegati a un argomento separato vengono forniti solo quei messaggi ad essi correlati. Quindi, vedi già alcune attività qui, il che significa che la mia applicazione è attiva e funzionante. Quindi, se torno alla dashboard del server, ora abbiamo tre applicazioni in esecuzione. Non vedrò nulla nelle statistiche regolari. Vedrei tutto nelle statistiche di messaggistica. Quindi, puoi vedere il conteggio dei messaggi.
Quindi, c'erano alcuni messaggi, la dimensione del negozio, è di circa 800 byte. Messaggio pubblicato e poi abbiamo credo che altri parametri sulla data non ci siano perchè non abbiamo ancora nessuna scadenza.
Quindi, tornando alla mia applicazione, eseguirei un'altra istanza di questo. Va bene, quindi ho due applicazioni. Avrei dovuto eseguirlo in incognito ma il messaggio di prova non appena inviato questo, viene inviato anche qui. Prova il messaggio 2 e vedresti anche quel messaggio dall'altra parte, giusto, e se torno qui, abbiamo delle attività in corso qui.
Quindi, utilizza Pub/Sub Messaging dietro le quinte e ti consente di creare un backplane. Quindi, SignalR stesso, il caso d'uso per esso, che enfatizza la notifica push invece del polling degli utenti che puoi inviare ai tuoi utenti. Ma con la web farm, c'è una limitazione che puoi solo inviare il contenuto ai client connessi a quel server web. Se hai più web server hai bisogno di un corpo centrale e di un backplane di ASP.NET e ASP.NET Core lo risolve.
Quindi, puoi usare NCache come backplane per quello. È una piattaforma di comunicazione a cui vengono inoltrati tutti i messaggi NCache, Inviato a NCache e poi NCache a sua volta invia a tutti i server web, lo trasmette e quei server web sono in grado di trasmettere quei messaggi ai loro utenti finali, eventualmente. Quindi, questo è ciò che rende molto veloce l'architettura complessiva perché il NCache è in memoria. È super veloce, molto scalabile, molto affidabile, altamente disponibile.
Bene. Quindi, penso che siamo bravi su questo fronte. Qualsiasi domanda? Altrimenti andrò avanti e parlerò dell'aspetto della memorizzazione nella cache dei dati. Quindi, dedicheremo gli ultimi 10-15 minuti alla memorizzazione nella cache dei dati, alcune delle funzionalità. Ci sono molte caratteristiche su questo fronte. Quindi, ne mostrerei rapidamente alcuni.
Quindi, prima di tutto ci sono molti modi in cui puoi usare NCache per la memorizzazione nella cache del database o la memorizzazione nella cache dei dati dell'app. Dove metti nella cache i dati all'interno NCache & salvi i viaggi nel database di back-end. Se stai già utilizzando IDistributedCache, anche se è molto limitato, puoi collegarti NCache come fornitore.
Ho un'applicazione di esempio proprio qui. Ancora una volta, è molto semplice. È necessario aggiungere il pacchetto NuGet. È ASP.NET Core ed NCache.Microsoft.Estensioni.Memorizzazione nella cache.
public async Task<IActionResult> onPostResetCachedTime()
{
var currentTimeUTC = DateTime.UtcNow.ToString();
byte[] encodedCurrentTimeUTC = Encoding.UTF8.GetBytes(currentTimeUTC);
var options = new DistributedCacheEntryOptions()
.SetAbsoluteExpiration(TimeSpan.FromSeconds(20));
_cache.Set("cachedTimeUTC", encodedCurrentTimeUTC, options);
return RedirectToPage();
}Quindi, questo copre IDistributedCache e quindi hai bisogno delle impostazioni dell'app in cui specifichi il nome della cache e all'interno di startup.cs colleghi. services.AddNCacheDistributedCache fornisce le impostazioni tramite la configurazione oppure è possibile utilizzare l'opzione due in cui si specificano le configurazioni, tutte le impostazioni direttamente tramite il codice.
public void ConfigureServices(IServiceCollection services)
{
// Reading NCacheSettings using appsettings.json
services.AddNCacheDistributedCache(_config.GetSection("NCacheSettings"));
services.AddMvc().SetCompatibilityVersion(Microsoft.AspNetCore.Mvc.CompatibilityVersion.Version_2_2);
}E, in index.html.cs abbiamo alcuni metodi qui. Dove stiamo chiamando cache.GetAsync.
public string CachedTimeUTC { get; set; }
public async Task OnGetAsync()
{
CachedTimeUTC = "Cached Time Expired";
var encodedCachedTimeUTC = await _cache.GetAsync("cachedTimeUTC");
if(encodedCachedTimeUTC != null)
{
CachedTimeUTC = Encoding.UTF8.GetString(encodedCachedTimeUTC);
}
}E una cosa che devi notare è questa interfaccia IDistributedCache, ad esempio, se ti mostro GetAsync, sta riprendendo un array di byte. Quindi, quello che stai ricevendo non è un oggetto serializzato o deserializzato. Devi eseguire tu stesso la serializzazione e la deserializzazione.
using System.Threading;
using System.Threading.Tasks;
namespace Microsoft.Extensions.Caching.Distributed
{
public interface IDistributedCache
{
byte[] Get(string key);
Task<byte[]> GetAsync(string key, CancellationToken token = default);
void Refresh(string key);
Task RefreshAsync(string key, CancellationToken token = default);
void Remove(string key);
Task RemoveAsync(string key, CancellationToken token = default);
void Set(string key, byte[] value, DistributedCacheEntryOptions options);
Task SetAsync(string key, byte[] value, DistributedCacheEntryOptions options,
CancellationToken token = default);
}
}Quello che abbiamo fatto in questo esempio, lo abbiamo effettivamente preso in modo tale da serializzare l'oggetto prima di aggiungerlo e dopo averlo recuperato lo stiamo deserializzando, giusto. Quindi, stiamo riprendendo la corda attraverso questo.
public string CachedTimeUTC { get; set; }
public async Task OnGetAsync()
{
CachedTimeUTC = "Cached Time Expired";
var encodedCachedTimeUTC = await _cache.GetAsync("cachedTimeUTC");
if(encodedCachedTimeUTC != null)
{
CachedTimeUTC = Encoding.UTF8.GetString(encodedCachedTimeUTC);
}
}Quindi, questo è qualcosa che abbiamo fatto ampiamente ed è quello che devi fare. Insieme a NCache utilizzato direttamente come piattaforma di memorizzazione nella cache dei dati dell'app, non devi fare tutto questo. NCache serializzerebbe e deserializzerebbe automaticamente i tuoi oggetti. Devi solo contrassegnarli come serializzabili.
Quindi, eseguirò questo esempio molto velocemente e questo dovrebbe permettermi di mostrare anche l'interfaccia IDistributedCache e infine mentre viene eseguito vorrei anche creare, quindi questa è la nostra interfaccia IDistributedCache e questa è la seconda l'opzione qui, che sto mostrando proprio qui, è la diretta NCache API. Ecco le nostre API.
/*Cache Connection*/
Cache cache = NCache.InitializeCache("myCache");
cache.Dispose();
/*Fetching Data*/
Employee employee = cache.Get<Employee>("Employee:1000");
bool isPresent = cache.Contains("Employee:1000");
/*Writing Data*/
cache.Add("Employee:1000", employee);
cache.AddAsync("Employee:1000", employee);
cache.Insert("Employee:1000", employee);
cache.InsertAsync("Employee:1000", employee);
Employee employee = (Employee) cache.Remove("Employee:1000");
cache.RemoveAsync("Employee:1000");In alternativa, che ti consigliamo vivamente di ottenere un maggiore controllo se gestisci tutto tramite direct NCache Chiamate API. Ti connetti a NCache usando inizializza la cache o ottieni la cache nelle versioni correnti e poi dici cache.Ottieni per recuperare la cache degli elementi.Aggiungi per aggiungere elementi. Aggiungi Async è anche disponibile Inserisci e Inserisci Async è anche disponibile e quindi puoi chiamare cache.Remove. Quindi, questo è il secondo approccio che mostrerò una volta eseguito questo esempio e IDistributedCache è supportato, ma le nostre API dirette sono più ricche di funzionalità rispetto al confronto.
Domanda: Possiamo usare? NCache API insieme a IDistributedCache e per questo dove possiamo ottenere gli esempi?
Quindi, prima di tutto sì, puoi usare IDistributedCache. Devi già utilizzare IDistributedCache. Quindi, puoi collegarti NCache come fonte per questo. Quindi, questo potrebbe essere un punto di partenza e quindi, in aggiunta a ciò, puoi anche iniziare a utilizzare le nostre API dirette nella stessa applicazione. Quindi, sì, puoi farlo. Non ti limitiamo a usare l'uno o l'altro. Tutti questi casi d'uso di cui abbiamo discusso Session Caching, Response Caching, SignalR Backplane, IDistributedCache o diretto NCache Chiamate API. Cinque di queste funzionalità, puoi usarle tutte anche in un'unica applicazione. Quindi, questa è la bellezza di NCache dove puoi combinare tutti quei casi d'uso.
Applicazioni di esempio, tutti questi esempi sono, vengono installati NCache, Giusto. Quindi, non stiamo usando nulla di personalizzato qui. Quindi, tutti questi sono disponibili nel file di esempio del programma, NCache campioni. Questi sono pubblicati anche sul nostro sito web.
Quindi, questo esempio è stato eseguito. Quindi, se reimpostassi il tempo della cache, lo farebbe e se tornassi rapidamente qui, mostrerei le chiavi della cache e ora vedresti altre chiavi della cache. Penso che alcuni articoli siano scaduti ma vedi l'ora della cache UTC. Alcuni oggetti della cache delle risposte devono essere scaduti.
Quindi, è così che usi l'interfaccia IDistributedCache con NCache.
Ora mostrerò la diretta NCache Chiamate API, che consigliamo vivamente. È qualcosa che puoi fare anche tu. Quindi, per questo puoi usare il Alachisoft.NCache.Sdk Pacchetto NuGet. Questo è il nostro SDK completo, che include tutte le risorse lato client e tutte le funzionalità possono essere esposte sul client utilizzando questo SDK e in base a questo posso dire di includere questi spazi dei nomi Alachisoft.NCache.Cliente e puoi anche includere Alachisoft.NCache.Durata perché ci sono alcune funzionalità avanzate che puoi utilizzare attraverso quello.
using Alachisoft.NCache.Runtime;
using Alachisoft.NCache.Sample.Data;
using Alachisoft.NCache.Client;
using System;
using System.Configuration;
using Alachisoft.NCache.Runtime.Caching;
namespace Alachisoft.NCache.Samples
{
public class BasicOperations
{
private static ICache _cache;
}
}
...Interfaccia ICache. Questa è la nostra interfaccia a differenza di IDistributedCache, giusto. Quindi, abbiamo molte funzionalità come puoi vedere a confronto e all'interno di queste abbiamo anche più funzionalità. Quindi, questi sono alcuni oggetti su ICache.
Quindi, puoi inizializzare la cache. L'inizializzazione è completata NCache.Cliente. CacheManager.GetCache, quindi, è così che ti connetti ad esso. Ottieni un handle della cache e usando quell'handle della cache puoi impostare una scadenza basata sul tempo. Dare l'oggetto che è cliente in questo caso, Aggiungi ObjectToCache e stiamo ottenendo un cliente. Quindi dici cache. Viene aggiunto un elemento valore chiave. Quindi, l'oggetto cliente verrebbe serializzato automaticamente mentre lo aggiungeresti alla cache e quindi il recupero avviene tramite cache. Ottieni, aggiorna tramite cache. Inserisci, dove puoi modificare alcuni valori. Modifica il tempo di scadenza e quindi puoi chiamare la cache. Rimuovi anche per rimuovere i dati.
Quindi, all'interno di questo campione se rapidamente. Tutto bene. Quindi, sta ottenendo la cache dalle impostazioni dell'app. Se do il nome di questa cache per essere asp core cache, questo inizierà a utilizzare la stessa cache anche per la memorizzazione nella cache dei dati e l'hai già visto in cui ho usato la stessa cache all'interno di diverse applicazioni ma, se è una grande applicazione che utilizza tutte queste funzionalità in combinazione l'una con l'altra, in combinazione l'una con l'altra, è anche supportato.
Quindi, mentre questo è in esecuzione, ci sono molte funzionalità. Sto solo mostrando uno o due negli esempi perché quelle sono solo operazioni di base e questo aggiungerebbe alcuni dati nella cache. Potrebbe non fermarsi in nessun momento, non ne sono troppo sicuro, ma vediamo. Nel frattempo, se ti mostro un client è connesso. Ha fatto delle operazioni, giusto. Speriamo. Lasciami mettere un punto di interruzione da qualche parte ed eseguirlo ancora una volta.
Quindi, in realtà ha inizializzato la cache, ha aggiunto un oggetto, l'ha recuperato, aggiornato, recuperato di nuovo, quindi rimosso e quindi la cache è stata eliminata. Quindi, prima di smaltire ho inserito un punto di interruzione, quindi si spera che ora puoi vedere che inizializzati, aggiunti, recuperati, dettagli aggiornati, aggiornati nella cache. Quindi, tutti questi metodi sono stati eseguiti.
Quindi, ecco com'è semplice eseguire questo esempio. Tutto ciò di cui hai bisogno è il pacchetto NuGet e gli spazi dei nomi da includere e quindi giocare con diverse API, che mostrerò qui.
Sono disponibili molte funzionalità. Trascorrerò gli ultimi 5 - 6 minuti su diverse funzionalità, che sono disponibili come parte della nostra diretta NCache API. Quindi, puoi utilizzare la scadenza basata sul tempo. È disponibile la scadenza assoluta e scorrevole. Assoluto è quando dai un tempo in anticipo e i dati verrebbero rimossi allo scadere di quel tempo. Lo scorrimento è, se continui a utilizzare quei dati, supponiamo che tu abbia una scadenza scorrevole di 10 minuti, se non accedi a quell'elemento per 10 minuti, solo allora viene rimosso. Altrimenti, rimarrebbe nella cache, se continui a utilizzare quell'oggetto.
Puoi sincronizzare la tua cache con il database. Qualsiasi modifica al contenuto dell'elemento memorizzato nella cache, giusto. Ad esempio l'elemento memorizzato nella cache qualsiasi modifica nel record del database. Se hai elementi memorizzati nella cache che appartengono al database, qualsiasi modifica nel database invaliderebbe l'elemento dalla cache e abbiamo una dipendenza SQL per questo, che è basata sugli eventi. Abbiamo una dipendenza basata su DB, la dipendenza dal polling DB, che è basata sul polling. Raccoglie le modifiche e se rileva che alcuni record nel database sono stati modificati, rimuoverà gli elementi corrispondenti dalla cache. .NET CLR stored procedure, dove è possibile effettuare direttamente NCache Chiamate API direttamente dai server di database. Puoi sincronizzare la tua cache anche con database non relazionali. Dipendenze file disponibili. Puoi rendere gli elementi della cache dipendenti dai file. Oppure potrebbe essere anche una dipendenza personalizzata, in cui esegui un registro di codice con NCache e ciò determinerebbe se quell'elemento deve essere scaduto dalla cache. Quindi, in base alla tua logica aziendale, puoi far scadere gli elementi dalla cache. Abbiamo una dipendenza dalla base chiave. Puoi usarlo per gestire le relazioni tra gli elementi memorizzati nella cache. Quindi, le relazioni uno-a-uno, uno-a-molti e molti-a-molti possono essere gestite all'interno NCache.
Supporto lato server, il supporto del codice è molto ampio. È possibile utilizzare il pattern cache aside oppure è possibile utilizzare il pattern Read-through e Write-through, in cui si legge nella cache, dalla cache e, se i dati non sono nella cache, è possibile leggere la cache eseguendo il provider. È un'interfaccia che implementi e registri con noi e puoi leggere la cache e ottenere quell'elemento o distruggerlo dal database di back-end.
E il write-through è l'opposto, in cui aggiorni la cache e quindi puoi anche aggiornare automaticamente il database back-end chiamando il tuo gestore di write-through, un'interfaccia che implementi e registri e write-behind aggiornerebbe il database back-end in modo asincrono, che è molto veloce in confronto, dove non è necessario nemmeno per le operazioni di scrittura, l'elemento della cache verrà aggiornato solo nella cache e la tua applicazione ritorna e dietro le quinte, quindi la cache aggiornerà i database back-end.
Gruppi, sottogruppi sono disponibili. Puoi creare raccolte logiche all'interno NCache. I tag sono supportati. Puoi allegare parole chiave agli elementi e recuperare, rimuovere o recuperare o persino giocare o cercare elementi in base al tag corrispondente.
Sono disponibili ricerche simili a SQL. Sono supportate le ricerche SQL e LINQ. Puoi cercare gli articoli in base ai loro attributi. Puoi eseguire un criterio di ricerca, che può essere qualcosa come selezionare prodotti in cui prodotto è il tipo di oggetto in cui e dire seleziona prodotti in cui prodotto.prezzo è maggiore di 10 e prodotto.prezzo è inferiore a 100. Quindi, in base ai criteri specificati NCache formulerebbe il set di risultati nelle tue applicazioni.
Inoltre, sono supportate anche le query LINQ. Questi sono paralleli. L'indicizzazione dei dati è supportata come parte di questo. Ne hai bisogno come un must che rende la ricerca molto veloce NCache.
Messaggistica Pub/Sub ed Eventi
La messaggistica e gli eventi Pub/Sub sono una funzionalità separata. Abbiamo una piattaforma di messaggistica Pub/Sub basata su eventi asincroni. Abbiamo una query continua basata su criteri, in cui puoi mappare un set di dati e ottenere eventi da quel set di dati. Ad esempio, puoi mappare tutti i prodotti, in cui i prezzi dei prodotti sono inferiori a 100. Quindi, questo potrebbe essere il tuo set di dati. Qualsiasi cambiamento in quel set di dati verrebbe notificato.
Sono disponibili eventi di base chiave. Pertanto, puoi ricevere una notifica se un elemento viene aggiornato o rimosso o potrebbe essere a livello di cache in cui tutti gli elementi vengono monitorati.
Cluster di cache dinamica
Infine qualche dettaglio in merito NCache raggruppamento. Si basa sul protocollo di clustering dinamico della cache. NCache ti consente di aggiungere o rimuovere server al volo. Quindi, non c'è un singolo punto di errore. Nel caso in cui un server si interrompa, viene gestito all'interno del protocollo. Se aggiungi più server, inizia automaticamente a utilizzare il server appena aggiunto. Se un server si interrompe non hai tempi di inattività anche in quel caso e non c'è un singolo punto di errore principalmente perché ci sono più server che ospitano questa cache.
L'aggiunta e la rimozione di server è senza soluzione di continuità, per quanto riguarda le tue applicazioni. Ti offre il 100% di tempo di attività, uno scenario di cache altamente disponibile e poi abbiamo già trattato le topologie.
Abbiamo alcuni Cache cliente. Replica WAN caratteristiche. È possibile avere la replica da sito a sito tra siti attivo-attivo o attivo-passivo. Anche quello è gestito.
Quindi, sai che l'elenco potrebbe continuare. Penso che abbiamo coperto molti dettagli e volevo darti una rapida panoramica di come puoi effettivamente utilizzare NCache nell'ASP.NET Core. Quindi, ci stiamo già dirigendo verso la fine di questa presentazione. Penso che un'ora.
Penso che concludiamo questo a questo punto. Per favore fatemi sapere se ci sono domande finora? Altrimenti lo consegnerò a Zack e poi potrà riprenderlo da lì. Qualsiasi domanda? Lasceremo la parola aperta per circa un minuto. Se hai qualche domanda o ne stai ancora pensando ad alcune, sentiti libero di buttarle fuori.
E già che ci siamo, abbiamo praticamente coperto tutte queste funzionalità che stai vedendo. ASP.NET Core Sessioni, cache delle risposte, SignalR Backplane, IDistributedCache, Caching dei dati e direct NCache Chiamate API e abbiamo anche applicazioni di esempio per la messaggistica Pub/Sub, se sei interessato separatamente a questa sezione, puoi anche ottenere un'applicazione di esempio separata disponibile.
Domanda: Questa presentazione sarà disponibile in seguito?
Si lo sarà. Saremo in grado non solo di ottenere una registrazione del webinar, ma avremo anche a disposizione le diapositive se desideri scaricare e utilizzare anche quelle e riceverai un'e-mail che ti collegherà al webinar registrato una volta che è pronto. Quindi, puoi sempre visitare il nostro sito Web una volta che è in diretta e sotto i webinar registrati puoi trovarli.
Domanda: Qual è la differenza tra IDistributedCache e NCache ASP.NET Core Fornitore del negozio di sessioni?
Ok, quindi, credo che la domanda sia più focalizzata sulla differenza di utilizzo della sessione tramite IDistributedCache e Session lo utilizzi tramite il nostro provider di cache. Quindi, a un livello elevato IDistributedCache è limitato in termini di funzionalità. NCache provider ti dà più controllo. Prima di tutto, puoi utilizzare il blocco della sessione. IDistributedCache Session è un archivio non basato sul blocco. È possibile utilizzare sessioni a sito singolo e multisito. Questa è una caratteristica specifica all'interno NCache che non è disponibile in IDistributedCache. Sebbene, NCache supporta IDistributedCache Session Provider così com'è. Ti offre molti vantaggi oltre a IDistributedCache, ma quando confrontiamo le sessioni di IDistributedCache con NCache e tu sai, NCache Provider dell'archivio sessioni con NCache, ecco dove NCache fornitore ha un vantaggio netto. Poi ci sono molte funzionalità come la condivisione di sessioni tra diverse applicazioni. Esiste un attributo dell'ID app di sessione che puoi specificare. Le tue eccezioni possono essere registrate nel registro eventi, è possibile creare registri della cache, è possibile creare registri client. Quindi, c'è un enorme elenco di funzionalità che sono diverse tra queste due.
Quindi, è altamente raccomandato se stai usando la cache di sessione con NCache, quindi consiglierei personalmente di rivedere il nostro provider di archivio sessioni rispetto a IDistributedCache Session con NCache perché ottieni molti vantaggi.
Domanda: In che modo il raggruppamento dei dati può semplificare il recupero dei dati?
Destra. Quindi, alleghi un gruppo a più elementi e poi ci sono API basate su gruppi in cui dici di ottenere i dati del gruppo e ottieni tutti quegli elementi contemporaneamente. Quindi, non devi fornire le chiavi di quei singoli oggetti separatamente. Quindi, con una chiamata API, tutti i dati del gruppo possono essere recuperati. Puoi rimuovere i dati in una chiamata API. Quindi, è così che il processo di recupero e aggiornamento è più semplice in confronto.