Messaggistica .NET Pub/Sub scalabile tramite NCache
Webinar registrato
Di Ron Hussain e Edward Bator
In questo webinar imparerai come utilizzare la potente messaggistica Pub/Sub per applicazioni .NET ad alto traffico e superare i colli di bottiglia delle prestazioni. NCache è una cache distribuita scalabile per .NET che fornisce un ricco set di funzionalità di messaggistica Pub/Sub.
Uno dei nostri architetti di soluzioni senior ti guiderà attraverso tutte le funzionalità Pub/Sub e i loro casi d'uso e ti mostrerà come incorporarle nella tua applicazione .NET.
Questo webinar riguarda:
- Introduzione alla messaggistica Pub/Sub in generale
- Comprensione NCache Funzionalità Pub/Sub
- Configurazione di Pub/Sub in NCache
- Utilizzo pratico di Pub/Sub nelle app .NET
- Demo di messaggistica Pub/Sub tramite NCache
- NCache elevata disponibilità e scalabilità per Pub/Sub
L'argomento di oggi riguarderà la messaggistica all'interno delle applicazioni .NET e lo useremo NCache come prodotto di esempio. L'obiettivo principale sarà Messaggistica Pub/Sub. Il modello di abbonato editore. Perché è importante? Dove lo usi esattamente e perché NCache si adatta meglio rispetto ad altre opzioni che vedi per il tuo .NET e .NET core applicazioni? Quindi, abbiamo molto da coprire. Cominciamo rapidamente con questo e ragazzi, se ci sono domande, come ha suggerito Eddie, usa la scheda risposta alle domande e poni tutte le domande di cui hai bisogno. Quindi, iniziamo rapidamente.
Che cos'è Pub/Sub?
Le prime diapositive sono incentrate sulla parte introduttiva. Che cos'è Pub/Sub? Sono abbastanza sicuro che tutti lo sappiano, ma solo per completezza, esaminerò il paradigma della messaggistica Pub/Sub.
Quindi, è un modello di abbonato editore. Ha principalmente tre componenti. Abbiamo editore, che invia messaggi, trasmette quei messaggi al canale di comunicazione. Poi abbiamo gli abbonati, che potrebbe essere un'altra applicazione, che sta ricevendo quei messaggi e quindi abbiamo una comunicazione, un bus, un broker, un servizio, un processo all'interno di un editore e un componente intermedio dell'abbonato che aiuta a inoltrare quei messaggi dagli editori agli abbonati. In alcuni casi, puoi archiviare messaggi, puoi elaborare messaggi. Questa potrebbe essere una base temporale, potrebbe essere basata sui tuoi destinatari.
Come funziona Pub/Sub?
Quindi, ci sono diverse opzioni che puoi regolare quando prevedi di usarlo. Ma, in generale, ci sono alcune linee guida, alcune regole che sono comuni alla tipica piattaforma di messaggistica Pub/Sub. È accoppiato liberamente. Editore e abbonati, possono lavorare in modo indipendente senza avere alcuna dipendenza l'uno dall'altro. Possono anche essere completamente inconsapevoli l'uno dell'altro e il sistema dovrebbe funzionare senza problemi. L'idea è che l'editore invia semplicemente messaggi al canale di comunicazione e quindi il canale di comunicazione trasmette quei messaggi e gli abbonati ricevono quei messaggi. L'editore non ha bisogno di conoscere l'identità o le informazioni sulle applicazioni degli abbonati e allo stesso modo gli abbonati non devono sapere quali sono le informazioni dell'editore. Possono solo gestire i messaggi, questo è il principale punto di interesse e l'idea è che ogni componente funzioni in modo indipendente. Gli editori non hanno alcuna dipendenza dal canale di comunicazione o dagli abbonati e viceversa.
La maggior parte dei modelli di abbonati editore, i modelli Pub/Sub ti consentono di avere una separazione delle preoccupazioni, in cui puoi avere argomenti, canali o stream. Questi sono usati per separare i messaggi. Quindi, messaggi di natura simile che servono a un unico scopo semplice, possono essere inseriti in un argomento specifico e puoi avere più argomenti, più flussi, più canali, all'interno di un paradigma di messaggistica Pub/Sub e puoi ricevere quei messaggi. Gli editori si connettono agli argomenti e quindi questo trasmette quei messaggi a un determinato argomento e quindi gli abbonati possono anche connettersi a un argomento all'interno del canale di comunicazione e quindi ricevere quei messaggi e funziona perfettamente, utilizzando questo approccio basato sull'argomento.
Ecco uno schema, che mette in evidenza i dettagli architettonici.
Abbiamo un argomento, questo è il canale di comunicazione, questa è l'applicazione dell'editore che abbiamo applicazioni per gli abbonati. Potrebbero esserci più editori. Allo stesso modo, potrebbero esserci più abbonati e quindi all'interno del canale di comunicazione puoi anche avere più argomenti. Ad esempio, puoi avere un argomento che riguarda le informazioni sull'elaborazione degli ordini. Potrebbe esserci un altro argomento che riguarda le informazioni sui clienti e così via. Quindi, in base allo scopo del messaggio, in base al tipo del messaggio, questi sono i requisiti di caricamento, puoi distribuire i messaggi in argomenti e quindi questo abbonato è collegato all'argomento A, dove come abbonato 2 è collegato all'argomento A come così come a B e quindi l'abbonato 3 è collegato solo all'argomento B. Quindi, l'editore invia questi messaggi e quegli abbonati che sono collegati ai rispettivi argomenti, ricevono quei messaggi senza problemi.
Casi d'uso comuni di Pub/Sub
Va bene, quindi, vai avanti. Quali sono i casi d'uso comuni di Pub/Sub? È sul mercato da un po' di tempo, questo intero paradigma di messaggistica Pub/Sub ed è stato utilizzato anche in molte applicazioni ad alto traffico. Ha molta trazione.
Quindi, abbiamo principalmente sistemi di back-end che possono trarre vantaggio dalla messaggistica Pub/Sub che si occupa dell'elaborazione dei dati asincrona. Potrebbero essere alcuni flussi di lavoro, alcune attività in background, alcune procedure di cui hai bisogno, alcuni calcoli che stai facendo. Quindi, i sistemi back-end utilizzano principalmente questa piattaforma di messaggistica.
Applicazioni di chat, questo potrebbe essere l'industria dei giochi, che potrebbe avere a che fare con milioni di utenti, milioni di messaggi trasmessi per gli utenti. Ad esempio, uno dei nostri clienti utilizzava Pub/Sub per la condivisione di informazioni quando c'erano diversi tornei nel loro sito di gioco. Quindi, condividevano molte informazioni relative ai tornei tra gli utenti.
Settore finanziario, e-commerce, prenotazioni qualsiasi, qualsiasi cosa che sia di fronte al pubblico e che devono eseguire alcune elaborazioni di ordini back-end, alcune elaborazioni di prenotazioni o in generale fornire qualche interazione tra i diversi componenti dell'applicazione.
Automazione e impianti di produzione. Ma, in genere, potrebbe essere il caso d'uso più importante, sarebbe un caso d'uso tecnico, sarebbe il microservices caso d'uso. Dove abbiamo diversi microservizi, che rappresentano una grande applicazione ma questi componenti hanno un unico scopo indipendente. È molto difficile implementare il livello di comunicazione per questi microservizi. Dovresti avere un canale di comunicazione separato che agisca di nuovo come un microservizio, che non ha capacità anche per altri microservizi e questa è l'idea in cui vorresti avere un livello di microservizi che sia indipendente, le istanze del microservizio sono indipendenti l'una dall'altra. Un'istanza sta facendo un unico scopo e non dipende da un altro e viceversa. Pertanto, per quelle applicazioni di microservizi, in cui sono presenti microservizi all'interno dell'applicazione, l'implementazione del canale di comunicazione è molto difficile e complica e ha molta dipendenza, oltre a rallentare le cose. Quindi, ha molto senso utilizzare una piattaforma di messaggistica Pub/Sub, in cui il canale di comunicazione è gestito dalla piattaforma stessa e quindi i microservizi agiscono come editori e abbonati e quindi condividono le informazioni tra loro. Quindi, ciò dovrebbe aiutare ad alleviare il carico e i problemi di architettura che in genere si verificano con Pub/Sub, le applicazioni delle piattaforme di microservizi che utilizzano il proprio canale di comunicazione. Dovrebbero usare Pub/Sub per alleviarlo.
Il problema: problemi di scalabilità con piattaforme Pub/Sub
Ci sono molte piattaforme Pub/Sub, ma in genere ci sono colli di bottiglia ed è quello che tratteremo in seguito. Abbiamo tipiche piattaforme di messaggistica tradizionali. Sono molto bravi in termini di lato architettonico delle cose. Invii un messaggio, quel messaggio verrà trasmesso a tutti gli abbonati, tutto funziona bene. Ma in genere, funziona molto bene a basso carico. Quando hai meno utenti, carica anche un numero inferiore di richieste o un numero inferiore di messaggi trasmessi avanti e indietro alla tua applicazione. Per quanto riguarda il carico, quando il carico dell'applicazione aumenta, ad esempio, ci sono molti utenti, molte elaborazioni in corso e poi molto carico di messaggi dagli editori agli abbonati, in genere, abbiamo visto che la nostra messaggistica tradizionale piattaforma, come database, diventano un collo di bottiglia. Ecco un diagramma che lo illustra.
Abbiamo applicazioni per editori, abbonato. Potrebbe trattarsi di un'applicazione Web, alcuni .NET o .NET Core back-end. Alcuni flussi di lavoro. Potrebbe essere qualsiasi tipo di .NET o .NET Core applicazione o anche applicazione Java, collegata a una piattaforma di massa tradizionale come database o coda di messaggistica. Prima di tutto, questi non sono veloci come in-memory store, giusto. Quindi, è qualcosa su cui devi lavorare. Ma il problema principale è che quando il tuo carico di messaggistica aumenta, quando hai molti utenti, le cose iniziano a rallentare perché il tuo carico di messaggistica può soffocare la piattaforma stessa perché è un'unica fonte. Non ha la capacità di aggiungere sempre più server per aiutare a far fronte al carico maggiore che le tue applicazioni stanno mettendo.
Quindi, questo è il problema principale e quale sarebbe l'impatto sull'utente finale? Ad esempio, un messaggio non è stato inoltrato in modo tempestivo, ha richiesto molto tempo e ciò ha contribuito alla latenza sul lato dell'applicazione. Ad esempio, l'utente finale era in attesa dell'esecuzione di un'elaborazione e tale elaborazione dipendeva da una piattaforma modello Pub/Sub e la piattaforma era lenta. Quindi, ciò a sua volta avrebbe un impatto anche sulla richiesta dell'utente finale e perderai affari se ci sono, diciamo, un fattore di millisecondo o qualche secondo di ritardo, quindi ciò può avere un impatto sull'utente finale e ciò a sua volta avrà un impatto sulla tua attività come bene ed è molto difficile da gestire, perché non c'è modo, è possibile modificare qualsiasi cosa all'interno dell'architettura dell'applicazione per risolvere il problema. C'è un problema, che è al di fuori dell'architettura dell'applicazione con il livello del database, giusto. Quindi, come affrontare quel particolare scenario?
La soluzione: cache distribuita in memoria
La soluzione è molto semplice, si utilizza una piattaforma di messaggistica Pub/Sub in memoria che è distribuita in natura, ad esempio NCache. È super veloce, questo è ciò che lo distingue dalle tradizionali piattaforme di messaggistica. Potrebbe avere meno funzioni, lo ammetto. Da, NCacheL'obiettivo principale è avere la memorizzazione nella cache degli oggetti, la memorizzazione nella cache dei dati, la memorizzazione nella cache della sessione, per l'elaborazione dei dati e l'archiviazione e il miglioramento delle prestazioni. Pub/Sub è una delle caratteristiche. Esistono prodotti come le code di messaggistica, ad esempio il servizio di messaggistica Java, la coda MSM, che sono più elaborati. Ma cosa fa NCache a parte questi prodotti è quello NCache è la memoria. Quindi, è super veloce da avviare.
Quindi, se hai, diciamo, cinque utenti e hai meno carico di messaggistica, quegli utenti vedranno un'esperienza super veloce rispetto alle tradizionali piattaforme di messaggistica. Quindi, è in memoria. Quindi, questo è un grande vantaggio e poi abbiamo più server che ospitano quella piattaforma di messaggistica. Puoi vedere un server del team unito in una capacità logica che formula la piattaforma di messing e ha un meccanismo Pub/Sub implementato su di esso, giusto. Pertanto, le applicazioni del tuo editore possono connettersi a questa cache e all'interno della cache puoi avere argomenti separati. Ti mostro come funziona, a seguire e poi gli abbonati, che tra l'altro possono essere anche editori, sono anche collegati allo stesso canale di comunicazione offerto da NCache come sotto forma di cache distribuita e quindi quel canale di comunicazione offre tutte le informazioni relative alla comunicazione a questi editori e abbonati. Questo può trasmettere messaggi e questo potrebbe avere tutti questi diversi tipi di esplorazioni, un diverso tipo di persistenza e diverse caratteristiche che evidenzierò in seguito.
La cosa bella di questa piattaforma è che puoi aggiungere tutti i server di cui hai bisogno e non devi preoccuparti che la tua piattaforma sia un collo di bottiglia della scalabilità come visto qui. Quindi, non è più un collo di bottiglia della scalabilità. Puoi aggiungere più server al volo e da due a tre server aumenti di un fattore giusto e da tre a quattro server, quasi raddoppi la capacità di quante richieste puoi gestire, quanti messaggi puoi gestire al secondo e senza compromettendo le prestazioni, ti darebbe miglioramenti lineari della scalabilità per la consegna dei tuoi messaggi e ciò aiuterebbe molto dal lato dell'applicazione. Gli utenti finali ne trarrebbero grandi vantaggi, in quanto vedrebbero tempi di risposta più rapidi, bassa latenza e throughput elevato per la tua applicazione e gli utenti.
Qualche domanda finora? Questo copre il motivo per cui dovresti considerare l'utilizzo NCache rispetto al tradizionale e quali sono i problemi con la tradizionale piattaforma di messaggistica Pub/Sub. Qualche domanda finora? Le prossime diapositive sono incentrate sui dettagli architettonici di NCache Messaggistica Pub/Sub e poi parleremo delle diverse funzionalità, che vengono offerte come parte di questo. Ciao Ron, abbiamo una domanda. Quali sono le opzioni di monitoraggio disponibili? OK, penso che sia per quanto riguarda NCache, sì, questo è un altro vantaggio che ho un segmento verso la fine allineato solo per questo. Ma penso che sarebbe molto bello se aspettassi fino a quella parte e ti dessi la demo pratica del prodotto e come parte di ciò ti mostrerò anche le capacità di monitoraggio. Quindi, rivisiterò questa domanda, una volta che sarò a quella parte. Spero che sia ok.
NCache Messaggistica Pub/Sub
Tutto apposto, NCache Messaggistica Pub/Sub. È molto simile a quello che hai visto qui. È una tradizionale piattaforma di messaggistica Pub/Sub. Ecco la ripartizione dell'architettura. Abbiamo un canale di messaggistica offerto da NCache e abbiamo un team di server proprio qui e all'interno di quel canale di messaggistica abbiamo l'argomento 1, l'argomento 2 e poi abbiamo un editore che potrebbe essere qualsiasi .NET, .NET Core applicazione e quindi abbiamo abbonati che sono di nuovo qualsiasi .NET o .NET Core, anche l'applicazione Java, ad essa collegata.
È possibile formulare una cache dedicata per questo e quindi il messaggio è qualcosa che viene inoltrato dal canale di comunicazione utilizzando il tipico meccanismo Pub/Sub, in cui un messaggio viene inviato dall'editore agli abbonati. Ecco un semplice frammento di codice.
Order payload = new Order();
payload.OrderID = 10248;
payload.OrderDate = new DateTime(2015, 07, 04);
payload.ShipName = "Vins et alcools Chevalier";
...
Cache cache = NCache.InitializeCache("PubSubCache");
ITopic orderTopic = cache.MessagingService.CreateTopic("orderTopic");
Message orderMessage = new Message(payload);
// Publish message to all registered subscribers
// Register delivery failure notification
orderTopic.Publish(orderMessage, DeliveryOption.All, true);Giusto per farti un'idea che costruisci il tuo carico utile, che è l'oggetto di interesse, inizializza la cache, il che significa che ti connetti ad esso, nominalo, puoi creare un cluster di cache con server diversi, quindi crei un argomento o ti connetti a un argomento esistente. L'argomento è un canale, un mezzo separato per messaggi simili e quindi costruisci un messaggio e poi lo pubblichi e il gioco è fatto. Ecco quanto è semplice per il caso d'uso di base.
Dal lato dell'abbonato, ancora una volta è necessario connettersi a un argomento o creare un nuovo argomento e quindi diventare un abbonato utilizzando il metodo di creazione dell'abbonamento e quindi c'è una richiamata che viene richiamata ogni volta che viene ricevuto un messaggio e questa è una chiamata asincrona -indietro.
Cache cache = NCache.InitializeCache("PubSubCache");
ITopic productTopic = cache.MessagingService.GetTopic(topicName);
ITopicSubscription prodSubscriber = prodTopic.CreateSubscription(MessageReceived);
private void MessageReceived(object sender, MessageEventArgs args)
{
// Perform operations
}Una demo pratica
Dovrei darti rapidamente la demo del prodotto e poi penso che sarebbe molto più facile da capire una volta che avremo fatto la demo. Andrei avanti e, come parte di questo, risponderei anche alle opzioni di monitoraggio. Va bene, quindi, andrei rapidamente avanti e ti mostrerei il NCache strumento di gestione, che viene installato con esso.
Crea una cache
Creerò una nuova cache.
Diciamolo, PubSubCache e alla fine aggiungerò Windows Win. Tutte le cache devono essere nominate. Puoi nominare la tua cache Pub/Sub, qualcosa che è significativo per la tua applicazione. Puoi creare una cache, NCache ti consente di creare una cache in ambiente Windows, server Windows, nonché su server Linux e abbiamo anche la versione mono di Windows, anch'essa disponibile. Quindi, con Linux devi usare .NET Core e su Windows puoi usare anche .NET .NET Core rilasci di NCache. Quindi, andrò avanti con i server Windows. Scegli la cache di replica della partizione perché voglio avere più server che contribuiscono alla capacità di gestione delle richieste.
Quindi, la replica partizionata e partizionata sono ottime opzioni. Partitioned Cache consente di partizionare i dati su più server, mentre Partitioned Replica è simile a Partitioned, ma dispone anche di backup. Quindi, dipende interamente da te. Se vuoi che i messaggi siano di natura importante, se da un server si interrompe, non vuoi perdere i messaggi che sono ancora nel canale di comunicazione, allora puoi usare Partitioned Replica altrimenti, Partitioned Cache è più eccentrico .
Ci sono altre due topologie ma quelle sono per configurazioni più piccole e la nostra NCache webinar sull'architettura copre tutti i dettagli di queste topologie in modo molto efficace. Quindi, ti consiglierei di visitarli, rivedere quel webinar se hai bisogno di saperne di più su queste topologie. Manterrò tutto semplice. Scegli Async come opzione di replica.
Cioè tra la partizione attiva e il backup su un altro server e qui specifico il team di server che ospiterà il mio cluster di cache. Posso averne due per iniziare e posso aggiungere più server in qualsiasi momento, come discusso in precedenza. A proposito, questa è una porta TCP. Ogni comunicazione tra NCache è guidato tramite TCP/IP e la dimensione è qualcosa che è la dimensione per server. Pertanto, in base al carico di messaggistica, in base al carico di dati, ti consigliamo di configurare una dimensione pertinente per le tue applicazioni. Manterrò tutto semplice. Avvia questa cache in avvio automatico, in modo che ogni volta che il server viene riavviato, la cache viene avviata automaticamente e il gioco è fatto.
È così semplice configurare questa cache e, successivamente, ti mostrerò come eseguire l'applicazione, ma avrei bisogno di un altro passaggio prima di passare a quello. Sta anche iniziando, quindi ci vuole un po', va bene, ecco qua.
Monitorare le statistiche
Quindi, c'era una domanda sulle opzioni di monitoraggio, penso che dovrei affrontarla subito. Aggiungerò la mia casella come client, da dove eseguirò l'applicazione editore e abbonato. Questi possono essere eseguiti anche da qualsiasi server, che ha accesso a questa cache. Ho aggiunto la mia casella come cliente, quindi è essenzialmente la casella del cliente. Posso aggiungere un'altra casella e da quella posso anche eseguire applicazioni. Noti che ci sono alcune opzioni della finestra statistica che sono disponibili nello strumento di gestione, ma per Pub/Sub quello che farei inizialmente, avvierei NCache monitor e poi ti mostrerei anche alcuni dei contatori che sono disponibili specificamente per Pub/Sub.
Ad esempio, questo è il mio trattino Pub/Sub. Andrò avanti e questo è NCache strumento di monitoraggio fornito con l'installazione NCache. Penso di aver bisogno, 1 per 3 va bene. Va bene, quindi, prima di tutto, se noti che abbiamo le statistiche degli argomenti. Quindi abbiamo alcuni messaggi pubblicati al secondo, diciamo, il conteggio dei messaggi e poi abbiamo i messaggi che scadono al secondo. Penso che sia una buona cosa. Puoi anche aggiungere altro a proposito. Ci sono molti qua e poi ci sono contatori PerfMon che sono anche disponibili. Permettimi di abilitare anche quelli e quindi eseguirò un'applicazione per mostrarti come funziona. Ho solo bisogno di mostrarti i contatori e anche il nostro strumento di monitoraggio utilizza i contatori PerfMon. Quindi, quello che vedi qui è disponibile anche nel monitor e viceversa. Va bene, quindi, siamo tutti a posto. Quindi, abbiamo anche alcuni contatori qui. Ad esempio, conteggio messaggi, consegna al secondo scaduto. Quindi, puoi vedere la vista numerica, la vista numerica e poi abbiamo anche la vista grafica nel monitor.
Gestisci un editore
Ora, eseguirei un'applicazione che viene installata con essa, ma l'ho modificata leggermente, in modo da poter pubblicare tutti i messaggi di cui ho bisogno. Quindi, questa è una configurazione dell'app per l'editore e quindi questa è una configurazione dell'app per il consumatore, l'abbonamento. Va bene, quindi, eseguirei questa applicazione. Prima di tutto, avvierà l'applicazione dell'editore e ti mostrerà come funziona. Fammi rivedere questo, forse non l'ho salvato. Va bene, dammi solo un minuto, ho bisogno di metterci un giro. In realtà, c'è un loop. Va bene, fammi eseguire il debug. Quindi, non ho informazioni per collegarmi a questa cache. Quindi, scopriamolo. Ho aggiunto la mia scatola quindi, per favore, abbiate pazienza. Fammi risolvere questo problema molto velocemente, ci vorranno un paio di minuti. Anche se ha aggiunto, forse c'è stato un errore di battitura. Ecco qua. Stavo specificando il nome della cache sbagliato, mia cattiva. Fammi rivedere il nome proprio qui. È pubsubcachewin.
Stavo usando il nome della cache di ieri che era una cache demo. Succede. Va bene, sono contento di essere stato in grado di risolverlo rapidamente, altrimenti sarebbe stato un disastro totale. Quindi, penso che stiamo bene. Quindi, questo avvierà il programma, che sarà publisher.exe e pubblicherà dieci messaggi. Pubblico sempre gli stessi messaggi. A questo punto l'editore è avviato, l'abbonato non è ancora avviato. Quindi, lascia che ti mostri i dettagli del monitoraggio.
Ci sono alcune richieste che stanno arrivando, ovviamente intorno a questo. Ma se noti, c'era il mio argomento, quello è il nome 10.
Gli elementi sono lì e quindi dovresti vedere quei messaggi scaduti dopo che il tempo di scadenza è scaduto e penso che sto mettendo cinque minuti di scadenza o più su quello. Ora andrei avanti e ne pubblicherei altri. Ecco qua e dovresti avere 10 articoli proprio qui, extra aggiunti. Quindi, 20 elementi in totale e puoi vedere il conteggio dei messaggi aumentare.
Quindi, questo è il grafico e puoi vedere le stesse opzioni anche nel monitoraggio delle prestazioni di Windows, dove ora abbiamo dimensioni e conteggio dei messaggi da 20 a 12. In primo luogo, perché alcuni sono scaduti. Penso di utilizzare già meno scadenza come parte di quello. Fammi vedere, penso che il conteggio dei messaggi non venga visualizzato correttamente, fammi vedere, penso che questo sia, dovrebbe essere 20 secondo il mio monitor.
Esegui abbonati
Esaminiamo questo con l'aiuto degli abbonati. Vediamo quanti messaggi riceve e, a proposito, ti mostrerò il codice una volta terminata la demo.
Quindi, dovrebbe ricevere i messaggi esistenti e penso che li abbia ricevuti tutti in modo casuale. Questa è una chiamata asincrona di messaggi. Non garantisce che i messaggi vengano consegnati in quell'ordine. Quindi, puoi ricevere il primo messaggio in una fase successiva e così via.
E se torno qui, il conteggio dei messaggi scende a zero. Penso che questo contatore, rivediamolo ancora una volta. Non sono sicuro che questo rappresenti i messaggi per un determinato argomento o i messaggi generali che vengono pubblicati. Va bene, quindi, non mostra il valore corretto mentre questo dovrebbe mostrare. Penso che quei messaggi siano stati ricevuti. Quindi, ho bisogno di chiudere l'abbonato per raggiungere questo obiettivo. Ho intenzione di eseguire un altro abbonato. Quindi, che vedi i messaggi consegnati a più uno e penso che quindi lo concluderemo e ti mostreremo l'esempio di codice per esso. Inserirò altri messaggi, continuerò a farlo e poi sul lato abbonato puoi vedere 10 messaggi ricevuti da questo e poi altri ricevuti da questo. Se sono disponibili due opzioni di consegna, puoi scegliere di trasmettere i messaggi a tutti questi abbonati oa qualsiasi altro. Giusto, quindi, in base a quello che lo riceve, anche un messaggio viene scaduto dalla cache. Quindi, quella è stata una rapida demo. Ora, ti mostrerò i dettagli su cosa è coinvolto per pubblicare un messaggio? Quali sono le caratteristiche sul lato argomento? Quali sono le funzionalità sul lato editore e quali sono le funzionalità sul lato abbonato? Se ci sono domande a questo punto, per favore fatemelo sapere. Sarei felice di rispondere a queste domande per te in questo momento, altrimenti andrò avanti e ti mostrerò il lato architettonico dettagliato delle cose.
Principali interfacce Pub/Sub in NCache
Queste sono le principali interfacce all'interno NCache.
Argomento
Abbiamo argomento. Ancora una volta, è un canale di comunicazione. Contiene l'elenco degli abbonati e inoltra i messaggi pubblicati a se stesso agli abbonati collegati.
Messaggio
Quindi abbiamo il messaggio che è il carico utile principale. Il punto di interesse, l'oggetto di interesse per gli abbonati. È un carico utile serializzabile. Potrebbe essere qualsiasi oggetto, potrebbe essere qualsiasi messaggio che si desidera recapitare, qualsiasi dato per la precisione.
Publisher
L'editore è un'applicazione che pubblica messaggi e può anche ricevere una notifica dello stato di consegna opzionale. Lo stato di consegna è qualcosa che puoi scegliere di attivare, ma come deciso in precedenza o come discusso in precedenza, l'editore non deve attendere la consegna del messaggio. Può andare avanti. Quindi, lo stato di consegna opzionale è qualcosa che puoi attivare secondo necessità o puoi disattivarlo.
abbonato
Abbonati, si registrano per argomenti specifici e ricevono tutti i messaggi.
Quindi, esaminiamoli uno per uno e il diagramma illustra tutto ciò di cui abbiamo appena discusso.
L'editore crea messaggi, registra eventi, invia messaggi, argomenti e archivia messaggi, archivia abbonati e invia messaggi. Gli abbonati si iscrivono e quindi ricevono le notifiche dei messaggi.
NCache Interfaccia Pub/Sub Argomento
Quindi, esaminiamo l'interfaccia dell'argomento. Quindi, prima di tutto, puoi creare un NCache Pub/Sub topic e quindi puoi connetterti anche a un argomento esistente o puoi anche eliminare un argomento. Quindi, vediamo cosa è coinvolto in questa interfaccia proprio qui? Quindi, se vado da questo editore proprio qui, devo prima andare al programma e se noti in questo programma, ricevo il nome della cache. Ricevo il nome dell'argomento, che potrebbe essere qualsiasi argomento che puoi scegliere e ricevo un contatore di messaggi, che è un messaggio casuale e quindi ho il metodo publisher.start, che ho implementato e al suo interno ' Sto iniziando la cache, il che significa che la collegherò alla cache e quindi riceverò un'interfaccia di creazione di argomenti e se torno qui, abbiamo IMessagingService. Quindi, se te lo mostro velocemente qui.
IMessagingService Interface for managing Topics in NCache
namespace Alachisoft.NCache.Web.Caching
{
public interface IMessagingService
{
ITopic CreateTopic(string topicName);
void DeleteTopic(string topicName);
ITopic GetTopic(string topicName);
}
}Abbiamo l'interfaccia IMessagingService, che ha un metodo CreateTopic, un metodo DeleteTopic per eliminare un argomento e quindi GetTopic. Esaminiamo questi uno per uno. Quindi, servizio di messaggistica abbiamo creato un argomento o possiamo semplicemente collegarci a un argomento esistente. In realtà, puoi anche abilitare la consegna dei messaggi, la notifica di mancata consegna, se è qualcosa che vorresti fare. Ad esempio, puoi impostare una richiamata proprio qui e quella richiamata a sua volta può essere richiamata ma è facoltativa. Non è necessario che questo sia necessario, se non si desidera abilitarlo. Quindi, come ho detto prima, le notifiche di consegna dei messaggi sono facoltative, quindi non è necessario abilitarle come obbligo. Dipende interamente dal tuo caso d'uso, se vuoi abilitarli, puoi andare avanti e farlo.
Quindi abbiamo un metodo di pubblicazione, che è un metodo personalizzato per questa applicazione, un wrapper per questo e quindi all'interno quello che stiamo davvero facendo è costruire un messaggio e quindi utilizzare topic.publish message. Quindi, questo restituisce un messaggio, un argomento. Una specie di maniglia per quell'argomento e quindi topic.publish è il loro metodo effettivo, se ti mostro rapidamente qui. Questa è un'interfaccia ITopic, che ha un nome, può avere un conteggio dei messaggi, può avere un tempo di scadenza, che ti mostrerò tra un po' e poi ha anche alcune richiamate sull'argomento cancellate, mancata consegna dei messaggi e quindi ti consente di avere un abbonamento per l'argomento e quindi pubblicare messaggi anche su di esso e questo è il primo metodo che volevo mostrare, è che puoi usare topic.publish e quindi se noti che c'è un'opzione di consegna come bene. Puoi avere la consegna a tutti come un must oa chiunque. Quindi, questo è il livello del messaggio, quindi è un'opzione di consegna per i messaggi consegnati o inviati a quell'argomento e poi c'è un ultimo booleano opzionale proprio qui, controlliamo questo, cosa suggerisce? Per questo, se vuoi ricevere o meno una notifica di errore. Quindi, in questo caso lo sto impostando su true ma puoi disattivarlo e, in tal caso, invocherebbe la richiamata sul lato editore di conseguenza.
Quindi, abbiamo visto due metodi qui. Puoi creare un argomento e allo stesso modo puoi anche ottenere un argomento. Quindi, questo è un altro metodo che puoi usare, in alternativa. Ma, dal momento che lo sto eseguendo per la prima volta, sto usando crea argomento, pubblicando messaggi sull'argomento e quindi posso anche eliminare l'argomento, se necessario. Quindi, questi sono alcuni degli scenari e, come puoi vedere, queste diapositive mostrano gli stessi esempi accanto a quello.
Create Topic: Code snippet to create a new topic in distributed cache
string cacheName = "pubSubCache";
string topicName = "orderTopic";
Cache cache = NCache.InitializeCache(cacheName);
cache.MessagingService.CreateTopic(topicName);Quindi, se elimini l'argomento, verrà richiamato il callback dell'argomento eliminato e il callback dell'argomento eliminato è quello da cui puoi notificare i tuoi utenti finali o qualsiasi informazione che devi pubblicare.
Delete Topic: Deletes an existing Topic distributed
string cacheName = "pubSubCache";
string topicName = "orderTopic";
Cache cache = NCache.InitializeCache(cacheName);
cache.MessagingService.DeleteTopic(topicName);
OnTopicDeleted callback: If registered, it will be triggered upon the Delete Topic call.
using (Subscriber subscriber = new Subscriber())
{
// Subscribes on it, using the provided cache-Id and the topic-name.
subscriber.OnTopicDeleted = TopicDeletedCallback;
}
static void TopicDeletedCallback(object sender, TopicDeleteEventArgs args)
{
Console.WriteLine("Topic '{0}' deleted.", args.TopicName);
}NCache Interfaccia messaggi Pub/Sub
Diamo un'occhiata all'interfaccia di messaggistica e qui discutiamo che esiste un'opzione di invalidamento dei messaggi, notifiche di messaggi ricevuti, errore o ricezione, notifica di errore e quindi crittografia e compressione sono supportate come parte di ciò. Quindi, diamo un'occhiata all'interfaccia IMessage per quella materia. Quindi, abbiamo un messaggio proprio qui.
namespace Alachisoft.NCache.Runtime.Caching
{
public class Message : IMessage
{
public Message(object payload, TimeSpan? timeSpan = null);
public static TimeSpan NoExpiration { get; }
public string MessageId { get; }
public TimeSpan? ExpirationTime { get; set; }
public object Payload { get; }
public DateTime CreationTime { get; }
}
}Vediamo, cosa è disponibile come parte di questo. Quindi, prima di tutto, abbiamo un TimeSpan, puoi scegliere NoExpiration o puoi avere un TimeSpan ExpirationTime proprio qui da specificare come opzione di messaggio e se torno qui, se noti che stiamo impostando una scadenza basata sul tempo anche su questo, se noti che questo viene trasmesso proprio qui e abbiamo un lasso di tempo. Quindi, questo viene chiamato dal programma stesso. Quindi, stiamo dando "TimeSpan.FromMinutes(5)". Quindi, ciò significa essenzialmente che qualsiasi argomento che non viene consegnato, se non ci sono abbonati o se gli abbonati sono stati disconnessi, quel messaggio rimarrà nel canale di comunicazione per il periodo di tempo specificato. È una specie di persistenza, ma dal momento che è contro la piattaforma Pub/Sub persistere i messaggi indefinitamente, quindi la base dei tempi è l'opzione giusta, in cui persisti i messaggi per un certo periodo di tempo e successivamente elimini il negozio stesso. Quei messaggi non scadranno individualmente anche dal canale di comunicazione e questa scadenza può essere a livello di argomento stesso. L'argomento stesso può avere la sua scadenza o anche i messaggi possono avere la loro scadenza individuale allegata. Quindi, è qualcosa che fai e, a proposito, se l'editore e gli abbonati sono collegati, l'editore pubblica i messaggi e quelli vengono inoltrati immediatamente. Non aspetta che avvenga la scadenza. Non lo manterrà, se il messaggio è stato consegnato. Quindi, una volta che il messaggio è stato consegnato, esce immediatamente dalla cache. Quindi, è così che imposti la scadenza.
Quindi hai anche qualche notifica ricevuta sui messaggi. Quelli sono qualcosa che ti ho mostrato prima. Ad esempio, puoi vedere la consegna, "Publisher.MessageDeliveryFailure" notifica e quindi puoi anche generare un messaggio, lo stato di successo anche dal messaggio. Quindi, questa è un'altra opzione che puoi attivare come parte di questo e quindi è possibile eseguire anche la crittografia e la compressione dei messaggi e questo è qualcosa che non è un'opzione di modifica del codice. Tutto quello che devi fare è accedere alla cache stessa, andare alle opzioni perché tutto è guidato da NCache si. Quindi, puoi abilitare la compressione e puoi fare clic con il pulsante destro del mouse e scegliere le configurazioni di applicazione a caldo.
La compressione è per oggetti di dimensioni maggiori. Il carico utile del messaggio è di dimensioni maggiori, quindi dovresti attivare automaticamente la compressione e la crittografia è qualcosa che è un'altra opzione proprio qui. Richiede che tu abiliti la crittografia e per questo devi prima interrompere il canale di comunicazione, fermare la cache e quindi abilitare la crittografia. Ci sono molti provider tra cui puoi scegliere e tutti i messaggi verranno crittografati e solo successivamente rispediti all'editore e agli abbonati. Spero che sia stato semplice. Quindi, l'esempio del messaggio è proprio qui.
//Payload containing OrderId to be sent in message
Order payload = new Order();
payload.OrderID = 10248;
payload.OrderDate = new DateTime(2015, 07, 04);
payload.ShipName = "Vins et alcools Chevalier";
payload.ShipAddress = "59 rue de l'Abbaye";
payload.ShipCity = "Reims";
payload.ShipCountry = "France";
//Create message with payload and expiration time set to 150 seconds
Message message = new Message(payload);
message.ExpirationTime = new TimeSpan(0, 0, 150);È possibile utilizzare l'ordine, creare un messaggio, impostare un tempo di scadenza e quindi utilizzare “argomento.pubblica” e fornisci quel messaggio all'argomento giusto.
Notifica messaggio ricevuto
Quindi, messaggio ricevuto notifica. Dal lato degli abbonati, voglio mostrarti anche questo.
Callback invoked when a message is published on the topic
string cacheName = "pubSubCache";
string topicName = "orderTopic";
Cache cache = NCache.InitializeCache(cacheName);
//Get Order topic
ITopic orderTopic = cache.MessagingService.GetTopic(topicName);
//Register subscribers for Order topic
ITopicSubscription ordSubscriber = orderTopic.CreateSubscription(messageReceivedCallback);
private void messageReceivedCallback(object sender, MessageEventArgs args)
{
//perform operations
if (args.Message.Payload is Order ord)
{
//perform operations
}Dal punto di vista dell'abbonato, tutto ciò che devi fare è collegarti alla cache per iniziare. Collegati all'argomento usando "_cache.MessagingService.GetTopic". Questo era il metodo che ti stavo mostrando in precedenza oppure puoi creare un argomento, se esiste e quindi creare un abbonamento che ti consente di ricevere un messaggio in una richiamata ed ecco il messaggio di ricezione della richiamata. Penso che dovrebbe essere proprio qui nel programma. Messaggio ricevuto richiamata. Quindi, questo verrà invocato ogni volta che viene ricevuto un messaggio. Quindi, questo completa l'esempio proprio qui.
Passo dopo passo: pubblica il messaggio sull'argomento
Quindi, passo dopo passo ancora una volta. Inizializzi il cluster di cache Pub/Sub, crei un argomento dedicato o ti connetti a uno esistente. Registra gli eventi di consegna dei messaggi se necessario, è facoltativo. Crea un messaggio e pubblicalo in un argomento separato. Abilita la scadenza, abilita le opzioni di consegna secondo necessità e questo è un codice che aiuterebbe a giustificarlo.
public void PublishMessages()
{
string cacheName = "pubSubCache";
string topicName = "orderTopic";
Cache cache = NCache.InitializeCache(cacheName);
ITopic orderTopic = cache.MessagingService.CreateTopic(topicName);
//Register message failure notification
orderTopic.MessageDeliveryFailure += FailureMessageReceived;
//Register topic deletion notification
orderTopic.OnTopicDeleted = TopicDeleted;
//Payload to be sent in message
Order payload = new Order();
payload.OrderID = 10248;
payload.OrderDate = new DateTime(2015, 07, 04);
payload.ShipName = "Vins et alcools Chevalier";
payload.ShipAddress = "59 rue de l'Abbaye";
payload.ShipCity = "Reims";
payload.ShipCountry = "France";
//Create message with Order and expiration time set to 150 seconds
Message orderMessage = new Message(orderPayload);
orderMessage.ExpirationTime = new TimeSpan(0, 0, 150);
//Publish message to all registered subscribers
//and register message delivery failure notification
orderTopic.Publish(orderMessage, DeliveryOption.All, true);E poi dal lato dell'abbonato ti connetti alla cache, ottieni un argomento esistente o ne crei uno nuovo. Crea una sottoscrizione per l'argomento per la ricezione dei messaggi. Registra gli eventi per la ricezione che saranno eventi asincroni, quindi annulla l'iscrizione all'argomento ed eliminalo, se necessario, e l'eliminazione dell'evento può farne parte.
NCache Monitoraggio per Pub/Sub
Le prossime diapositive saranno incentrate sul monitoraggio delle cose. Esaminiamoli nella totalità. Abbiamo già trattato i dettagli di base all'interno del supporto contatore PerfMon per NCache, abbiamo diverse opzioni all'interno della dashboard. Creiamo un altro dashboard.
Abbiamo tutti questi aggiunti ad esso. Quindi, abbiamo anche alcune statistiche sugli argomenti. Ad esempio, abbiamo le statistiche degli argomenti, che ti ho già mostrato. Conteggio argomenti, numero di argomenti che hai. Conteggio messaggi. Dimensioni dell'archivio messaggi, che sono la dimensione totale e i byte per l'argomento e questo è molto importante per lo sviluppo della capacità. Se stai cercando di capire quanti messaggi vengono consegnati o pubblicati, puoi trascinare e rilasciare il messaggio pubblicato al secondo e il messaggio consegnato al secondo e quindi puoi avere uno stato di scadenza del messaggio e parte di quello. Quindi, questi sono alcuni dei contatori. Se eseguo l'applicazione di esempio ancora una volta, vedresti attività su tutti questi. Va bene, continuerò a caricare un po' premendo invio più volte e se torno qui, puoi vedere le attività su tutti loro.
Ci sono 220 messaggi. Il conteggio degli argomenti è 1 a questo punto. Il conteggio dei messaggi è di circa 220. Vengono visualizzate anche le dimensioni dell'archivio messaggi. I messaggi vengono pubblicati. Ma non ci sono messaggi che sono stati consegnati e non ci sono messaggi che sono scaduti e se eseguo solo un abbonato, sarà molto veloce, vedresti che anche quei messaggi verranno ricevuti. Ecco qua e se torno qui, ora dovresti vedere l'attività anche qui. Anche i messaggi vengono ricevuti.
Quindi, questo completa il processo, puoi registrare questi contatori per vedere la capacità, per vedere gli argomenti generali che ci sono, i messaggi lì, le dimensioni del negozio e anche la scadenza di quei messaggi e posso creare tutti gli argomenti di cui ho bisogno in base sulle mie esigenze. Gli stessi contatori sono disponibili anche su Windows PerfMon. Quindi, hai lo stesso set qui e inoltre hai anche alcuni cmdlet di PowerShell. Ad esempio, se vai alla nostra documentazione qui, fammi aprire molto velocemente. Quindi, abbiamo tre diverse opzioni, Contatori PerfMon, NCache Monitor e cmdlet di PowerShell. In alcuni casi, vuoi solo fare affidamento sugli strumenti. Quindi, a tale scopo puoi utilizzare la nostra documentazione e all'interno della nostra guida di PowerShell, vediamo, se riesco a cercarla molto velocemente. Mi ha fornito un collegamento generale, quindi fammi vedere alcune opzioni di monitoraggio proprio qui. Quindi, puoi vedere "Get-Topics", che è un cmdlet di PowerShell, che ti consente di ottenere i nomi degli argomenti in base al nome della cache. Ad esempio, se apro PowerShell proprio qui. Posso usare questo comando, lasciami aprire da questo lato, quindi è chiaro. Va bene, quindi, ad esempio, posso eseguirlo da qualsiasi casella qui e quindi pubSubCachewin è il nome della cache. Non mi darebbe niente. Ho bisogno di eseguirlo sul server stesso perché penso che non lo sia, pubSubCachewin, ecco qua. Il mio argomento, abbonati, editore e conteggio dei messaggi.
Il motivo per iniziare a lavorare dalla mia scatola perché ha bisogno di un indirizzo IP per sapere dove esiste la cache. Quindi, ci sono alcuni strumenti sul lato PowerShell delle cose, che ti consentono di vedere alcune statistiche secondo necessità. Quindi, questo completa la parte demo. Per favore, fammi sapere se ci sono domande. Passerò un po' di tempo verso la fine per i dettagli sull'architettura o su ciò che viene offerto come parte di questo canale di comunicazione, NCache come piattaforma di messaggistica e perché NCache è una misura migliore?
Architettura della cache distribuita
Prima di tutto, NCache è Open Source. Quindi, puoi iniziare e Pub/Sub è disponibile anche in una versione Open Source di NCache. È linearmente scalabile, questo è il punto numero uno e prima ancora è in memoria, questo è il principale punto di interesse per le applicazioni che cercano solo prestazioni e non stanno cercando di avere requisiti di carico elevati per iniziare. Quindi, se c'è un problema di prestazioni NCache ancora una volta è una soluzione migliore rispetto alle tradizionali piattaforme di messaggistica Pub/Sub.
È linearmente scalabile, il che significa essenzialmente che puoi aggiungere tutti i server di cui hai bisogno. Due server sono abbastanza buoni. Ma se raggiungono la capacità perché la capacità può essere colpita NCache anche i server. Il problema iniziale che hai riscontrato con il database. Non lo stiamo dicendo NCache non vedrei questo problema. Con un server puoi raggiungere una capacità e del resto puoi avere più server, ma quei più server potrebbero anche aggiungere capacità. Ad esempio, questi due server sono al massimo ed è il momento giusto perché si conosce in anticipo i requisiti di carico o il carico è elevato sull'applicazione. Quindi, puoi in qualche modo prevenirlo aggiungendo più server ed effettuando una migliore pianificazione della capacità. Quindi, più server possono essere aggiunti al volo e questo è il bello di ciò che è linearmente scalabile.
Poi la terza caratteristica importante è che, se necessario, puoi anche avere il supporto per la replica e questo garantirebbe l'affidabilità. È già altamente disponibile e il suo server che si interrompe non avrà un impatto sui client finali o la piattaforma dell'editore o dell'abbonato funzionerebbe senza problemi. Finché hai un nodo sopravvissuto nel cluster di cache, la piattaforma Pub/Sub rimarrà attiva e funzionante e perché è in grado di farlo? È altamente disponibile perché è di natura dinamica.
È un cluster di cache con architettura peer-to-peer al 100%. Ciò ti consente di aggiungere tutti i server di cui hai bisogno e quei server sono di natura indipendente. Contribuiscono alla richiesta di capacità di movimentazione distribuendo il carico ma funzionano in modo indipendente al 100%. Qualsiasi server che si interrompe o viene aggiunto un nuovo server non avrebbe alcun impatto sulla cache. La piattaforma non ha bisogno di essere fermata per questo. Può continuare a funzionare e quindi non è necessario arrestare o riavviare i client. Questo è il problema con le origini convenzionali, dove se un server si interrompe potrebbe essere necessario riavviare i client per iniziare a utilizzare i nodi sopravvissuti. Quindi, questa è una dinamica di natura in cui i client si adeguano automaticamente e il cluster stesso è un tempo di attività del 100% con un meccanismo di auto-guarigione. Se un server viene aggiunto, il cluster si adegua distribuendo il carico al server appena aggiunto e notificando i client allo stesso tempo.
Allo stesso modo, nel caso di manutenzione o in caso di guasto del server, in cui un server si arresta o si guasta in quel caso, il cluster di cache rimane attivo e funzionante. È necessario un nodo sopravvissuto affinché funzioni e i client vengano avvisati in fase di esecuzione. Il supporto per il failover della connessione è integrato nel protocollo lato client. Pertanto, i client rilevano gli errori e quindi eseguono il failover e iniziano a utilizzare automaticamente i nodi di sopravvivenza e ciò garantisce un tempo di attività del 100% sul lato cache e anche per i client finali che sono collegati ad essa. Quindi, è di natura dinamica. È un'architettura peer-to-peer al 100%. Il supporto per il failover della connessione è integrato e il cluster si sta auto-riparando. È un meccanismo integrato nel protocollo. Ciò garantisce un tempo di attività del 100%, uno scenario di cache altamente disponibile.
Topologie di memorizzazione nella cache: cache partizionata
La topologia dei canali di comunicazione.
La piattaforma Pub/Sub può avere il partizionamento dei dati. Puoi avere i dati partizionati sul Server 1 così come sul Server 2. Questi sono elementi di dati che rappresentano i tuoi messaggi. Quindi, abbiamo alcuni messaggi consegnati dal Server 1 e alcuni dal Server 2. È completamente casuale, basato sul nostro algoritmo di distribuzione e il tuo editore e gli abbonati sono collegati a tutti i server. Quindi, alcuni sono connessi al Server 1, altri sono connessi al Server 2, ma se noti che ogni server ha, in realtà sono connessi a tutti ma alcuni messaggi vengono consegnati dal Server 1 e alcuni dal Server 2 e così via via. Quindi, il carico dei messaggi verrà distribuito e questo è eccentrico, in cui utilizza completamente la capacità di memoria di tutti questi server, per servire i messaggi, per archiviare i messaggi, per il loro tempo di scadenza e unisce anche la loro potenza di calcolo in una capacità logica anche. Quindi, tutti questi servizi contribuiscono alla capacità di gestione delle richieste e questo è il motivo per cui se si aggiungono più server si ottiene più capacità dal sistema ed è per questo che si consiglia di utilizzare la topologia della replica dell'operazione di partizione perché è possibile scalare linearmente, se si bisogno di.
Topologie di memorizzazione nella cache: cache di partizione-replica
Questa è la cache di replica delle partizioni, che ha anche il supporto per il backup.
Abbiamo la partizione attiva del Server 1, il backup su (server) 2. Quindi, tutti i server formulano una partizione attiva e una partizione di backup di un altro server, che è una replica per l'altro server. Il server 1 è il backup attivo sul server 2, il server 2 è il backup attivo su 3 e il server 3 è il backup attivo su 1 e il cluster è ancora in grado di gestirlo se un server si interrompe. Perché, se il server 1 non funziona, il backup del server 1 era su 2, quindi questo backup viene attivato e viene unito al server 2 e 3 e il cluster si autoguarisce e formula un backup attivo a 2 nodi, meccanismo attivo passivo in cui il backup del server 1 è attivo Il backup del Server 2 è sul Server 1. Ed è completamente trasparente per i tuoi utenti finali. Non devi preoccuparti che gli utenti finali ne siano interessati. Quindi, con un tempo di attività del 100%. NCache assicura tutto questo.
Va bene, questo ci porta verso la fine della nostra presentazione. Per favore, fatemi sapere, possiamo concentrarci verso la fine su alcune delle domande che potreste avere. Quindi, a questo punto, lo consegnerei a Eddie. Eddie puoi prenderlo da qui. Ancora una volta, grazie mille per il tuo tempo. Speriamo che sia stato utile e non vediamo l'ora di rivederti al nostro prossimo webinar. Nel frattempo, se hai bisogno di rivedere il webinar esistente, che hai appena esaminato online all'indirizzo alachisoft.com/risorse Ancora un promemoria, NCache è l'unica applicazione nativa oggi sul mercato per le massime prestazioni. Non vedo l'ora di rivederti presto. Grazie.