NCache Dividi architettura e demo per il recupero del cervello
NCache fornisce un'importante capacità architettonica ad alta disponibilità chiamata Split Brain Detection and Recovery. Guarda questo video per conoscere questa funzionalità e poi guarda una demo pratica di NCache Recupero del cervello diviso.
Oggi parlerò del NCache architettura di recupero del cervello diviso e te ne fornisci anche una demo.
NCache è una cache distribuita in memoria per .NET e .NET Core applicazioni. Supporta anche le applicazioni Java e Node.js. NCache viene utilizzato nelle applicazioni di transazione più elevate in cui l'applicazione è in esecuzione su più server delle applicazioni. Potrebbero essere le tue applicazioni Web, le tue applicazioni di microservizi o qualsiasi altra applicazione server. E, NCache si trova tra il livello dell'applicazione e il database, sia che si tratti di un server SQL o di un tipo di database relazionale Oracle o qualsiasi altro NoSQL database come CosmosDB o MongoDB o qualsiasi database o dati mainframe legacy. E, NCache di solito ha due o più server cache in un cluster e per questo ambiente applicativo mission-critical NCache fornisce alta disponibilità e come parte di tale alta disponibilità, c'è una funzionalità molto importante chiamata rilevamento del cervello diviso e ripristino del cervello diviso di cui parlerò.
Architettura dinamica del cluster di cache
Prima di entrare in split-brain, lascia che ti dia rapidamente una panoramica del NCache architettura di clustering dinamico della cache.
Questa è un'architettura basata su TCP in cui ogni server è connesso a ogni altro server tramite un socket TCP. È un'architettura peer-to-peer che si autorigenera. L'auto-guarigione significa che si adatta automaticamente a qualsiasi cambiamento. E non c'è un singolo punto di errore a causa di quell'architettura peer-to-peer. Ciò significa che non c'è padrone non c'è schiavo. È presente un nodo coordinatore del cluster che di solito è il nodo più vecchio del cluster. Ma, se mai dovesse diminuire, il nodo successivo più vecchio diventa automaticamente il suo successore. Un coordinatore del cluster è responsabile della gestione del cluster. Gestisce l'appartenenza al cluster. Gestisce, in caso di topologia Partizione o Partizione-Replica, gestisce la mappa di distribuzione dei dati. E gestisce anche l'integrità del cluster.
Ora, come ho detto, ogni nodo in questo cluster è connesso a ogni altro nodo e tiene traccia di quella connessione. E, se la connessione si interrompe, c'è una funzione di failover della connessione all'interno del cluster, ovvero quel nodo esegue automaticamente nuovi tentativi, più tentativi che è un'opzione configurabile e ogni nuovo tentativo ha un timeout. E c'è anche una funzione heartbeat in cui continua a inviare un heartbeat a un intervallo configurabile per assicurarsi che la connessione del socket sia attiva. Il motivo per cui tutto ciò viene fatto è perché nella maggior parte delle situazioni è sufficiente per garantire che qualsiasi interruzione della connessione venga ripristinata o ripristinata automaticamente. E il motivo è perché i server cache sono solitamente distribuiti nello stesso data center, di fatto, nella stessa sottorete. Quindi, la connessione tra questi server cache di solito è molto affidabile. E il cervello diviso non si verifica molto frequentemente, ma a volte lo fa. E, quando lo farà, parlerò di come lo gestiamo.
Ad ogni modo, questa architettura ti consente di aggiungere o rimuovere qualsiasi server cache in fase di esecuzione senza interrompere la cache o nessuna delle tue applicazioni. Inoltre, ogni volta che aggiungi un server cache al cluster, il coordinatore del cluster aggiorna la mappa di appartenenza al cluster e la propaga dinamicamente a tutti i server cache, che quindi si propagano dinamicamente a tutti i client. E, allo stesso modo, se si tratta di una topologia di partizione o replica di partizione, anche la mappa di distribuzione dei dati viene aggiornata e puoi accedere al NCache video di architettura per maggiori dettagli su questo. Ma una topologia di partizione o replica di partizione ha 1000 bucket che è la mappa di distribuzione e la mappa in pratica, dice ai server quali bucket ha ciascun server e quando viene inviato ai client, i client sanno dove si trovano i dati. Quindi, questo è il cluster di cache dinamica.
Connessioni client dinamiche
Il secondo aspetto di ciò sono le connessioni client dinamiche, ovvero che, proprio come la connessione all'interno del cluster è dinamica, anche la connessione tra i client e il cluster è dinamica.
Ed è una connessione basata su TCP molto leggera. E, se la connessione dovesse interrompersi, c'è di nuovo una funzione di failover della connessione in cui ci sono tentativi e timeout. Inoltre, c'è anche la funzione di mantenimento in vita in cui il client continua a inviare un messaggio di tipo heartbeat al cluster per assicurarsi che la connessione rimanga attiva. In realtà, la probabilità di interruzione della connessione tra i client e il cluster è più probabile che all'interno del cluster stesso e il motivo è perché i client potrebbero essere distribuiti in una sottorete separata, anche attraverso il firewall. Quindi, tutto ciò di solito aumenta le possibilità di rottura delle prese. Quindi, ogni volta che ciò accade, i client possono riconnettersi. Quindi, c'è una funzione di failover della connessione.
L'intera architettura consente di aggiungere o rimuovere client in fase di esecuzione senza arrestare la cache o l'applicazione. E, ogni volta che viene aggiunto un client, il client ottiene le informazioni sull'appartenenza al cluster dal cluster e quindi se si tratta di una topologia di partizione o replica di partizione, ottiene anche la mappa di distribuzione dei dati che ho mostrato qui dal cluster. E ciò consente al client di sapere automaticamente esattamente quanti server ci sono nel cluster, chi sono. Quindi, puoi connetterti a loro solo in una topologia di partizione o replica di partizione e anche sapere qual è la mappa di distribuzione dei dati.
Rilevamento del cervello diviso
Quindi, considerando tutta quell'architettura, c'è ancora una situazione nonostante il fatto che ci sia resilienza incorporata nella connessione TCP attraverso tentativi e timeout, ma una connessione potrebbe effettivamente interrompersi tra i server di cache per qualche motivo. Potrebbe essere un motivo hardware. Potrebbe essere un problema di driver di rete o potrebbe essere una varietà di motivi. Ogni volta che ciò accade, lo chiamiamo interruzione della connessione.
Pertanto, nell'architettura di clustering della cache, ogni nodo del cluster continua a rilevare se si è verificata un'interruzione della connessione, il che significa che, nonostante i tentativi, la connessione si è interrotta. Ogni volta che una connessione si interrompe, ogni nodo presume che l'altro nodo sia morto. Quindi, continua a parlare con tutti gli altri nodi. Quindi, ad esempio, se hai un server qui, questo nodo sta parlando con tutti e tre questi. Quindi, questo nodo potrebbe non funzionare. Quindi, questo nodo potrebbe essere in grado di parlare con questi tre. Quando ciò accade, si presumerà che questi tre siano ora un cluster di tre e che questo nodo sia andato via. Quindi, quando succede qualcosa del genere, diciamo, un cluster di sei nodi e farò solo l'esempio che le connessioni si interrompono in modo tale che tre di loro siano in grado di parlare tra loro, questi due sono in grado di parlare tra loro e questo non è in grado di parlare con nessuno.
Quindi, quando ciò accade quando questi nodi rilevano tutto ciò, tutti presumono che, va bene, sono un gruppo di tre perché sono in grado di parlare con questi tre nodi e quando sono un gruppo di tre allora uno dei miei nodes diventerà un coordinatore del cluster che potrebbe già essere un coordinatore del cluster perché se è s1 che probabilmente era il più vecchio e continua ad essere il coordinatore del cluster qui. Ma, in caso di divisione a due, s4 diventa il nuovo coordinatore del cluster per questo cluster. E, per lo split 3, s6 essendo l'unico nodo diventa anche il coordinatore. Ora, in questa situazione, questi nodi sanno che questi tre nodi sono in grado di parlare con questi tre nodi. Quindi, dice ok, sto bene, gli altri sono morti. Questo pensa la stessa cosa, sto bene che gli altri sono morti. Questi pensano che io sia buono, gli altri sono morti.
Ma sanno anche che dovrei essere un cluster di sei nodi. Quindi, continuano a provare a eseguire il ping di tutti gli altri nodi per vedere se torneranno su. E il ping avviene per un intervallo configurabile, dopo di che si arrenderanno e presumeranno che questi nodi siano caduti in modo permanente e io sono l'unico rimasto. Ma, entro quell'intervallo, se diciamo la connessione, la connessione di rete viene ripristinata e questi nodi sono ora visibili l'uno all'altro. Quindi, diciamo che tutti sono in grado di vedersi in questo esempio. Quindi, ora si rendono conto che abbiamo creato tre divisioni separate ma siamo in grado di parlarci.
Quindi, ora lo faranno formalmente, NCache rileverà formalmente una divisione. Anche se la scissione è avvenuta nel momento in cui le connessioni si sono interrotte, NCache nodes non sapevano che si trattava di una scissione perché pensavano che fossero tutti morti. Ma, se quei nodi sono tornati entro quell'intervallo specificato, i nodi della cache diranno, ok si è verificata una divisione e ora è il momento di eseguire un ripristino diviso. E il motivo per cui ciò viene fatto è perché la tua applicazione ha bisogno di un cluster di cache integro per continuare a funzionare e sebbene la divisione non sia una situazione salutare, se puoi ripristinarla automaticamente, invece che il tuo personale amministrativo deve intervenire in orari dispari del giorno o della notte o nei fine settimana. Allora ti semplifica la vita NCache ritorna automaticamente a uno stato sano, un gruppo sano di sei. Ma come succede?
Il primo è che la divisione viene rilevata come ho detto viene rilevata solo quando la connessione viene ripristinata e sono in grado di vedersi. Fino a quel momento presumono che gli altri siano morti. Bene? Ora che la divisione è stata rilevata, ora entra in gioco il ripristino della divisione.
Recupero del cervello diviso
Che cosa è coinvolto nel recupero diviso?
Quindi, nel recupero diviso, i due sottogruppi più grandi o le due più grandi scissioni vengono uniti per primi. E il cluster di questa divisione e il cluster di questa divisione, si coordinano tra loro per dire ok poiché sono il più piccolo dei due e la dimensione qui si basa sul numero di nodi in ciascun cluster. Potrebbe essere basato sulla quantità di dati. Avrebbe potuto essere basato sulla quantità di attività e sul numero di clienti, ma abbiamo scelto il numero di nodi perché quella era la situazione più probabile. Perché, nella maggior parte delle situazioni, ogni nodo ha più o meno la stessa quantità di dati a causa della distribuzione della mappa hash, perché ci sono mille bucket che sono distribuiti uniformemente, perché c'è una funzione di bilanciamento dei dati in NCache che ribilancia i dati tra i nodi se mai dovesse sbilanciarsi.
Quindi, tutto ciò significa che la situazione più probabile è che ogni nodo abbia approssimativamente la stessa quantità di dati. Quindi, il maggior numero di nodi significa la maggiore quantità di dati. Quindi, quello diventa il maestro. E quest'altra divisione deve rinunciare ai suoi dati e ricongiungersi a questo cluster come nuovi nodi. Quindi, la prima cosa che fa, rinuncia ai suoi clienti, dice. Quindi, questi due server, questo coordinatore dice al suo altro nodo che va bene dobbiamo rinunciare ai client e dire ai client di connettersi a questo cluster. Quindi, la prima cosa che accade è che i client si spostano nel nuovo cluster perché questo è il cluster sano, questo è il cluster principale. Una volta che i client si sono spostati qui, ora questo cluster rinuncia ai suoi dati e sostanzialmente puoi vederlo riavviarsi. Sebbene non si riavvii, rinuncia ai suoi dati e si unisce nuovamente a questo cluster come nodo integro.
E ora, di conseguenza, hai un cluster a cinque nodi che è una fusione di split one e split two. Quindi, dopo averlo fatto, passa alla divisione successiva più grande e la unisce a questa. Ora, nel nostro caso, avevamo solo tre divisioni ma potresti averne più di tre e l'algoritmo è che inizi con il più grande e lo unisci con il successivo più grande e il successivo più grande e così e così. Quindi, esegui tutte le iterazioni necessarie, ma in qualsiasi momento vengono unite solo due divisioni. Quindi, mentre queste due divisioni vengono unite, la terza divisione è considerata indipendente, continuerà a svolgere le sue operazioni fino a quando la divisione non verrà unita e ora questa fusione avverrà.
E, se ci fosse una quarta divisione che sarebbe stata unita anche dopo questa. Quindi, in questo processo, tieni presente che a seconda di quanti nodi hanno dovuto perdere o rinunciare ai propri dati, i dati andranno persi. Quindi, ad esempio, in questo caso, tre nodi diventano master, gli altri tre perdono i loro dati. Anche in una topologia di replica di partizione, hai solo una replica per partizione. Quindi, perderai dati e questa è solo la parte di questa situazione. Tuttavia, l'altra parte di questa realtà è che se per la situazione di memorizzazione nella cache dei dati, questi dati stanno già arrivando. Questo esiste già nel database. Quindi, non stai perdendo i dati, devi solo ricaricarli dal database. Potresti ricaricarlo in base all'incostante delle operazioni della tua applicazione. Puoi anche ricaricarlo in base alla lettura. Puoi anche ricaricarlo in base alla funzione di aggiornamento della cache di NCache ma in entrambi i casi i dati non vengono persi.
Tuttavia, se i dati erano più di uno stato di sessione, qualsiasi altro dato transitorio, che non esisteva in un archivio permanente, allora quei dati sono stati persi. Quindi, in tal caso, devi ricreare quelle sessioni. Ma, nonostante ciò, la perdita di dati è ancora una situazione migliore perché dopo tutto hai avuto un guasto alla rete. Quindi, questo ha delle conseguenze.
Nella prossima versione di NCache, forniremo una funzione di persistenza in cui è possibile mantenere la cache. E una cache persistente significa che tutto ciò che era nella cache, è tenuto da solo, NCacheil proprio archivio di persistenza e in questo modo in un ripristino del cervello diviso, non perderai nemmeno i dati transitori, perché NCache ne sta conservando una copia su un archivio persistente. Ma ne parlerò quando quella funzione sarà resa pubblica. Quindi, in questo momento parlerò solo di questo.
Demo pratica
Quindi, spero di aver spiegato questa architettura. Ora, in realtà ti darò una demo di esattamente come puoi farlo NCache. Quindi, ho un esempio in cui ho cinque server cache e creerò una divisione tra questo e questo elenco.
Creerò solo queste due divisioni. Split one conterrà questi due server cache e split two conterrà questi due server cache. E ho un client Windows che userò, che è dove sono seduto in questo momento, che userò per la gestione e il monitoraggio. E ho un client Linux su cui ho due scaffali aperti per questo client. Quindi, da lì posso avviare due applicazioni client separate. Quindi, ho questo cluster in esecuzione in questo momento. Non ti mostrerò come aggiungere questo cluster perché ci sono altri video che ti mostrano come farlo. Ti mostrerò solo la parte del cervello diviso.
Monitora l'integrità e le statistiche del cluster
Quindi, qui, ho un cluster a cinque nodi. Ho un cluster a cinque nodi. Quindi, ho un cluster a cinque nodi che è proprio qui ed è in esecuzione. Va bene e vado avanti e apro le statistiche e aprirò anche il suo monitor. Quindi, quello che ho fatto è che ne ho aperti due diversi NCache finestre di gestione. Uno è collegato al .97 che è proprio qui, e uno è collegato al .82 proprio qui. Quindi, questo è .97 che ho il vero manager. Ho il monitor e ho le statistiche. E il secondo è il .82 e lo farò di nuovo. È lo stesso cluster ma sto solo parlando con un server diverso per la gestione. Sto parlando con questo server rispetto a questo, proprio qui. E, in questo, farò di nuovo statistiche. Quindi, posso vedere l'attività. Al momento non ci sono attività perché non ho ancora client in esecuzione. E aprirò anche il monitor.
Allora, perché ne ho aperti due? Perché, voglio monitorare, voglio connettermi a questo nodo e voglio connettermi a questo nodo. Quindi, quando faccio la divisione posso vedere. Perché, se sono connesso a questo solo quando si verifica la divisione, mostrerà solo che ho solo due server rimasti e questi non saranno in grado di vederli. Quindi, voglio vedere questo da entrambi i punti di vista. Perché, introdurrò la divisione tramite una regola del firewall, ovviamente, nel tuo caso non avrai la regola del firewall. Avrai una sorta di interruzione della rete. Quindi, lo introdurrò o lo simulerò attraverso una regola del firewall. Quindi, ora sono connesso a questo nodo per la gestione e il monitoraggio e questo nodo per la gestione e il monitoraggio. E ora verrò qui e farò... oh no, non ancora.
Userò anche questa riga di comando per chiamare Get-Caches-Server e parlerò con .82 qui.
Parlerò con 82 e dirò di darmi i dettagli di tutte le cache che hai. Quindi, .82 sta dicendo, ho una cache chiamata democache in cui ho cinque server; 82, 102, 122, 97 e 117. Un cluster a cinque server che è dovuto al fatto che non c'è divisione in questo momento.
Vado sull'altro server, il 97.
Gli chiederò la stessa cosa. Ho detto dammi il tuo server. Dice tutto bene, ho una cache a cinque server; 82, 102, 122, 97 e 117, attualmente. Quindi, è un cluster di cinque server, niente Split, va tutto bene.
Simula lo stress utilizzando il cmdlet Test-Stress di Powershell
Tutto funziona bene. Ora avvierò l'applicazione. Ho una finestra di PowerShell. In realtà, questa è una scatola Linux proprio qui. Ti mostrerò cosa è successo qui. Dai! Apro di nuovo PowerShell. Mie scuse. Importerò solo questo modulo che è il NCache modulo gestionale. Devi farlo solo su Linux. Non è necessario importarlo su Windows. Quindi dirò Democache Test-Stress. Bene. Quindi, ora ho eseguito questo di questo strumento. Farò lo stesso qui.
Sto per dire Democache Test-Stress. Ho entrambi questi. Ora guarda, ho delle attività in corso. Ho attività in corso su tutti e cinque i nodi, come puoi vedere qui, uno due tre quattro cinque. Su tutti e cinque i nodi ho attività in corso. Proprio qui, posso vederlo. Anche qui. Ho cinque nodi. Sto parlando di nuovo di 97, questo è .97 ora.
Vediamo se riesco a vedere lo stesso anche qui. Quindi, andrò a .82 e vedrò che ho cinque nodi di attività in corso. La finestra delle statistiche mostra anche l'attività.
Bene! Quindi, tutto funziona bene. Normalmente, non aprirei questo e monitorare il gestore della cache su due server diversi. Il motivo per cui sto aprendo è perché ho bisogno di mostrare la divisione e quando si verifica la divisione ho bisogno di mostrarti da entrambi i lati della divisione cosa sta succedendo.
Induzione di una disconnessione dalla rete
Bene! Ora che ho tutto in esecuzione. Ora vado avanti e introduco. Quindi, quello che farò è su queste due scatole, userò la regola del firewall. Quindi, userò il firewall qui. Userò un firewall qui. Quindi, ho già impostato queste due regole. Quindi, sto per accedere. Ho effettuato l'accesso a 97 qui. Ho una regola qui. Vado al diciamo che ho una regola in entrata. È NCache, l'ho appena chiamato NCache cervello diviso. Questa regola dice di bloccare la connessione su quali porte, da 78 a 7900, è la cache.
NCache avvia un processo separato per ogni cache. Quindi, quel processo di cache utilizza per impostazione predefinita una porta da 7800 a 7900. Sebbene sia configurabile. Quindi, potresti utilizzare una porta diversa, nel qual caso devi bloccarle se vuoi simularlo. E la porta 8250 è la porta di gestione.
Scope dice blocco per 82, 102, 122. Quindi, sto dicendo a questo, blocca queste tre caselle dall'accesso, questo è fondamentalmente quello che sta dicendo.
Quindi, ho questo porto. Dirò abilita regola e ho la stessa porta per una regola in uscita. È un... Quindi, sta bloccando l'uscita. E ora vado al 117 e blocca anche quello. Vengo al 117. Di nuovo, ho un ingresso proprio qui. Stessa cosa qui. Blocco connessione, porte, 78 79, ambito, tutte e tre queste scatole. Bene. Quindi, dirò abilita regola. È abilitato. Vado all'altro, dirò abilita la regola proprio qui.
Ok, ora quello che ho fatto, ho attivato il firewall su tutti questi.
Formazione di due sottogruppi
Quindi, ora la divisione inizierà a verificarsi. Anche se non accadrà immediatamente e posso vedere che prima chiederò a 82 qual è questo, quanti server hai nella cache? Dice bene! Ho 82, 102, 122, 97, 117. Quindi ne ha ancora tutti e cinque perché la divisione non è ancora avvenuta. Sta ancora attraversando i tentativi e tutte le altre cose. Chiederò all'altro, quanti server hai? Ne ha ancora uno, due, tre, quattro, cinque. Quindi, non è ancora avvenuta alcuna divisione perché ci saranno ancora tentativi e timeout. Ma la divisione avverrà presto.
Verrò qui a vedere se inizia a vedere delle fermate. Quindi, sto parlando con 97 qui, 97 è il lato del cluster a due nodi.
Quindi, 97 mi sta dicendo che sta solo vedendo... Quindi, non sta vedendo 102, 182, 82 sta dicendo che quelli sono fermi ma 97 e 117 stanno andando bene. Bene! Vediamo cosa mostra l'altro lato. L'altro lato della spaccatura che era l'altro lato. Quindi, stavo parlando con 97, ora parlerò con 82 come puoi vedere questo è l'82, proprio qui c'è l'82. Indirizzo IP ... dice ok! Dicendo 102, 122. Quindi, sta dicendo 122 è parzialmente connesso e 82 è completamente connesso.
Sta ancora attraversando quel recupero. Sta ancora attraversando questa fase di tentativi in cui 122 non è in grado di parlare con alcuni degli altri nodi ma andrà avanti e quello che accadrà è che ti mostrerò rapidamente...
Quindi, c'è una funzionalità qui di cui ti ho parlato nel cluster, se c'è un nodo parzialmente connesso rimuove quel nodo parzialmente connesso o parzialmente connesso dal cluster per creare un cluster sano. Quindi, questo è ciò che sta accadendo in questo momento è che sta rimuovendo quell'altro cluster, quell'altro nodo che è un nodo parzialmente connesso. Ora, veniamo di nuovo qui e ora vediamo cosa dice la riga di comando. Sto parlando con 82 che, come ho detto, è il cluster a tre nodi. Quindi dovrebbe... vediamo quanti ne ha? Oops proprio qui, sta dicendo 82 ha uno, due, tre, quattro. Quindi, ne ha quattro. Non ne ha ancora cinque. Ne ha quattro. Sta ancora attraversando il... rimuoverà forzatamente i nodi così come sono e ora vado a 97 che è proprio qui e dirò ok quanti server hai? E 97 ne ha solo due.
Quindi, 97 ha già stabilito il fatto che non può vedere gli altri tre. Quindi, pensa bene che io sia l'unico gruppo qui. Non sa che c'è una divisione perché come ho detto solo la divisione, NCache sa di una divisione solo quando questa connessione viene ripristinata. Quindi, in questo momento pensa solo che gli altri nodi siano morti. Quindi, e dice che va bene, continuerò con me stesso con questi due nodi. E, lasciami andare all'altro qui. Vediamo cosa ha. Oh ok! Ora ne rimangono anche tre. Quindi, è passato e ha anche fatto questo. Ha rimosso il nodo parzialmente disconnesso per raggiungere ora un cluster integro. Ma è un cluster di soli tre nodi, giusto?
Quindi, ho parlato con il server .82 qui che è proprio qui. Gli ho chiesto quanti server hai nella tua cache, dice solo tre. Ho chiesto a 97 quanti server hai nella tua cache, dice solo due.
Bene! Quindi, è avvenuta una scissione. Come parte della divisione vedrai che finora l'applicazione non ha generato eccezioni. Ciò significa che la divisione è avvenuta senza alcuna perdita di dati. Questo probabilmente potrebbe essere dovuto al fatto che l'applicazione non si è verificata, ma in alcuni casi incontrerai alcune eccezioni.
Dividi il rilevamento e il recupero del cervello al ripristino della rete
Bene! Ora, il prossimo passo che farò è andare avanti e dare un calcio al cervello diviso. Quindi, voglio ora ripristinare la connessione in modo che venga rilevato lo split-brain e venga avviato un ripristino. Ma, prima di farlo, ti mostrerò che nella mia configurazione della cache se vado alle impostazioni del cluster che è il primo argomento qui, se vado fino in fondo, ho già abilitato il ripristino automatico per cervello diviso.
Quindi, se abiliti il ripristino automatico, ciò significa NCache si riprenderà automaticamente da un cervello diviso una volta rilevato il cervello diviso. E, come ho già detto, rileva lo split-brain quando viene ripristinata la connessione.
Quindi, torniamo ora a 97 e questo e spegniamo questo firewall. E prima farò il 97. Verrò qui e dirò, disabilita questa regola e verrò qui e dirò disabilita questa regola.
Bene! L'ho fatto ora, verrò qui a 117 e dirò che disabilitiamo anche la regola qui. Disabilita la regola. Disabilita la regola. Bene! Ora ho disabilitato le regole. Quindi, questo firewall è disattivato, il che significa che ora sono in grado di vedersi, o molto presto, saranno in grado di vedersi. Non accadrà istantaneamente, ma potranno vedersi. E, come puoi vedere...
Quindi, in realtà verrò di nuovo qui e dirò mostrami la tua cache. Sono di nuovo, lo terrò di fronte a me e dirò che sto parlando con 82 in questo momento e dico mostrami le tue cache, 82 dice, ho 82, 102, 122. Quindi, così finora ha ancora tre cache. Non è vedere gli altri due. Vado all'altro e ti dirò mostrami i tuoi cache. Dice 97 e 117. Finora il recupero del cervello diviso non è entrato in vigore, ma lo farà. Lo farà perché ci vuole un po' di tempo prima che avvengano i tentativi. Come puoi vedere qui, vedo già uno due tre quattro cinque server. E qui uno due tre quattro cinque server.
Ma, di nuovo, dipenderò dal mio buon vecchio strumento PowerShell da riga di comando per dirmelo. Lo farò ottenere chiamate cache. Parlerò con 82 e dirò mostrami quanti server hai. Ha ancora uno due tre. E io dico mostrami quanti server hai proprio qui. Ne ha ancora uno due. Quindi, di nuovo, uno due e uno due tre. Quindi, nessuna connessione è stata. Quindi, il cervello diviso non è stato ancora recuperato. Ed è per questo che sarà ancora parzialmente connesso, parzialmente connesso e i clienti continuano a lavorare.
Bene! lasciami andare di nuovo. Facciamone un altro. Non è ancora finito. Bene! Vai qui. 97.. Forza! Bene! Ora inizia a vedere l'altro nodo. 82, 102, 122 e anche 97 proprio qui. Ma è ancora parziale. Deve vederne due e dovresti vedere sia la partizione che la replica ed è per questo che probabilmente non è ancora in grado di parlare con 97 perché... Va bene! Ora, 82, 102, 122, 97, di nuovo cinque nodi vengono ripristinati qui. Tutti e cinque.
Fammi andare a questo. Questo. In qualche modo... Andiamo! Lo cambierò qui. Quindi, invece di 82 dirò 97 qui. Ora fallo. Vedrò che anche 97 mi mostra cinque nodi, uno due tre quattro cinque. Bene. Quindi, tutti e cinque i nodi vengono ricollegati.
Verrò qui. Lasciami riavviare questo monitor. Verrò di nuovo qui. Questa cache, dirò statistiche. Vedo che tutti e cinque stanno lavorando e i clienti stanno parlando con loro. Quindi, ancora una volta il fatto che il client stia parlando con tutti e cinque significa che anche le connessioni client vengono ripristinate automaticamente. E il monitor mi mostrerà anche tutti e cinque qui. Quindi, come puoi vedere, tutti e cinque i nodi sono completamente connessi.
Bene! Ora lasciami venire qui dall'altro Uno. Sono andato all'altro? Questo. Bene! Dirò statistiche ok. Tutti e cinque sto parlando con tutti e cinque qui, come puoi vedere, l'attività sta avvenendo su tutti loro e dirò che i monitor tutti e cinque stanno accadendo qui.
Conclusione
Quindi, siamo passati dall'avere un cluster sano all'avere una divisione per avere di nuovo un cluster sano. E possiamo vedere che, anche qui, abbiamo un cluster a cinque nodi. Quindi, questa è praticamente la fine di questa demo. Per favore, vai avanti e giocaci NCache e vedi che con il ripristino del cervello diviso, hai questa capacità aggiuntiva di alta disponibilità.