Sei modi per ottimizzare NCache Prestazione

Webinar registrato
Di Kal Ali e Sam Awan

NCache è una popolare cache distribuita in memoria open source per .NET. Ti aiuta a ridimensionare le tue applicazioni .NET memorizzando nella cache i dati delle applicazioni e riducendo i costosi viaggi del database. NCache scala in modo lineare consentendo di aggiungere più server cache al cluster del livello di memorizzazione nella cache.

Scopri come ottimizzare NCache prestazioni configurandolo correttamente e anche utilizzando le sue funzionalità di potenziamento delle prestazioni.

Questo webinar riguarda:

• Introduzione alla NCache e la sua architettura
• Modi comuni NCache viene usato
• NCache funzioni di potenziamento delle prestazioni
• NCache opzioni di configurazione per aumentare le prestazioni

Panoramica

Oggi presenteremo un webinar su sei trucchi per migliorare NCache prestazione. La modalità di questo webinar sarebbe di solo ascolto. Avrai la possibilità di porre qualsiasi tipo di domanda desideri. C'è una scheda di domande e risposte nel riquadro di destra. Sarai in grado di digitare le tue domande e uno di noi sarà in grado di rispondere a queste domande per te. Durante il webinar, se hai domande o dubbi e se non sei in grado di ascoltarci, per favore, ancora una volta puoi utilizzare la finestra della chat. Kal parlerà di tutta la parte tecnica della presentazione. Se c'è qualcosa che non è così tecnico o legato alle vendite, potete rivolgere le vostre domande direttamente a me. Detto questo, lo consegnerò a Kal e lui inizierà la presentazione.

Tutto bene. Grazie Sam. Potresti confermare che sei in grado di vedere il mio schermo, perché ho appena iniziato a condividerlo? Sì, posso vedere il tuo schermo perfettamente bene. Va bene, perfetto. Quindi, ciao ragazzi, quando Sam mi ha appena presentato, mi chiamo Kal e l'argomento del webinar di oggi è Sei modi per ottimizzare NCache Prestazioni

Quindi, nel webinar di oggi tratteremo alcuni dettagli generali in merito NCache e anche quali funzionalità puoi utilizzare all'interno della tua applicazione per ottimizzare le prestazioni. Così, NCache è già una soluzione per le prestazioni. Aumenta rapidamente le prestazioni delle tue applicazioni, perché riduce i tuoi viaggi al database. Ma con queste funzionalità puoi effettivamente migliorarlo ulteriormente e questi sei trucchi saranno effettivamente basati su casi d'uso. Presenterò un caso d'uso insieme a ciascuno di essi e in base a quello che si applica al tuo scenario specifico, puoi sicuramente usarlo e vedere come funziona per te. Quindi, tratteremo alcune esercitazioni pratiche, sai, demo di diverse applicazioni e in base a ciò vedremo come in diverse situazioni NCache funziona e come queste caratteristiche effettivamente ci aiutano. Quindi, ho intenzione di procedere con la presentazione ora.

Il problema della scalabilità

Quindi, prima di tutto, parliamo effettivamente del problema di scalabilità riscontrato nella maggior parte degli scenari di distribuzione. Quindi, di solito hai una web farm, che si trova dietro a bilanciamento del carico e questo tipo di livello, questo scenario è generalmente molto scalabile. Perché, poiché vedi che c'è più carico in arrivo sulle tue applicazioni, puoi semplicemente aggiungere più server a questo livello e ciò aumenterebbe effettivamente la capacità del tuo ambiente, in termini di carico totale che può assumere o per esempio richieste totali che può ricevere, diciamo, contro in un secondo.

Il vero problema, il vero collo di bottiglia risiede nel punto in cui queste applicazioni devono entrare in contatto con l'origine dati di back-end. Forse per ottenere alcuni dati di riferimento, forse per ottenere un altro tipo di dati che sono archiviati lì. Quindi, fondamentalmente è lì che si trova il collo di bottiglia. Di solito l'origine dati di back-end è un database. Come tutti sappiamo, i database sono eccellenti per l'archiviazione, ma il problema sta nel fatto che generalmente sono lenti perché sono su disco. Tendono a soffocare con un carico di transazioni elevato e non sono molto scalabili.

La Soluzione

Quindi, in tali scenari le aziende/organizzazioni tendono a muoversi verso a NoSQL database, ma a questo punto non è l'approccio ottimale. Perché ciò richiede un'intera modifica dell'architettura, non solo all'interno dell'applicazione ma anche all'interno dei dati effettivi per renderli compatibili tra loro. Quindi, in tali scenari, un approccio ottimale sarebbe una cache distribuita in memoria, ad esempio NCache, che è più veloce e più scalabile, perché tutto è posizionato all'interno della memoria. Quindi, se lo confrontiamo con un database, in quel caso era presente sul disco. Quindi, ora abbiamo tutto ciò che è presente nella memoria. È più scalabile perché la cache distribuita è logicamente una singola unità ma sotto hai più server indipendenti che ospitano questa cache in cluster.

È una topologia molto scalabile. Puoi aggiungere tutti i server che vuoi qui. Come sapete, ciò che fa è fondamentalmente raggruppare non solo le risorse di memoria per tutti questi server, ma anche la potenza di calcolo di tutte queste risorse. Quindi, aggiungendo più numeri di server, aumenta la capacità della cache in termini di dati totali che possono essere archiviati. Così come le operazioni totali o il carico totale che può richiedere.

Quindi, quando vedi che c'è più carico in arrivo nella tua web farm, puoi effettivamente aumentare il numero di server anche nel tuo cluster di memorizzazione nella cache e ciò renderebbe anche questo livello scalabile. Quindi, ora il tuo livello di memorizzazione nella cache corrisponde alle richieste in arrivo dalla web farm. Quindi, ora aiuta effettivamente a rimuovere quella parte di non scalabilità che era presente con il database. La parte migliore di questo è che non è un sostituto di un database. Puoi usarlo insieme ad esso. Quindi, quello che fa è fondamentalmente il cluster di cache si trova proprio tra le tue applicazioni e il tuo database. Puoi comunque effettuare chiamate dirette. Ma quello che fa è che puoi fare NCache la tua unica fonte di dati e l'utilizzo che abbiamo delle funzionalità del livello di accesso ai dati fornite con questa cache, attraverso le quali puoi effettivamente, la cache può effettivamente scrivere dati sulle origini dati back-end e ottenere dati dal back-end Origine dei dati.

Quindi, utilizzando questo, la tua cache rimane sincronizzata con le origini dati di back-end. Quindi, hai dati aggiornati da una fonte più veloce perché sono presenti nella memoria ed è anche una fonte più scalabile. Quindi, è un ottimo compromesso in questo caso.

NCache Distribuzione

Quindi, parliamo del NCache distribuzione in questo diagramma. Quindi, qui se puoi vederlo, questi sono fondamentalmente i tuoi server di applicazioni o server Web in cui hai ospitato la tua applicazione. Di solito sono seduti dietro un bilanciatore di carico. In precedenza effettuavano chiamate dirette alle origini dati di back-end, come un database, ma ora è presente il livello di memorizzazione nella cache proprio qui. Questa è la distribuzione consigliata da noi è che tu abbia un livello di memorizzazione nella cache dedicato che ospita le tue cache in cluster.

Quindi, quello che stanno facendo le tue applicazioni, stanno facendo NCache l'unica fonte di dati. Tutte le loro richieste per ottenere dati o anche una sorta di elaborazione vengono eseguite direttamente sulla cache e se la cache non le dispone utilizzando quei provider di livello di accesso ai dati, può effettivamente recuperare dalle origini dati. Quindi, questo è ciò che sta facendo nel tuo ambiente. Questi server, come accennato in precedenza, sono consigliati per essere server dedicati e sono server molto economici. L'unico prerequisito per NCache in questo caso è solo il .NET framework. Su questi server che ospitano la cache del cluster, hai l'installazione del server cache, che ha la capacità di ospitare cache del cluster e sul client, su queste caselle client proprio qui, che sono i tuoi server delle applicazioni, hai il remote client installazione, che può ospitare cache locali e può effettivamente aiutare a connettersi a cache cluster remote.

Quindi, ecco come appare la distribuzione. Tutto questo è linearmente scalabile. Man mano che aggiungiamo un numero maggiore di server, aumenta la capacità totale della cache.

Tre usi comuni di NCache

Parliamo dei tre usi comuni di NCache. Sto esaminando rapidamente tutte queste cose perché voglio arrivare a quei sei modi e ottenere i dettagli per quelli, quindi, se ci sono domande posso sicuramente rispondere a quelle. Quindi, parliamo dei tre usi comuni di NCache.

1. Memorizzazione nella cache dei dati dell'applicazione

   Il primo è la memorizzazione nella cache dei dati dell'applicazione. Quindi, in questa diapositiva stavamo parlando dei tre usi comuni di NCache. Quindi, il primo è la memorizzazione nella cache dei dati dell'applicazione. In questo caso, in pratica, quello che fai è introdurre il NCache API all'interno della tua applicazione e utilizzando quell'API puoi aggiungere elementi e ottenere elementi dalla cache e puoi eseguire diverse operazioni sulla cache, dove e come sono richieste. E allora NCache ha la capacità host di, in pratica, puoi memorizzare nella cache qualsiasi cosa all'interno NCache. Possono essere immagini, alcuni oggetti personalizzati, oggetti di dominio, possono essere raccolte, praticamente qualsiasi cosa. Quindi, tutto ciò che è consentito per .NET può essere memorizzato nella cache all'interno NCache e utilizzando le tue applicazioni introducendo il NCache API, molto semplice da usare, molto facile da usare, puoi effettivamente eseguire diverse operazioni sulla cache e aggiungere e recuperare elementi.

2. ASP.NET, ASP.NET Core Caching

   Il prossimo caso d'uso riguarda ASP.NET, ASP.NET Core memorizzazione nella cache. Quindi, il primo è che puoi usare NCache come provider dello stato della sessione. Può essere a sito singolo o multisito. Il prossimo è che puoi avere NCache memorizza il tuo stato di visualizzazione. Questo è qualcosa che è pre-MVC. Dopodiché il concetto di stato di vista non era più presente. Dopo di che abbiamo per ASP.NET abbiamo il provider della cache di output. NCache può agire come quello e quindi per ASP.NET Core applicazioni può essere Core Response Caching. Quindi, puoi farlo con NCache. NCache può anche fungere da SignalR Backplane. Quindi, tutte queste opzioni che sono appena state trattate nel numero 2 non sono in realtà opzioni di modifica del codice. Non è necessario apportare alcun tipo di modifica al codice. Puoi semplicemente aggiornare il file di configurazione delle tue applicazioni e utilizzare quelli che puoi effettivamente avere NCache per archiviare qualsiasi cosa si desidera archiviare. Potrebbe essere Sessions, potrebbe essere View State, potrebbero essere i tuoi output o persino il Core Response Caching. Quindi, usando questo puoi avere NCache conservare quelle cose. Quindi, sostanzialmente in questo caso, di nuovo nessuna opzione di modifica del codice, molto facile da usare. Sono necessari un paio di passaggi. Abbiamo una documentazione completa. Abbiamo anche campioni e seguendo quei passaggi e quella documentazione, anche i campioni, puoi configurarlo entro 15 minuti. Puoi avere tutto pronto. Possiamo effettivamente testarlo, vedere come funziona per te.

3. Pub/Sub e Condivisione dei dati di runtime tramite eventi

   Il prossimo è Pub / Sub ed Condivisione dei dati di runtime tramite eventi. Quindi, in pratica in questo caso hai, diciamo, app serverless e vuoi assicurarti che ci sia una sorta di sincronizzazione tra loro vogliono passare determinati messaggi, determinati dati. NCache può essere usato come mezzo proprio per questo. Potresti avere editori, potresti avere abbonati e loro potrebbero pubblicare alcuni messaggi. Gli abbonati che sono registrati a quelli, diciamo, i clienti possono effettivamente ottenere quelli per ottenere quei dati da quelli da NCache in quel caso.

   Quindi, un tipico esempio potrebbe essere un'applicazione di chat di gruppo. Forse hai membri del gruppo, tutti collegati alla stessa cache, in realtà sono in una chat di gruppo. Uno dei membri pubblica un messaggio, tutti gli altri membri di quel gruppo riceveranno una notifica di quei dati che sono stati aggiunti. Quindi, questo è solo un esempio di base e poi abbiamo anche guidato le notifiche e le query continue.

Quindi, queste erano le cose che NCache effettivamente offre te e ciò che è fondamentalmente utilizzato dalla maggior parte dei nostri clienti.

NCache Architettura

Parliamo effettivamente del NCache Architettura adesso. Spieghiamo come funziona? Quindi in poche parole NCache è un'architettura peer-to-peer al 100%. Non c'è un singolo punto di errore e non c'è nessuno schiavo padrone o regola della maggioranza o un concetto simile all'interno NCache. I server possono essere aggiunti e rimossi al volo. La cache non ha bisogno di essere fermata e continuerebbe a funzionare bene. Anche nel caso in cui se uno dei server si arresta, sostanzialmente in uno scenario imprevisto, il cluster non funziona, il cluster completo non si arresta. Avvia la logica di ripristino, tra i server a redistributare quei dati o ottenere i dati da uno dei backup e sul lato client i client effettivamente effettuano il failover delle loro connessioni ai server rimanenti presenti all'interno del cluster.

Quindi, usando questo i dati in realtà non vengono persi e i client sono effettivamente le loro connessioni, eseguono il failover sugli altri server. Quindi, continuano a fare le richieste anche se uno dei server si è interrotto. Quindi, finché hai un server attivo e funzionante, la tua richiesta verrebbe gestita.

Quindi, tutte queste modifiche, tutti questi server di modifiche alla configurazione aggiunti, rimossi al volo per scenari imprevisti, tutti questi vengono effettivamente propagati in tutto il cluster. Quindi, tutte queste configurazioni sono in realtà dinamiche. Qualsiasi aggiornamento all'interno del cluster e in termini di configurazione viene mappato su tutti i server presenti all'interno del cluster e anche i client lo sanno automaticamente.

NCache Requisiti di sistema

Server di cache

Parliamone il NCache requisiti di sistema. Quindi, generalmente in termini di, diciamo, se parli di core, più sono e meglio è. Ma, in generale, consigliamo di avere 8+ core. Le tre cose principali che NCache utilizza CPU, risorse di rete e memoria. La CPU viene utilizzata fondamentalmente per gestire le richieste in arrivo, o forse se è presente del codice lato server configurato per eseguire quel tipo di operazioni, ecco perché viene utilizzata la CPU. In secondo luogo, la RAM viene utilizzata solo per l'archiviazione e forse un po' di sovraccarico coinvolto dopo che i dati sono stati archiviati e nelle risorse di rete vengono utilizzate per mantenere la comunicazione. Ad esempio, da server a server di comunicazione e quindi da client a server di comunicazione. Quindi, hai entrambe queste opzioni e quindi i server Windows consigliati sono 2012, 2016. L'unico prerequisito di NCache is .NET framework, in caso contrario, è supportato in tutti gli ambienti Windows.

Remote Clients

In termini di remote clients, l'unico prerequisito è avere .NET 4.0 o versioni successive e il tuo client sarebbe effettivamente supportato. Puoi avere NCache su quei server.

Ambiente di installazione

Quindi, ora che abbiamo parlato delle diverse cose, della base, sai, dell'introduzione riguardante NCache, parliamo di come possiamo impostare l'ambiente. Quindi, ogni volta che abbiamo clienti che valutano il nostro prodotto, ciò che diciamo loro, diamo loro cinque passaggi con cui lavorare NCache. Il primo è scaricare una nuova copia del file NCache Enterprise dal sito Web e il secondo è quello di installare NCache all'interno del tuo ambiente. Io ho NCache già installato su due delle mie macchine. In realtà sono scatole remote demo1 e demo2. E, su queste scatole una volta installato NCache, ottengo uno strumento di gestione di NCache detto NCache direttore. Usando questo strumento posso effettivamente creare cache, configurarle ed eseguire diverse operazioni e persino monitoraggio è coinvolto in questo caso.

Crea una cache tramite NCache direttore

Quindi, andiamo avanti e apriamo il NCache manager qui. Ho solo bisogno di cercare NCache e viene automaticamente fuori. Quindi, una volta aperto, questa è la vista che ottieni. Quindi, ora ciò che dobbiamo fare è creare una nuova cache in cluster. Per crearlo, fai clic con il pulsante destro del mouse su "Cache raggruppate", fai clic su "Crea nuova cache raggruppata".

Quindi, qui quello che devo fare è dargli un nome. Vado avanti e gli darò un nome "democache". Tutte le cache devono essere nominate. Lo terrò solo. Vado a fare clic su Avanti.

Queste sono le quattro topologie offerte da NCache Manterrò selezionata la "replica partizionata" perché è la più consigliata e la più popolare tra tutti i nostri clienti. È molto scalabile, molto affidabile.

Questa è la strategia di replica tra la partizione attiva e la partizione di backup nel caso di replica partizionata. Lo terrò su Async, perché è più veloce.

Qui è dove specifico questi server che ospiteranno questa cache in cluster. Quindi, qui specificherò demo1 e demo2. Queste sono le due caselle che ho, 107 e 108 e faccio clic su Avanti.

Questa è la porta del cluster su cui comunica il cluster. Viene prelevato automaticamente.

Questa è la dimensione configurata su ciascuna scatola. Quindi, ci saranno 2 Giga di dimensione totale, uno su server1 e uno su server2.

Queste sono alcune opzioni avanzate. Forse se hai la cache che ottiene uno scenario completo, la cache può rimuovere automaticamente gli elementi dalla cache. Se si tratta di dati sensibili, puoi effettivamente disattivare lo sfratto, in modo che gli elementi non vengano rimossi da soli e quindi hai anche la possibilità di avviare automaticamente la cache non appena si avvia, non appena la macchina si avvia. Quindi, farò semplicemente clic su Fine e questo creerà effettivamente la mia cache.

Quindi, ecco com'è stato facile creare una cache. Ho la cache configurata ora. Se faccio semplicemente clic con il pulsante sinistro del mouse sul nome della cache, si aprono qui tutte queste diverse schede attraverso le quali posso apportare ulteriori modifiche o configurazioni se necessario a questo punto.

Quindi, la prossima cosa che farò è aggiungere la mia casella personale come a remote client. Per fare ciò, fai semplicemente clic con il pulsante destro del mouse sul nome della cache e fai clic su aggiungi nodo.

E qui darò solo l'IP della mia casella personale, che è 102 e ora è stato aggiunto.

Quindi, una volta aggiunto, farò semplicemente clic con il pulsante destro del mouse sul nome della cache e farò clic su Start. Quindi, ora la cache viene avviata su 107 e 108 box. Una volta installato e funzionante, aprirò le statistiche e ti mostrerò anche uno strumento di monitoraggio di NCache detto NCache monitor, che approfondisce i dettagli in merito al controllo di cose sostanzialmente diverse che stanno accadendo all'interno della cache. Quindi, la cache è attiva e funzionante ora. Per aprire le statistiche, fai clic con il pulsante destro del mouse sul nome della cache e fai clic su statistiche.

Quindi, questo è ciò che tirerà su tutte queste statistiche per entrambe le caselle 107 e 108.

Quindi, ora apriamo effettivamente il strumento di monitoraggio di NCache. Per aprirlo, fai clic con il pulsante destro del mouse sul nome della cache e fai clic sul cluster di monitoraggio.

I NCache monitor ora si aprirà, il che ci darà due dashboard preconfigurati, ovvero il dashboard del server e il dashboard di visualizzazione dei report. Quindi, usando questo puoi avere un'idea abbastanza chiara di cosa sta succedendo all'interno della cache. Se vediamo qui, questa è, ad esempio, la dimensione della cache, che viene attualmente consumata e quindi questo è il grafico delle richieste al secondo. Quindi, ti fornisce molti dettagli diversi che sono attualmente in corso nella cache e puoi utilizzare questi dettagli per eseguire il debug di alcuni scenari o andare in fondo se stai riscontrando qualsiasi tipo di problema.

Quindi, ho intenzione di tornare rapidamente al NCache manager e qui puoi anche creare la tua dashboard personalizzata. Se hai alcune cose che vuoi guardare non quelle che sono preconfigurate qui, puoi farlo anche tu. Hai i controlli presenti qui sotto la categoria del server cache e quindi anche nella categoria dei client cache. Puoi anche creare le tue dashboard personalizzate per vedere solo le cose che ti interessano davvero. Quindi, torniamo al NCache gestore. Tutto viene visualizzato a zero perché non abbiamo applicazioni in esecuzione su questa cache.

Simula lo stress e monitora le statistiche della cache

Quindi, in realtà, testiamolo rapidamente eseguendo un'applicazione. Quindi, ho il PowerShell aperto qui. In realtà chiariamolo. In realtà apriamone uno nuovo. Ok, quindi, ho un PowerShell che si apre. Quindi, quello che farò è eseguire l'applicazione dello strumento di stress per aggiungere un carico fittizio alla mia cache in cluster, per simulare alcune attività. Quindi, usando quell'attività, l'avremo anche monitorata attraverso il NCache manager, nonché, tramite il NCache monitor, guarda come funziona per noi.

Quindi esegui quello strumento di stress test. Devo digitarlo di nuovo. Prima uccidiamo il processo. Nel frattempo, se hai domande, non esitare a pubblicarle nella scheda Domande e risposte. Kal, non credo che abbiamo domande al momento. Va bene, perfetto. Qualche motivo per cui non sta raccogliendo. Sono tornato Sì. Scusate, stavo giusto per dirlo, ragazzi, questa sessione è in registrazione. Quindi, per qualsiasi motivo se non sei in grado di partecipare alla sessione completa o se ti sei perso la parte iniziale, potresti controllare questa registrazione. Credo che lo pubblicheremo più avanti nella settimana o all'inizio della prossima settimana. Quindi, sarai in grado di andare avanti e ripetere l'intera sessione.

Quindi, quello che sto facendo in questo momento è che sono effettivamente andato direttamente in quella directory, per aprire il prompt dei comandi lì ed eseguire lo strumento di stress test. Ok, quindi, vediamo, sì, è stato rilevato, vado avanti e gli darò il nome stresstesttool.exe e poi la cache demo. Quindi, ora quello che farebbe è aggiungere alcuni dati fittizi alla cache. Se torniamo qui, dovremmo vedere alcune attività in arrivo su queste due scatole in questo momento. Eccolo. Quindi, vediamo alcune attività in arrivo su entrambe queste caselle 107 e 108.

Nella topologia che abbiamo selezionato replica partizionata, ogni client ha una connessione a tutti i nodi server presenti all'interno del cluster, ecco perché si connette a entrambi i server. Se veniamo al NCache monitor, possiamo vedere che c'è un client connesso contro 108 e uno contro 107. Se guardi il NCache richiesta al secondo grafico, possiamo vedere che c'è qualche attività in corso.

Quindi, questo test era solo per verificare se tutto è, la cache è configurata correttamente, tutto funziona perfettamente ed è stato testato. Quindi, interromperò l'applicazione dello strumento di stress test. Ora, torniamo al NCache gestore. Andiamo avanti e svuotiamo questa cache, in modo che per il nostro ulteriore test non siano presenti elementi all'interno della cache. Quindi, tutto viene visualizzato a 0. Torniamo alla presentazione. Quindi, il nostro ambiente è ora configurato ed è tutto pronto. Quello che possiamo fare ora è procedere con le diapositive.

NCache Trucchi: ottimizzazione delle prestazioni

Quindi, parliamo dei sei modi che utilizzeremo per ottimizzare le prestazioni, uno per uno. Giusto per ribadire NCache, la cache del cluster è già una caratteristica delle prestazioni che, sai, le prestazioni migliorano le prestazioni all'interno della tua applicazione, i viaggi del database vengono ridotti e quindi trovi i dati da un'origine più veloce che è una cache distribuita in memoria. Ma queste funzionalità ti aiuteranno effettivamente a migliorare ulteriormente le prestazioni a seconda del tuo caso d'uso specifico.

• Cache cliente

  Quindi, il primo di cui parleremo è cache del cliente. Quello che fa è fondamentalmente ridurre i tuoi viaggi alla cache in cluster effettiva.

• Chiamate in blocco

  Quindi parleremo di chiamate in blocco, che riducono i viaggi nella cache in modo tale da eseguire solo una singola operazione e utilizzando una sola chiamata e più operazioni in cambio verranno elaborate sul server.

• Compressione

  Allora hai anche compressione. Forse se la dimensione dell'oggetto è maggiore, puoi utilizzarla per ridurre l'intera dimensione dell'oggetto che viene aggiunto o recuperato. In genere, si consiglia di scomporre l'oggetto in dimensioni più piccole, ma nel caso in cui non sia possibile è possibile utilizzare la funzione di compressione.

• Aggiornamenti asincroni

  Abbiamo anche aggiornamenti asincroni. Quindi, usando questi, in pratica la tua applicazione non attende che l'operazione venga eseguita. Forse puoi creare un'attività separata per questo e quindi in base a ciò puoi permetterti che i dati vengano aggiunti da soli e se c'è qualche tipo di aggiornamento che vuoi recuperare, forse i dati sono stati aggiunti o meno o se c'è era un problema puoi semplicemente registrarti per una richiamata contro quello.

• Serializzazione compatta

  Il prossimo è serializzazione compatta. Quindi, ad esempio, se hai oggetti personalizzati, oggetti di dominio, che non sono contrassegnati come serializzabili e all'interno di una cache distribuita, poiché è completamente fuori processo, sarà necessario serializzare tutti gli oggetti. Quindi, se hai questo scenario in cui non puoi permetterti di modificare il codice all'interno del tuo ambiente ma devi anche avere i tuoi oggetti personalizzati o oggetti di dominio serializzabili, puoi usare la funzionalità di serializzazione compatta di NCache per contrassegnarli tutti come serializzabili e quindi utilizzarli che puoi effettivamente continuare a utilizzare NCache all'interno del tuo ambiente. Non è un'opzione di modifica del codice. Solo qualcosa che puoi capire dalla GUI e hai tutto impostato.

• Doppia scheda di rete

  E poi finalmente abbiamo il doppia scheda di rete caratteristica. Quindi, se vuoi separare fondamentalmente il traffico dalla comunicazione client a server e dalla comunicazione server a server, separare le risorse di rete, puoi effettivamente farlo con NCache. Questo è solo nel caso in cui tu abbia, dove sai, le tue risorse di rete effettivamente soffocate dal traffico in eccesso che sta entrando. Solo in quegli scenari lo consigliamo. Ma, se a quel punto non vedi che quelle risorse sono state esaurite, puoi effettivamente mantenere la stessa scheda di interfaccia di rete per entrambi i tipi di comunicazioni.

Dimo

Quindi, eseguiamo effettivamente il nostro primo test, in cui aggiungeremo elementi alla cache e recupereremo elementi dalla cache e lo useremo come linea di base con l'API di base che abbiamo. Ancora una volta, è già ottimizzato, ma lo useremo come linea di base ed eseguiremo diverse funzionalità su di esso e vedremo come funzionano per noi.

Quindi, il primo, torniamo effettivamente a questo esempio proprio qui. Quindi, questo è un esempio che posso effettivamente fornire anche questo codice. Questo è ciò che useremo per mostrarti la linea di base che tratteremo. Quindi, siamo nel test 1. Nel test 1 quello che stiamo facendo è fondamentalmente aggiungere 5,000 elementi nella cache di dimensioni 100 KB e quindi recuperare quegli elementi dalla cache. Questo test ci darà solo il tempo necessario per l'intero codice, questa parte di recupero richiederà. In questa parte di recupero, il ciclo viene eseguito in realtà 5000 volte, perché è necessario recuperare 5000 elementi e nelle diapositive successive tratteremo come funzionalità diverse possono effettivamente aiutare in questo caso.

...
try
    {
        cache = NCache.InitializeCache(args[0]);
        cache.Clear();

        Console.WriteLine("TEST 1\n");
        Console.WriteLine("Press anything to add " + objectsCount + " items (100kb Object)");
        Console.ReadKey();
        Console.WriteLine("Adding items now");

        for (int i = 0; i < objectsCount; i++)
            {
                cache.Insert(key + i, obj1);
            }

        Console.WriteLine(objectsCount + " items added. Press any key to retrieve them.");
        Console.ReadKey();
        Console.WriteLine("\nRetrieving " + objectsCount + " items now");
        datetime1 = DateTime.Now;
        ...

Quindi, eseguiamo effettivamente questo. Verifichiamo innanzitutto che tutto sia impostato correttamente. Sì, democache test 1 e lo eseguirò. Quindi, ancora una volta questo è il test numero uno, solo per avere una linea di base di come appaiono i numeri. Premerò Invio. Inizierà ad aggiungere elementi nella cache. Se torniamo al NCache manager, ecco qui, vediamo che c'è dell'attività in corso. Quindi, sta aggiungendo elementi nella cache. Poiché ci sono due server nella partizione della topologia di replica, i dati vengono aggiunti su entrambi questi server, vengono aggiunti sul server 1 che è 107 e anche sul server 2. Quindi, i dati verranno divisi. Su tutti gli elementi totali all'interno della cache saranno 5,000.

Quindi, in questo caso, attendiamo il completamento e una volta completato, possiamo effettivamente annotare quel numero e usarlo per il nostro confronto per le funzionalità successive con cui testeremo. Abbiamo quasi finito, abbiamo già aggiunto circa 4,000 articoli.

Tieni presente che è un oggetto da 100 KB, che è una dimensione abbastanza grande per, sai, il test, ma questo era solo per mostrarti come appaiono le cose. Penso che siano tutti aggiunti, sì, sono tutti aggiunti. Il contatore si è effettivamente fermato. Se facciamo clic su Invio, ci è voluto, se facciamo clic su Invio inizierà a recuperare questi elementi dalla cache e se torni qui visualizzerà l'ora una volta che lo fa. Quindi, possiamo vedere che i recuperi al secondo stanno effettivamente aumentando e anche le richieste al secondo per entrambi questi server. Quindi, questo in realtà ti mostra che c'è un po' di attività in corso che inizia a recuperare quegli elementi dalla cache. Una volta terminato il recupero di tutti i 5000 elementi dalla cache, visualizzerà il timer sullo schermo e utilizzando quel timer lo imposteremo come base per i nostri prossimi test.

Cache client (vicino alla cache)

Quindi, parliamo effettivamente del prossimo. La prossima, la funzione effettiva che useremo per prima è la cache del client. Quindi, lascia che ti spieghi cos'è una cache client? Una cache client è fondamentalmente una cache locale, presente sulle caselle client e su queste caselle client, ciò che fa è ridurre i viaggi nella cache cluster. La cache del client è un sottoinsieme dei dati delle cache in cluster. Manterrà una copia locale con sé dei dati delle cache raggruppate. Rimane sincronizzato con la cache del cluster.

Pertanto, tutti gli aggiornamenti eseguiti sulla cache del client vengono propagati alla cache del cluster e viceversa. Quindi, rimane aggiornato con la cache in cluster e quello che fa è se la tua applicazione sta cercando di recuperare alcuni elementi dalla cache, fornisce, se ha quegli elementi presenti localmente proprio qui, condivide semplicemente quei dati o quegli elementi proprio lì e poi da una fonte locale.

Torniamo effettivamente a questo. Ok, ci sono voluti circa 45 secondi per fare questa operazione. Quindi, una volta utilizzata la cache del client, possiamo effettivamente vedere come influisce all'interno di quello scenario. Vado a fare clic su Invio. Conserveremo questo ricordo, questo numero che è di 45 secondi.

Quindi, stavamo già parlando della cache del client. Quindi, come ho detto prima, fondamentalmente ci sono due opzioni che hai. Puoi eseguire la cache del client come InProc o OutProc, è qualcosa che puoi immaginare. Nel caso di OutProc, verrà eseguito un processo separato, che rimarrà, che rimarrà sincronizzato con la cache del cluster.

Il processo OutProc è generalmente consigliato, quando si dispone di uno scenario di giardino Web in cui sono presenti più applicazioni o più istanze delle applicazioni in esecuzione sulla stessa scatola. Quindi, avrebbero una risorsa comune da gestire, ovvero la cache del client, un processo separato in esecuzione. La seconda opzione è una cache InProc ed è consigliata nel caso in cui si disponga di uno scenario di Web farm, in cui di solito si hanno una o due applicazioni in esecuzione sulla stessa casella.

Nel caso di uno, ciò che sta accadendo è che la cache del client risiede all'interno del processo delle applicazioni. Quindi, in tal caso, poiché fa parte dello stesso processo, molte delle spese generali vengono effettivamente rimosse. In questo caso l'overhead di serializzazione, l'overhead di comunicazione tra processi, tutti questi vengono effettivamente rimossi e aumentano notevolmente le prestazioni.

Nel caso di OutProc, ciò su cui stai memorizzando nella cache è che l'applicazione ottiene quei dati da una fonte locale, che è presente nella stessa casella. Quindi, un viaggio di rete è effettivamente ridotto. Quindi, questo aumenta un po' le prestazioni e possiamo effettivamente vederlo solo ora.

Quindi, in questo quello che faremo è creare una cache client, prima come OutProc e poi come InProc e vedremo come sono i numeri numerici. E nello scenario attuale, se ricordi che ci sono voluti 45 secondi con i normali getti.

Kal, ho una domanda qui e la domanda è che tutte le caratteristiche di cui stiamo parlando fanno parte dello stesso prodotto? Quindi, immagino che parlino di edizioni.

Sì, alcuni di essi sono disponibili solo nell'azienda, ma posso condividerli confronto edizioni documento che copre effettivamente ogni singolo dettaglio per tutti loro. Quindi, forse questo ti darebbe effettivamente i dettagli esatti che stai cercando.

E, coglierò questa opportunità e chiederò a tutti gli altri, ci sono domande al momento? No, non abbiamo domande, quindi continua a parlare.

Cache client out-proc

Quindi, andrò avanti e cancellerò il contenuto della cache. Hanno finito ora. Quindi, ora andrò avanti e creerò una cache client. Quindi, nel NCache manager, hai la cache del client scritta proprio qui. Basta fare clic con il pulsante destro del mouse qui e fare clic su crea nuova cache client. Quindi, qui, manterrò lo stesso nome. È impostato sulla cache del client. Mantieni tutto predefinito. Successivamente, è impostato su OutProc ora, ma lo cambieremo in InProc in seguito. Fare clic su Avanti. La dimensione impostata su un Gig. Lo terrò così. Posso effettivamente cambiarlo in quello che voglio e alcune ulteriori impostazioni avanzate che erano presenti anche quando stavamo creando una cache del cluster. Quindi, ora la cache del client è effettivamente configurata sulla mia casella personale, ovvero 102.

Un modo rapido per verificarlo sarebbe semplicemente eseguire lo strumento list caches, presente nella mia casella personale, una volta installato NCache e usando quello strumento in realtà mi fa sapere quale NCaches sono in esecuzione sulla mia casella personale a questo punto. Quindi, qui se vengo qui, eseguiamo effettivamente le cache degli elenchi. Ok, mostra le cache presenti sulla mia casella personale, ovvero 102. Penso che sul retro stia ancora cercando di abilitarlo per qualche motivo. Sì, sembra essere abilitato lì. Quindi, se vieni qui, possiamo vedere che la cache del client. Quindi, la cache del client è una cache locale proprio qui ed è in esecuzione. Quindi, a questo punto è in esecuzione sulla mia casella personale e ora possiamo effettivamente usarlo.

Quindi, prima di procedere effettivamente, quindi, cosa NCache in effetti, pubblica questi contatori che vengono persino visualizzati sullo schermo in questo momento. Quindi, possono essere visualizzati attraverso il monitor delle prestazioni di Windows. Quello che farò è aprire il monitor delle prestazioni di Windows e aprire i contatori per la cache del client che utilizzerò.

Quindi, dalla mia casella personale, cercherò un PerfMon che monitori le prestazioni proprio qui, e usando questo quello che farò è aprire il NCache categoria e cerca la mia cache specifica che era la cache del client e apri i contatori per quelli. Quindi, ora è aperto e aprirò un nuovissimo monitor delle prestazioni, per cercare la categoria di NCache. Eccolo qui e qui ho la cache del client come presente proprio qui. Farò clic su Aggiungi e farò clic su OK. Ho intenzione di cambiare la visualizzazione in visualizzazione report. Quindi, ora, questi sono i contatori. Tutto ciò che viene visualizzato è 0 in questo momento perché non viene utilizzato. È un processo separato in esecuzione perché lo abbiamo impostato su OutProc.

Vediamo come appaiono i numeri ora, dalla mia casella personale. Eseguirò l'applicazione, stesso codice, non sto apportando alcun tipo di modifica al codice. Le funzionalità della cache del client non comportano alcuna modifica del codice, come accennato in precedenza, devi solo abilitarlo o disabilitarlo, a seconda di quale sia il tuo preferito, e quindi verrebbe raccolto automaticamente. Quindi, se faccio clic sul pulsante di avvio, sullo stesso codice, sullo stesso tutto, anche sullo stesso test, inizierà ad aggiungere quegli elementi dopo aver fatto clic su "Invio". Ok, quindi, dopo aver fatto clic su Invio, ha iniziato ad aggiungere questi elementi. Se torni al NCache manager, vediamo che sulla cache cluster vengono aggiunti gli elementi. Se apri il NCache monitor, questo è questo, sì, questo, vediamo che c'è anche un po' di attività in corso qui, ed è quello che stavo spiegando inizialmente. Quando hai configurato la cache del client, utilizza e quando aggiungi elementi alla cache, anche la cache del client riceve una copia e anche la cache in cluster ne ottiene una copia.

Questo caso d'uso è generalmente consigliato quando hai, ad esempio, un rapporto tra letture e scritture dall'80% al 20% o anche un rapporto tra letture e scritture dal 70% al 30%. Questo è generalmente consigliato in scenari in cui hai molte letture, forse alcuni dati di riferimento da dati statici che hai all'interno del tuo ambiente ed è lì che vedresti grandi miglioramenti delle prestazioni quando hai una cache client abilitata.

Quindi, tieni presente che il primo test con solo l'API get eseguito in un ciclo, abbiamo ottenuto 45 secondi in cui è stato in grado di recuperare quegli elementi dalla cache. Ma ora usando questa cache del client, troverebbe tutti quei dati all'interno di un'origine locale, in un processo separato che è in esecuzione sulla stessa scatola e vedremo come funziona per noi. Quindi, se scorriamo verso il basso qui, possiamo vedere che questo è il conteggio della cache del client. Questo conteggio deve salire a 5,000 perché è un'unica fonte. Quindi, tutti i 5,000 elementi saranno presenti qui nel cluster e verranno distribuiti tra tutti i nodi del server. Quindi, stiamo solo aspettando che questi elementi salgano a 5,000 e quindi eseguiremo la seconda parte del test che è dove recupera questi elementi dalla cache del cluster.

Quindi, un'altra cosa da notare sarebbe che una volta recuperati gli elementi dalla cache, le chiamate non andrebbero alla cache in cluster, sarebbero tutte intercettate dalla cache del client che è attualmente localmente ed è quello che mostrerò tu da questi contatori, proprio qui. Quindi, questi contatori mostrano i contatori della cache del client, ma se arrivi a questo, questi mostrano i contatori lato server per la cache in cluster. Facciamo clic su Invio qui e inizierà a recuperare questi elementi dalla cache. Quindi, ancora una volta, solo per mostrarti che nessuna carta viene spostata qui. Quindi, non c'è nessuna chiamata in arrivo qui. Se apri questo, possiamo vedere che questa attività sta andando avanti qui. Ci sono alcuni recuperi in corso. Quindi, la cache del client è ampiamente utilizzata in questo momento e questo è il punto centrale di avere una cache del client in scenari in cui hai più letture che scritture. Quindi, dopo alcuni secondi, dovremmo vedere i risultati qui di quanto tempo ci è voluto per mostrarti 5,000 elementi di dimensioni 100 KB dallo scenario della cache del client. Quindi, qui puoi vedere che da 45 secondi è sceso a 33 secondi con il caso in cui hai una cache del client OutProc abilitata nel tuo ambiente.

Quindi, puoi vedere che è un grande miglioramento. Sono più di 10 secondi che puoi vedere e in termini di applicazioni è un grande momento. Quindi, ci ha mostrato un grande miglioramento in questo caso.

Cache client in corso

Quindi, andrò avanti e creerò una cache client In-Proc ora e utilizzando quella cache client InProc, vedremo come si comporta per noi rispetto a questi 45 secondi per il test effettivo, 33 secondi per il test OutProc della cache del client. Quindi, prima di tutto andrò avanti e rimuoverò questa cache. Ora è stato rimosso. Creerò una nuova cache. Di nuovo, digiterò semplicemente InProc accanto ad esso e farò clic su Avanti e manterrò il livello di isolamento su InProc, manterrò tutto predefinito e farò clic su Fine. Quindi, ora questo è stato creato sulla mia casella personale e farò lo stesso identico test. In realtà, cancelliamo prima i dati nella cache.

Quindi, ora stessi test, stessi argomenti e l'ho appena iniziato. Quindi, ora eseguirà di nuovo lo stesso identico test. 5000 elementi nella cache di dimensioni 100 KB e quindi recupererà quegli elementi utilizzando la cache del client InProc del client. Il concetto rimane lo stesso. Una volta che la tua applicazione ha aggiunto elementi alla cache, la aggiungeresti anche alla cache del client che è presente nello stesso processo, perché ora la stiamo eseguendo come In Proc. Quindi, aggiunge anche quegli elementi alla cache del client e li aggiunge anche alla cache in cluster. Quindi, una volta che lo è, farò clic su Invio ora. Quindi, una volta recuperati quegli elementi, troverà tutti quegli elementi all'interno del locale, all'interno dello stesso processo.

Quindi, ora senza alcun sovraccarico coinvolto come comunicazione e serializzazione tra processi, deserializzazione, tutto ciò viene ora completamente rimosso. Otterrebbe i dati proprio lì e poi da un'origine locale e vedremmo quanto la cache del client stia effettivamente funzionando con una modalità InProc per questo scenario specifico. Quindi, sto solo aspettando che gli elementi vengano aggiunti. Se torniamo qui, dovremmo vedere alcuni contatori che salgono e scendono. Possiamo sicuramente vederlo.

Quindi, nel frattempo, ragazzi, se avete domande, fatemelo sapere. Sam sta tenendo d'occhio la scheda del dock delle domande. Mi informerà se ci sono domande.

Quindi, la prossima cosa che ho menzionato in precedenza nell'elenco saranno le operazioni in blocco. Quindi, testeremo solo con uno solo, ovvero utilizzando l'API di massa. Ma ci sono diversi concetti di cose diverse che funzionano allo stesso modo delle operazioni di massa e in questa presentazione tratteremo tutti questi in teoria. Vediamo effettivamente quanti elementi vengono aggiunti. Quindi, sono già stati aggiunti circa più di 3000 articoli. Quindi, stiamo solo aspettando che raggiunga il marcatore 5000 completo e dopo vedremo come funziona. Ok, bloccato con il primo. Quindi, sto solo aspettando che le operazioni vengano eseguite nella parte posteriore. Nel frattempo, sto solo parlando della prima cosa qui nel caso delle operazioni di massa.

Quindi, il concetto centrale dell'operazione in blocco è solo quello di limitare la quantità effettiva di chiamate che entrano nella cache del cluster. Quindi, invece di eseguire tutte queste cose all'interno di un ciclo, come abbiamo già fatto, possiamo effettivamente eseguire le stesse chiamate come parte di un'unica operazione. Pertanto, è possibile eseguire una singola operazione inviata alla cache in cluster e quindi più operazioni. Quindi, se condividi in caso di bulk devi conoscere le chiavi. Quindi, ad esempio, hai appena fornito le chiavi e gli oggetti effettivi che desideri aggiungere, solo una singola chiamata e l'utilizzo che tutti quegli elementi verranno effettivamente aggiunti nella cache raggruppata sul retro.

Quindi, penso che dovrebbero essere fatti, sì, sono quasi finiti ora. Se torniamo qui, quindi, tutti questi elementi vengono ora aggiunti. Farò clic su Invio e possiamo vedere che tutti quegli elementi sono stati recuperati. È molto sorprendente da vedere perché molte spese generali sono state ora rimosse. Quindi, è stato estremamente veloce. Quindi, nel caso ripetiamo quello che abbiamo fatto con il test iniziale, con il test di base ci sono voluti 45 secondi, con la cache del client OutProc ci sono voluti circa 33 secondi. Ma, nel caso della cache del client InProc, tutto questo tempo è sceso a 0.1 secondi in questo caso.

Quindi, questo è quanto di miglioramento puoi vedere con una cache del client InProc se il tuo caso d'uso viene mappato su quello che abbiamo in corso proprio qui. Quindi, questo è un grande miglioramento che puoi vedere se hai più letture e più scritture in corso.

Quindi, farò solo clic su Invio. Quindi, si avvicina. Ho intenzione di rimuovere questa cache del client qui e anche in realtà ho ripulito. Ok, quindi, torniamo alla presentazione. Quindi, qui, quindi, stavamo parlando di operazioni di massa.

Ottieni in blocco (basato su chiave)

Quindi, nel caso di operazioni in blocco, la prima è che una volta aggiunti, se hai molti elementi che vuoi aggiungere o anche recuperare dalla cache, devi solo fornirgli l'elenco di conseguenza e utilizzando una sola chiamata puoi eseguire tutte quelle operazioni sulla cache. Quindi, in genere, se hai un oggetto di dimensioni maggiori, ti consigliamo di suddividerlo in più oggetti e quindi di utilizzare le funzionalità che NCache fornisce per raggrupparli effettivamente o addirittura ottenerli o aggiungerli nella cache. Pertanto, l'API di massa può essere utilizzata in questi scenari. Il secondo è, ad esempio, se non si conoscono le chiavi di questi elementi, poiché la massa era un'operazione basata su chiavi, quindi è necessario sapere che tutte le chiavi.

Query di ricerca SQL/LINQ

Nelle query di ricerca di tipo SQL o LINQ, in pratica se non conosci le chiavi, puoi effettivamente cercare in base a determinati criteri. Ad esempio, se hai prodotti aggiunti nella cache, puoi effettivamente recuperare più prodotti dalla cache in base a determinati criteri. Quindi, diciamo, eseguo una query con il nome 'SELEZIONA prodotto DOVE prodotto.prezzo > 10 E prodotto.prezzo < 100'. Quindi, tutti i prodotti che soddisfano effettivamente quei criteri specifici e sono presenti nella cache mi verrebbero effettivamente restituiti. Quindi, in questo caso non ho specificato alcuna chiave, ho solo specificato con i criteri e mi sono state restituite.

Gruppi e sottogruppi

Il prossimo è se puoi creare raccolte logiche all'interno della cache. Li tratterò entrambi insieme, come gruppi, sottogruppi e quindi anche tag. Quindi, puoi farlo. Quindi, ad esempio, se hai clienti e i loro ordini inseriti nella cache, puoi effettivamente raggruppare tutti gli ordini insieme. Poiché ci sono elementi separati nella cache, puoi effettivamente conservare anche le raccolte, ma ti consigliamo di scomporle, perché di solito una volta ottenuto un elemento dalla cache non è necessario l'oggetto completo, è necessario un certo valore contro di esso. Quindi, se lo scomponi in più oggetti, puoi usarlo in un modo più efficiente. Quindi, utilizzando queste funzionalità di raccolta logica, puoi sostanzialmente raggruppare elementi all'interno della cache. Quindi, tutti gli ordini di un determinato cliente possono essere raggruppati e utilizzando una sola chiamata. Diciamo che nei gruppi puoi fare un get by group o nel caso di tag get by tag, basta solo fornire l'ID cliente e tutti questi elementi associati presenti all'interno della cache ti verrebbero effettivamente restituiti. Anche in questo caso, in questo caso non è necessario conoscere le chiavi, devi solo conoscere il determinato valore di stringa che è un gruppo o un tag e in base a quello ti è stato restituito e quindi supporta anche le query parallele.

Operazioni in blocco - Demo

Quindi, passiamo all'esempio di operazioni di massa effettive. Quindi, se torni a questo test, proprio qui. Questo è il test di massa, cioè il test 2 e lo eseguiremo effettivamente. In realtà iniziamo prima e poi possiamo entrare nei dettagli su cosa sta facendo. Quindi, l'ho appena cambiato per testare 2 ora e l'ho avviato. Quindi, ciò che sta facendo questo test è in pratica aggiungere 10,000 elementi di dimensioni 10 KB nella cache in questo momento. In primo luogo, sta facendo solo un inserimento di base per aggiungere questi elementi alla cache e quindi sta recuperando tutti questi elementi e sta effettivamente registrando il tempo per le aggiunte e anche la parte di recupero.

Console.WriteLine("TEST 2\n");
Console.WriteLine("Press anything to add " + objectsCountBulk + " items (10kb Object)");
Console.ReadKey();
Console.WriteLine("Adding items now");
datetime1 = DateTime.Now;
for (int i = 0; i < objectsCountBulk; i++)
{
    cache.Insert(key + i, obj2);
}
datetime2 = DateTime.Now;
Console.WriteLine(objectsCountBulk + " items added. Time to add " + objectsCountBulk + " items in a loop: " + (datetime2 - datetime1).TotalSeconds);
Console.WriteLine("\nPress any key to retrieve them.");
Console.ReadKey();

Quindi, una volta fatto, otteniamo una linea di base del tempo impiegato per aggiungere 10,000 elementi di dimensioni 10 KB nella cache, quindi avvia le operazioni di massa. In quelle operazioni in blocco aggiunge tutti quei 10,000 elementi nella cache con la stessa chiamata e recupera di nuovo con una sola chiamata, con l'elenco delle chiavi e l'elenco degli oggetti predefiniti.

Ok, faccio clic su invio. Inizierà ad aggiungere quegli elementi nella cache. Se torniamo al NCache manager, vediamo che c'è un po' di attività in corso qui. Questi elementi vengono ora aggiunti a entrambi i server attualmente presenti.

Anche se guardi il cluster di monitor possiamo vedere un client connesso qui, un client connesso lì e poi vediamo che c'è un po' di attività in corso in questi grafici. Quindi, usando questo puoi effettivamente avere una buona idea di cosa sta succedendo all'interno della cache, cosa viene utilizzato, cosa non viene utilizzato a questo punto e quanto viene utilizzato. Ha quasi finito tutti i 10,000 articoli, penso che ora siano stati aggiunti. Sì, lo sono e premerò Invio per recuperare questi 10,000 elementi. Quindi, prima di tutto, ci sono voluti circa 37 secondi per aggiungere questi elementi alla cache. Ora, quello che sta facendo è leggere quei 10,000 elementi dalla cache. Quindi, se vedi, qui possiamo vedere che ci sono alcuni recuperi al secondo in corso su entrambi questi nodi del server. Quindi, gli articoli sono attualmente in fase di recupero. Quindi, ora sta recuperando in un ciclo in questo momento. Tieni presente che una volta completato, inizierà il test di massa. Quindi, sulla base di quel test di massa, confronteremo questi due numeri e vedremo come influiscono effettivamente. Quindi, qui ci sono voluti circa 30 secondi per recuperare questi 10,000 elementi e con l'API di massa ha effettivamente finito con le aggiunte e dovrebbe presto essere fatto anche con la parte di recupero, penso, oh sì, è necessario premere INVIO. Ok, in realtà aspettiamo che sia completato e poi posso davvero mostrarti come appaiono tutte queste cose. Quindi, ora è completo. Quindi, solo per eseguire questo test, ha aggiunto 10,000 elementi di dimensioni 10 KB nella cache utilizzando un ciclo e ha impiegato circa 37 secondi. Per recuperare quei 10,000 elementi ci sono voluti circa 30 secondi, sempre in un ciclo. Con il test di massa, ha aggiunto quei 10,000 elementi alla cache e ci sono voluti circa 5 secondi.

Quindi, questo è un grande divario tra 37 secondi e 5 secondi e per recuperare quegli elementi nella cache, ci sono voluti circa, diciamo, 6 secondi. Quindi, di nuovo una grande differenza tra 6 secondi e 30 secondi. Quindi, questo è quanto di miglioramento le operazioni di massa possono effettivamente offrire a te e alla tua applicazione e utilizzando questo non è necessario eseguire la stessa chiamata ancora e ancora. Non è necessario accedere alla cache in cluster ogni volta. Fondamentalmente puoi creare una raccolta di tutte quelle operazioni che devi eseguire, usando l'API di massa puoi semplicemente aggiungerle alla cache.

Compressione - Demo

Quindi, ora il nostro test di massa è effettivamente terminato. Quindi, torna alla presentazione. Quindi, il prossimo è il test di compressione. Ancora una volta, come accennato in precedenza, generalmente consigliamo di scomporre l'oggetto in dimensioni più piccole, ma se non hai questa opzione disponibile, ciò che puoi fare è effettivamente comprimere, puoi effettivamente impostare una certa soglia. Qualsiasi oggetto maggiore di quello non verrebbe compresso a una dimensione inferiore. In questo momento abilitiamo la compressione nel nostro ambiente. Quindi, prima di tutto, andiamo avanti e svuota la cache. E 'fatto. La compressione è qualcosa che può essere fatto al volo. Quindi, non è necessario arrestare la cache. Quindi, se faccio clic con il pulsante sinistro del mouse sul nome della cache, si apriranno tutte queste diverse configurazioni. Se vado qui e apro le opzioni qui e quello che devo fare è semplicemente fare clic su questa compressione abilita. Lo imposterò su 50 KB. Quindi, tutto ciò che è maggiore di 50 KB verrà compresso. Fare clic con il pulsante destro del mouse sul nome della cache e fare clic su applica configurazioni. Tutte queste configurazioni verranno ora applicate al cluster. Quindi, qualsiasi oggetto più grande di quello sarebbe effettivamente compresso.

Quindi, eseguirò lo stesso test che abbiamo fatto inizialmente ed era il test 1. Cambialo di nuovo nel test 1, lo salverò e premerò su Run (start). Aspettiamo che inizi e poi fornirò alcuni dettagli in più su come la compressione aiuta effettivamente in diversi scenari. Quindi, il modo in cui funziona la compressione è che una volta che il client invia questi elementi alla cache, li invia come compressi. Quindi, il modo in cui la compressione aiuta è che, una volta che l'elemento viaggia sulla rete, è di dimensioni inferiori e una volta che si trova nella cache cluster, occupa anche meno posizione.

Kal, volevo solo ricordarti che abbiamo 10 minuti prima che la sessione finisca, quindi cerca di andare di conseguenza. Giusto, va bene grazie. Qualche domanda a questo punto? No, sembra che stiano tutti bene. In realtà, abbiamo due conferme, finora tutto bene, quindi stiamo bene. Va bene, perfetto. Grazie.

Ok, quindi, stavo parlando di compressione come aiuta. Quindi, nel caso in cui ci siano due cose, l'intero viaggio in rete di un oggetto di dimensioni inferiori sarà ovviamente più veloce di quello di dimensioni maggiori e una volta che l'oggetto è stato posizionato nella cache, fai clic su Invio in modo che inizi a recuperare questi elementi . Quindi, una volta posizionato all'interno della cache, in realtà è anche più piccolo. Quindi, sta consumando meno spazio. Anche il tempo necessario per elaborare questo articolo è ridotto. Quindi, ecco come la compressione aiuta nel tuo scenario. C'è un sovraccarico coinvolto sul lato client durante l'aggiunta. Ma l'intero miglioramento netto che noteremo in questo momento è in realtà maggiore di quello. Quindi, tutto il tempo necessario per, sai, tutte le operazioni sono state trovate su questi oggetti sarà in realtà molto più veloce. Quindi, il test 1 eseguito con la compressione ha richiesto circa 26 secondi.

Se ricordi inizialmente, nel nostro primo test senza nulla, senza funzionalità speciali coinvolte solo l'API di base, ci sono voluti 45 secondi, credo. Quindi, c'è una grande differenza tra 45 secondi e 26 secondi. Quindi, ecco quanto la compressione aiuta effettivamente e se queste operazioni vengono ulteriormente ridimensionate, in questo caso ci sarebbe una differenza ancora maggiore. Quindi, questo aiuta molto in questo caso.

Operazioni asincrone - Demo

Quindi, passiamo effettivamente allo scenario successivo che abbiamo, ovvero gli aggiornamenti asincroni. Gli aggiornamenti asincroni sono fondamentalmente la tua applicazione non aspetta. È possibile impostare un'attività separata per essa e quell'attività eseguirà tali operazioni. È possibile impostare le richiamate solo per ottenere le informazioni se l'elemento è stato aggiunto o non è stato aggiunto per qualsiasi scenario. In realtà puoi anche configurarlo. Ora andrò rapidamente al campione e penso che sia il test numero 3, ma posso confermarlo rapidamente. Ok, questo è il test numero 3 per gli aggiornamenti asincroni. Iniziamo effettivamente e poi possiamo esaminare i dettagli del codice. Non appena potrò ricontrollare, aprirò il file di codice e ti mostrerò effettivamente cosa sta succedendo nel test numero 3 che è per gli aggiornamenti asincroni. Iniziato ora. Quindi, negli aggiornamenti asincroni, questo è il test numero 3, quello che sta succedendo è che inizialmente aggiunge un elemento nella cache usando solo la chiamata di inserimento di base e quindi una volta che ha finito di aggiungere quegli elementi, sostanzialmente li rimuove di nuovo in una parte di un ciclo continuo. Quindi, ogni chiave viene rimossa in una singola iterazione.

...
else if (args[1].Equals("test3"))//ASYNC API TEST
{
    Console.WriteLine("TEST 3\n");
    Console.WriteLine("Press anything to add " + objectsCount + " items normally (100kb Object)");
    Console.ReadKey();
    Console.WriteLine("Adding items now");

    try
    {
        cache = NCache.InitializeCache(args[0]);
        datetime1 = DateTime.Now;
        for (int i = 0; i < objectsCount; i++)
        {
            cache.Insert(key + i, obj1);
            //cache.InsertAsync(key + i, obj1, OnItemAdded, "", "");
        }
...

Vado a fare clic su Invio. Aggiunge 5,000 elementi nella cache di dimensioni 100 KB e lo sta facendo normalmente. Normalmente qui intendo solo un semplice inserto e quindi rimuove quegli elementi con di nuovo in una parte del ciclo. Quindi, usando questo vedremo quanto tempo ci vuole per questa parte e poi useremo le chiamate asincrone per aggiunte, inserti asincroni e quindi per rimuoverli. Mentre aggiunge questi elementi, facciamo un salto indietro e vediamo come appaiono. Quindi, in questo caso, sta solo eseguendo una rimozione di base, per rimuovere questi elementi. Nella parte di test asincrona, ciò che sta facendo è eseguire la chiamata asincrona di inserimento. Quindi, il client non aspetta, passa semplicemente l'operazione in coda. La coda non significa che sarà un processo lento, il client non lo aspetta ed è fatto come un bel processo in background, ma è abbastanza veloce. Perché molte operazioni all'interno della cache vengono effettivamente eseguite in modo asincrono.

...
datetime2 = DateTime.Now;
Console.WriteLine("Time to remove " + objectsCount + " objects normally: " + (datetime2 - datetime1).TotalSeconds);
Console.WriteLine("\nAdding items using Async API now");
datetime1 = DateTime.Now;

for (int i = 0; i < objectsCount; i++)
{
    //cache.Insert(key + i, obj1);
    cache.InsertAsync(key + i, obj1, OnItemAdded, "","");
}
datetime2 = DateTime.Now;
Console.WriteLine("Time to add " + objectsCount + " objects with Async API: " + (datetime2 - datetime1).TotalSeconds);
Console.WriteLine("\nRemoving " + objectsCount + " items with Async API now");
...

Lasciate che vi faccia un esempio. Quindi, ad esempio, se si parla di replica, se ricordi nel processo di creazione della cache lo impostiamo come asincrono. Quindi, usandolo fondamentalmente molti di loro vengono eseguiti come processo in background. Sono molto affidabili. È solo che la tua applicazione, il processo principale, l'attività principale non ne sono interessati. Quindi, ha aggiunto quegli elementi nella cache, ci sono voluti circa 49 secondi per aggiungere quegli elementi nella cache. Ora, in realtà sta rimuovendo quei 5,000 elementi. Ora, una volta fatto, vedremo come prendono le chiamate asincrone. Quindi, deve spostare 5,000 elementi. Ci sono voluti circa 25 secondi per rimuovere quegli elementi e ora sta aggiungendo elementi con la chiamata asincrona e vedremo quanta differenza otteniamo tra 49 secondi e il numero che otterremo ora in termini di quando ' riaggiungendo elementi alla cache. Eccolo. Quindi, da 49 secondi è stato ridotto a 28 secondi nella parte delle aggiunte e nel caso di rimozione di quegli elementi è sceso da 25 secondi a 1.6 secondi. Quindi, ecco quanta performance possiamo effettivamente vedere una volta coinvolto. Quindi, puoi vedere che c'è una grande differenza. Sono circa 25 secondi di differenza tra la rimozione di elementi da una chiamata di rimozione di base e quindi da una chiamata di rimozione asincrona. Quindi, è qualcosa che puoi aspettarti da questo tipo di funzionalità offerte da NCache.

Doppia scheda di rete - Demo

Torniamo effettivamente alla presentazione. Abbiamo coperto l'asincrono e il prossimo è la serializzazione compatta. Quindi, ancora una volta, solo questo è coperto in quegli scenari in cui non hai il lusso di eseguire un aggiornamento all'interno del codice e usando questo puoi effettivamente contrassegnare tutte quelle classi come serializzabili. Kal con quel commento, ci restano circa 3 minuti, quindi... Giusto, giusto. Lo coprirò velocemente. Quindi, le ultime due cose che sono rimaste erano, quella è la serializzazione compatta e quella successiva è che abbiamo la funzione di doppia scheda di rete. Quindi, come accennato in precedenza, se vedi che la tua risorsa di rete viene esaurita, per impostazione predefinita sia il tipo di comunicazione, la comunicazione da server a server che la comunicazione da client a server, entrambi si verificherebbero sulla stessa scheda di interfaccia di rete. Ma se vedi che le tue risorse di rete sono esaurite, quello che puoi fare è separare il tipo di comunicazione tra client e server e quindi tra server e server. È un compito molto semplice all'interno del NCache gestore. Se vieni qui, per selezionarlo, fai clic con il pulsante destro del mouse qui e fai clic su seleziona NIC.

Dopo aver selezionato NIC, puoi effettivamente specificare quale comunicazione vuoi che avvenga su questo determinato IP. Dal momento che ne ho solo uno, ho queste opzioni disponibili. Se ho più IP, posso effettivamente selezionarlo lì e poi. Quindi, farò solo clic su Annulla.

Non abbiamo avuto la possibilità di fare la demo di serializzazione compatta a causa della mancanza di tempo, ma posso effettivamente condividere questo esempio con voi ragazzi e potete testarlo e vedere come funziona per voi. Sam da te. Perfetto. Bene, grazie mille per il tuo tempo Kal.

Ci sono domande prima di concludere la sessione di oggi? Darò solo un minuto per vedere se ci sono domande. Ok, quindi, c'è una domanda.

Puoi per favore condividere il link dove condividerai questa presentazione? Quindi, Kal, immagino che sarebbe disponibile sul nostro sito web, giusto?

Sì, sarà disponibile e ho la loro email annotata laggiù. Quindi, quello che posso fare è inviare loro un'e-mail, non appena viene caricata. Ok. In realtà, abbiamo un'altra domanda.

Possiamo programmare una presentazione, ok, quindi possiamo programmare una demo per il nostro team?

Si assolutamente. Puoi sicuramente programmare una demo. Puoi contattare il nostro team di supporto support@alachisoft.com o il nostro team di vendita sales@alachisoft.com e facci sapere quali sono le tue preferenze di orario e saremo più che felici di programmare una sessione personalizzata per te.

Ok, Kal, quindi vado avanti e concludo. Non credo che abbiamo altre domande. Grazie a tutti per esservi uniti e per aver partecipato alla sessione di oggi, lo apprezziamo. Come ho detto, se hai domande, contatta il nostro team di supporto o per domande relative alle vendite contatta il nostro team di vendita. Saremo qui per aiutarti. Sentiti libero di chiamarci. Potete contattarci direttamente anche telefonicamente. È sul nostro sito web. Alla prossima volta, grazie mille e buona serata, ciao.

Cosa fare dopo?

• NCache Dettagli
• Scaricare NCache
• Richiedi una Demo LIVE personalizzata