Vi suggeriu di leghje a trascrizione di a lezione "Hadoop. ZooKeeper" da a serie "Metodi per u processu distribuitu di grandi volumi di dati in Hadoop"
Cosa hè ZooKeeper, u so postu in l'ecosistema Hadoop. Untruths nantu à l'informatica distribuita. Schema di un sistema distribuitu standard. Difficultà in a coordinazione di sistemi distribuiti. Problemi tipici di coordinazione. I principii daretu à u disignu di ZooKeeper. U mudellu di dati ZooKeeper. bandiere znode. Sessioni. Client API. Primitive (configurazione, appartenenza à u gruppu, chjusi simplici, elezzione di capu, chjusi senza effettu di mandria). L'architettura di ZooKeeper. ZooKeeper DB. ZAB. Gestore di dumanda.
Oghje parlemu di ZooKeeper. Sta cosa hè assai utile. Hè, cum'è qualsiasi pruduttu Apache Hadoop, hà un logò. Rapprisenta un omu.
Prima di questu, avemu parlatu principarmenti di cumu i dati ponu esse processati quì, cumu per almacenà, vale à dì, cumu aduprà in qualchì manera è travaglià cun ellu in qualchì manera. È oghje vogliu parlà un pocu di custruisce applicazioni distribuite. È ZooKeeper hè una di queste cose chì vi permette di simplificà sta materia. Questu hè un tipu di serviziu chì hè destinatu à qualchì tipu di coordinazione di l'interazzione di prucessi in sistemi distribuiti, in applicazioni distribuite.
U bisognu di tali appiicazioni hè sempre di più ogni ghjornu, hè ciò chì u nostru cursu hè tuttu. Da una banda, MapReduce è stu framework ready-made vi permette di livellà sta cumplessità è liberà u programatore da scrittura primitiva cum'è interazzione è coordinazione di prucessi. Ma d'altra parte, nimu ùn guarantisci chì questu ùn deve esse fattu in ogni modu. MapReduce o altri frameworks pronti ùn sò micca sempre rimpiazzati cumplettamente certi casi chì ùn ponu esse implementati cù questu. Includendu MapReduce stessu è una mansa di altri prughjetti Apache, in fattu, sò ancu appiicazioni distribuite. È per fà a scrittura più faciule, anu scrittu ZooKeeper.
Cum'è tutte l'applicazioni relative à Hadoop, hè statu sviluppatu da Yahoo! Avà hè ancu una applicazione ufficiale Apache. Ùn hè micca sviluppatu attivamente cum'è HBase. Se andate à JIRA HBase, allora ogni ghjornu ci sò una mansa di rapporti di bug, una mansa di pruposte per ottimisà qualcosa, vale à dì chì a vita in u prugettu hè in constantemente. È ZooKeeper, da una banda, hè un pruduttu relativamente simplice, è da l'altra banda, questu assicura a so affidabilità. È hè abbastanza faciule d'utilizà, per quessa hè diventatu un standard in l'applicazioni in l'ecosistema Hadoop. Allora aghju pensatu chì saria utile di rivisione per capisce cumu funziona è cumu aduprà.
Questa hè una foto di qualchì lezzione chì avemu avutu. Pudemu dì chì hè ortugonale à tuttu ciò chì avemu cunsideratu finu à avà. È tuttu ciò chì hè indicatu quì, à un gradu o un altru, travaglia cù ZooKeeper, vale à dì, hè un serviziu chì usa tutti questi prudutti. Nè HDFS nè MapReduce scrivenu i so servizii simili chì anu da travaglià specificamente per elli. Per quessa, ZooKeeper hè adupratu. È questu simplifica u sviluppu è alcune cose ligati à l'errori.
Da induve vene tuttu questu? Sembra chì avemu lanciatu duie applicazioni in parallelu in diversi computer, cunnessu cù una corda o in una maglia, è tuttu funziona. Ma u prublema hè chì a Rete ùn hè micca affidabile, è s'è vo sniffed u trafficu o fighjulà ciò chì succede quì à un livellu bassu, cumu i clienti interagiscenu nantu à a Rede, pudete spessu vede chì certi pacchetti sò persi o rinviati. Ùn hè micca per nunda chì i protokolli TCP sò stati inventati, chì permettenu di stabilisce una certa sessione è guarantisci a spedizione di missaghji. Ma in ogni casu, ancu TCP ùn pò micca sempre salvà. Tuttu hà un timeout. A reta pò solu falà per un tempu. Puderia solu lampà. È questu tuttu porta à u fattu chì ùn pudete micca cunfidendu chì a Rete hè affidabile. Questa hè a principal diferenza di scrittura appiicazioni parallele chì eseguite nantu à un computer o in un supercomputer, induve ùn ci hè micca Rete, induve ci hè un busu di scambiu di dati più affidabile in memoria. È questu hè una diferenza fundamentale.
Frà altre cose, quandu si usa a Rete, ci hè sempre una certa latenza. U discu hà ancu, ma a Rete hà più. A latenza hè qualchì tempu di ritardu, chì pò esse chjucu o abbastanza significativu.
A topologia di a rete hè cambiata. Cosa hè a topologia - questu hè u locu di u nostru equipamentu di rete. Ci sò centri di dati, ci sò racks chì stanu quì, ci sò candele. Tuttu chistu pò esse reconnected, spustatu, etc Stu tuttu ci vole dinù esse pigliatu in contu. I nomi IP cambianu, l'itinerariu attraversu quale u nostru trafficu viaghja cambia. Questu hè ancu deve esse cunsideratu.
A reta pò ancu cambià in quantu à l'equipaggiu. Da a pratica, possu dì chì i nostri ingegneri di rete piacenu veramente aghjurnà periodicamente qualcosa nantu à e candele. Di colpu un novu firmware hè ghjuntu è ùn anu micca particularmente interessatu in qualchi cluster Hadoop. Hanu u so propiu travagliu. Per elli, u principale hè chì a Rete travaglia. In cunsiquenza, volenu ripiglià qualcosa quì, fate un lampatu nantu à u so hardware, è u hardware cambia ancu periòdicamente. Tuttu chistu di qualchì manera deve esse cunsideratu. Tuttu chistu affetta a nostra applicazione distribuita.
Di solitu e persone chì cumincianu à travaglià cù grandi quantità di dati per una certa ragione crede chì Internet hè illimitatu. Se ci hè un schedariu di parechji terabytes, allora pudete piglià à u vostru servitore o l'urdinatore è apre u usu gattu è fighjate. Un altru errore hè in Vim fighjate à i logs. Ùn fate mai questu perchè hè male. Perchè Vim prova di buffer tuttu, carica tuttu in memoria, soprattuttu quandu avemu cuminciatu à passà per questu logu è circà qualcosa. Quessi sò cose chì sò scurdate, ma vale a pena cunsiderà.
Hè più faciule per scrive un prugramma chì corre nantu à un computer cun un processore.
Quandu u nostru sistema cresce, vulemu parallelizà tuttu, è parallelize micca solu in un computer, ma ancu in un cluster. A quistione hè: cumu coordina sta materia? I nostri appricazzioni ùn ponu ancu interagisce cù l'altri, ma avemu eseguitu parechji prucessi in parallelu in parechji servitori. E cumu monitorà chì tuttu va bè per elli? Per esempiu, mandanu qualcosa nantu à Internet. Hanu da scrive nantu à u so statu in un locu, per esempiu, in un tipu di basa di dati o logu, dopu aggregate stu logu è poi analizà in un locu. In più, ci vole à piglià in contu chì u prucessu era u travagliu è u travagliu, di colpu un errore apparsu in ellu o s'hè lampatu, allora quantu prestu scopremu?
Hè chjaru chì tuttu questu pò esse monitoratu rapidamente. Questu hè ancu bonu, ma u monitoraghju hè una cosa limitata chì vi permette di monitorà alcune cose à u più altu livellu.
Quandu vulemu chì i nostri prucessi cumincianu à interagisce cù l'altri, per esempiu, per mandà un pocu di dati, allora a quistione hè ancu - cumu serà questu? Ci sarà un tipu di cundizione di razza, si sovrascriveranu l'un l'altru, i dati ghjunghjeranu currettamente, qualcosa serà persu in a strada? Avemu bisognu di sviluppà un tipu di protocolu, etc.
A coordinazione di tutti sti prucessi ùn hè micca una cosa triviale. È furzà u sviluppatore à falà à un livellu ancu più bassu, è scrive sistemi sia da zero, o micca abbastanza da zero, ma questu ùn hè micca cusì simplice.
Se vi vene cun un algoritmu criptograficu o ancu implementà, allora scaccià immediatamente, perchè assai prubabilmente ùn hà micca travagliatu per voi. Hè prubabilmente cuntene una mansa di errori chì avete scurdatu di furnisce. Ùn aduprate mai per qualcosa di seriu perchè probabilmente serà inestabile. Perchè tutti l'algoritmi chì esistenu sò stati pruvati da u tempu per un tempu assai longu. Hè bugged da a cumunità. Questu hè un tema separatu. È hè u listessu quì. Se ùn hè micca pussibule di implementà un certu tipu di sincronizazione di u prucessu stessu, allora hè megliu ùn fà micca questu, perchè hè abbastanza cumplicatu è vi porta in a strada tremula di a ricerca constantemente di l'errori.
Oghje parlemu di ZooKeeper. Da una banda, hè un quadru, da l'altra parte, hè un serviziu chì facilita a vita di u sviluppatore è simplificà l'implementazione di a logica è a coordinazione di i nostri prucessi quant'è pussibule.
Ricurdemu ciò chì un sistema distribuitu standard puderia esse. Hè ciò chì avemu parlatu - HDFS, HBase. Ci hè un prucessu Maestru chì gestisce i travaglii è i prucessi slave. Hè rispunsevuli di a coordinazione è a distribuzione di i travaglii, di riavvià i travagliadori, di lancià novi, è di distribuzione di a carica.
Una cosa più avanzata hè u Serviziu di Coordinazione, vale à dì, move u compitu di coordinazione stessu in un prucessu separatu, più eseguisce qualchì tipu di backup o stanby Master in parallelu, perchè u Maestru pò fallu. È se u Maestru cade, allora u nostru sistema ùn hà micca travagliatu. Facemu una copia di salvezza. Certi stati chì u Maestru hà bisognu à esse replicatu à a copia di salvezza. Questu pò ancu esse affidatu à u Serviziu di Coordinazione. Ma in questu schema, u Maestru stessu hè rispunsevuli di a coordinazione di i travagliadori quì u serviziu hè a coordinazione di l'attività di replicazione di dati.
Una opzione più avanzata hè quandu tutta a coordinazione hè trattata da u nostru serviziu, cum'è di solitu. Piglia a rispunsabilità per assicurà chì tuttu funziona. È s'ellu ùn viaghja micca qualcosa, avemu da scopre è pruvate d'attraversà sta situazione. In ogni casu, simu lasciati cun un Maestru chì in qualchì modu interagisce cù i schiavi è ponu mandà dati, informazioni, missaghji, etc.
Ci hè un schema ancu più avanzatu, quandu ùn avemu micca un Maestru, tutti i nodi sò schiavi maestri, diffirenti in u so cumpurtamentu. Ma anu sempre bisognu di interagisce cù l'altri, cusì ci hè sempre un pocu di serviziu per cuurdinà queste azzioni. Probabilmente, Cassandra, chì travaglia nantu à stu principiu, si adatta à stu schema.
Hè difficiuli di dì quale di sti schemi funziona megliu. Ognunu hà i so pros è cuns.
È ùn ci hè bisognu di teme di qualchi cose cù u Maestru, perchè, cum'è a pratica mostra, ùn hè micca cusì suscettibile à serve constantemente. A cosa principal quì hè di sceglie a suluzione ghjusta per l'ospitu di stu serviziu nantu à un node putente separatu, per ch'ellu hà abbastanza risorse, per chì, s'ellu hè pussibule, l'utilizatori ùn anu micca accessu, per ùn avè micca accidentalmente tumbà stu prucessu. Ma à u listessu tempu, in un tali schema hè assai più faciuli di gestisce i travagliadori da u prucessu Maestru, vale à dì stu schema hè più simplice da u puntu di vista di l'implementazione.
È questu schema (sopra) hè probabilmente più cumplessu, ma più affidabile.
U prublema principali hè fallimentu parziale. Per esempiu, quandu avemu mandatu un missaghju nantu à a Rete, un tipu d'accidente accade, è quellu chì hà mandatu u missaghju ùn sapi micca se u so messagiu hè statu ricevutu è ciò chì hè accadutu da u latu di u receptore, ùn sapi micca se u missaghju hè statu trattatu bè. , vale à dì ùn riceverà alcuna cunferma.
Per quessa, avemu da trattà sta situazione. È a cosa più simplice hè di rinvià stu missaghju è aspittà finu à chì avemu ricevutu una risposta. In questu casu, ùn hè micca cunsideratu se u statu di u receptore hà cambiatu. Pudemu mandà un missaghju è aghjunghje i stessi dati duie volte.
ZooKeeper offre manere di trattà cun tali rifiuti, chì rende ancu a nostra vita più faciule.
Comu diciatu un pocu prima, questu hè simili à scrive prugrammi multi-threaded, ma a principal diferenza hè chì in l'applicazioni distribuite chì custruemu nantu à diverse macchine, l'unicu modu per cumunicà hè a Rete. Essenzialmente, questa hè una architettura di nulla spartutu. Ogni prucessu o serviziu chì corre nantu à una macchina hà a so propria memoria, u so propiu discu, u so propiu processatore, chì ùn sparte micca cù nimu.
Sè avemu scriviri un prugrammu multi-threaded nant'à un urdinatore, allura putemu aduprà a memoria spartutu à scambià dati. Avemu un cambiamentu di cuntestu quì, i prucessi ponu cambià. Questu influenza u rendiment. Da una banda, ùn ci hè micca cusì in u prugramma nantu à un cluster, ma ci sò prublemi cù a Rete.
In cunsiquenza, i prublemi principali chì nascenu quandu scrive sistemi distribuiti sò cunfigurazione. Scrivemu un tipu d'applicazione. S'ellu hè simplice, allora codificamu ogni tipu di numeri in u codice, ma questu hè inconveniente, perchè se decidemu chì invece di un timeout di a mità di seconda vulemu un timeout di un secondu, allora avemu bisognu di recompilà l'applicazione è rollu tuttu fora di novu. Hè una cosa quandu hè nantu à una macchina, quandu pudete solu riavvia, ma quandu avemu parechje macchine, avemu da copià constantemente tuttu. Avemu da pruvà à fà l'applicazione configurable.
Quì parlemu di cunfigurazione statica per i prucessi di u sistema. Questu ùn hè micca sanu, forse da u puntu di vista di u sistema upirativu, pò esse una cunfigurazione statica per i nostri prucessi, vale à dì, questa hè una cunfigurazione chì ùn pò micca esse solu presa è aghjurnata.
Ci hè ancu una cunfigurazione dinamica. Quessi sò i paràmetri chì vulemu cambià nantu à a mosca per ch'elli sò cullati quì.
Chì ci hè u prublema quì ? Avemu aghjurnatu a cunfigurazione, l'avemu lanciata, allora chì? U prublema pò esse chì da una banda avemu rollu fora a cunfigurazione, ma scurdatu di a cosa nova, a cunfigurazione ferma quì. Siconda, mentre stavamu stendu, a cunfigurazione hè stata aghjurnata in certi lochi, ma micca in altri. È certi prucessi di a nostra applicazione chì eseguite nantu à una macchina sò stati riavviati cù una nova cunfigurazione, è in qualchì locu cù una vechja. Questu pò esse risultatu in a nostra applicazione distribuita inconsistente da una perspettiva di cunfigurazione. Stu prublema hè cumuni. Per una cunfigurazione dinamica, hè più pertinente perchè implica chì pò esse cambiatu nantu à a mosca.
Un altru prublema hè l'appartenenza à u gruppu. Avemu sempre qualchì gruppu di travagliadori, vulemu sempre sapè quale di elli hè vivu, quale hè mortu. S'ellu ci hè un Maestru, allora deve capisce chì i travagliadori ponu esse ridiretti à i clienti in modu chì eseguinu calculi o travaglià cù dati, è quale ùn pò micca. Un prublema chì si sviluppa constantemente hè chì avemu bisognu di sapè quale travaglia in u nostru cluster.
Un altru prublema tipica hè l'elezzioni di capu, quandu vulemu sapè quale hè u capu. Un esempiu hè a replicazione, quandu avemu qualchì prucessu chì riceve l'operazioni di scrittura è poi li replica trà altri prucessi. Serà u capu, tutti l'altri ubbidiscenu, u seguitaranu. Hè necessariu di sceglie un prucessu in modu chì ùn sia micca ambiguu per tutti, per ùn esce micca chì dui capi sò scelti.
Ci hè ancu un accessu mutualmente esclusivu. U prublema quì hè più cumplessu. Ci hè una cosa cum'è un mutex, quandu scrivite prugrammi multi-threaded è vulete accessu à qualchì risorsa, per esempiu, una cellula di memoria, per esse limitata è realizatu da un solu filu. Quì a risorsa puderia esse qualcosa più astratta. E diverse applicazioni da i diversi nodi di a nostra Rete duveranu riceve solu accessu esclusivu à una risorsa data, è micca cusì chì ognunu pò cambià o scrive qualcosa quì. Quessi sò i cosiddetti chjusi.
ZooKeeper permette di risolve tutti questi prublemi à un gradu o un altru. È vi mustraraghju cù esempi cumu vi permette di fà questu.
Ùn ci sò micca primitivi bluccanti. Quandu avemu principiatu à aduprà qualcosa, stu primitivu ùn aspittà micca chì ogni avvenimentu accade. Hè assai prubabile, sta cosa hà da travaglià in modu asincronu, permettendu cusì chì i prucessi ùn si fermanu micca mentre aspettanu qualcosa. Questu hè una cosa assai utile.
Tutte e dumande di i clienti sò trattate in l'ordine di a fila generale.
È i clienti anu l'uppurtunità di riceve notificazioni nantu à i cambiamenti in qualchì statu, nantu à i cambiamenti di dati, prima chì u cliente vede i dati cambiati stessi.
ZooKeeper pò funziunà in dui modi. U primu hè autonomu, nantu à un solu nodu. Questu hè cunveniente per e prove. Pò ancu funziunà in modu cluster, nantu à qualsiasi numeru di nodi. servitoriSè avemu un cluster di 100 macchine, ùn hè micca necessariamente necessariu chì funziona nantu à 100 macchine. Basta à assignà uni pochi di macchine induve ZooKeeper pò funziona. È rispetta u principiu di l'alta dispunibilità. ZooKeeper conserva una copia cumpleta di i dati nantu à ogni istanza in esecuzione. Spiegheraghju cumu face questu dopu. Ùn spartisce nè partiziona i dati. Da una parte, questu hè un svantaghju perchè ùn pudemu micca almacenà assai, ma da l'altra parte, ùn hè micca necessariu. Ùn hè micca cuncipitu per quessa; ùn hè micca una basa di dati.
Dati ponu esse cache in u latu di u cliente. Questu hè un principiu standard per ùn interrompe micca u serviziu è ùn caricate micca cù e stesse richieste. Un client intelligente di solitu sapi di questu è u cache.
Per esempiu, qualcosa hè cambiatu quì. Ci hè un tipu d'applicazione. Hè statu elettu un novu capu, chì hè rispunsevuli, per esempiu, di trasfurmà e operazioni di scrittura. È vulemu riplicà e dati. Una suluzione hè di mette in un ciclu. E dumandemu constantemente u nostru serviziu - hè cambiatu qualcosa? A seconda opzione hè più ottima. Questu hè un mecanismu di vigilanza chì vi permette di avvisà i clienti chì qualcosa hà cambiatu. Questu hè un metudu menu caru in termini di risorse è più convenientu per i clienti.
U cliente hè l'utilizatore chì usa ZooKeeper.
Server hè u prucessu ZooKeeper stessu.
Znode hè a cosa chjave in ZooKeeper. Tutti i znodes sò guardati in memoria da ZooKeeper è sò urganizati in a forma di un diagramma gerarchicu, in a forma di un arbre.
Ci sò dui tipi di operazioni. U primu hè aghjurnamentu / scrittura, quandu qualchì operazione cambia u statu di u nostru arbre. L'arburu hè cumuni.
È hè pussibule chì u cliente ùn compie micca una dumanda è hè disconnected, ma pò stabilisce una sessione per quale interagisce cù ZooKeeper.
U mudellu di dati di ZooKeeper s'assumiglia à un sistema di schedari. Ci hè una radica standard è poi andemu cum'è per i cartulari chì vanu da a ràdica. E poi u catalogu di u primu livellu, secondu livellu. Questu hè tuttu znodes.
Ogni znode pò almacenà qualchi dati, di solitu micca assai grande, per esempiu, 10 kilobytes. È ogni znode pò avè un certu numaru di zitelli.
Znodes venenu in parechji tipi. Puderanu esse creati. È quandu creanu un znode, spicificà u tipu à quale deve appartene.
Ci sò dui tipi. U primu hè a bandiera effimera. Znode vive in una sessione. Per esempiu, u cliente hà stabilitu una sessione. È mentre sta sessione hè viva, esisterà. Questu hè necessariu per ùn pruduce qualcosa innecessariu. Questu hè ancu adattatu per i mumenti quandu hè impurtante per noi di almacenà e dati primitivi in una sessione.
U sicondu tipu hè bandiera sequenziale. Incrementa u contatore in a strada di u znode. Per esempiu, avemu avutu un repertoriu cù l'applicazione 1_5. È quandu avemu creatu u primu node, hà ricevutu p_1, u sicondu - p_2. È quandu chjamemu stu metudu ogni volta, passemu u percorsu sanu, indicà solu una parte di u percorsu, è questu numeru hè automaticamente incrementatu perchè indicà u tipu di node - sequential.
znode regulare. Ella vivrà sempre è averà u nome chì li dicemu.
Un'altra cosa utile hè a bandiera di u watch. Se l'installemu, allora u cliente pò subscribe à certi avvenimenti per un node specificu. Vi mustraraghju più tardi cun un esempiu cumu si faci questu. ZooKeeper stessu notifica à u cliente chì e dati nantu à u node anu cambiatu. Tuttavia, e notificazioni ùn guarantisci micca chì alcune novi dati sò ghjunti. Dicenu simpricimenti chì qualcosa hè cambiatu, cusì avete sempre à paragunà dati dopu cù chjamati separati.
E cum'è aghju dettu, l'ordine di e dati hè determinatu da kilobytes. Ùn ci hè bisognu di almacenà e grande dati di testu quì, perchè ùn hè micca una basa di dati, hè un servitore di coordinazione d'azzione.
Lasciami dì ti un pocu di e sessioni. Sè avemu parechji servitori, pudemu cambià in modu trasparente da un servitore à l'altru. servitore, aduprendu l'ID di sessione. Questu hè abbastanza cunveniente.
Ogni sessione hà un tipu di timeout. Una sessione hè definita da se u cliente manda qualcosa à u servitore durante quella sessione. S'ellu ùn hà micca trasmessu nunda durante u timeout, a sessione casca, o u cliente pò chjude ellu stessu.
Ùn hà micca tanti funziunalità, ma pudete fà cose diverse cù questa API. Questa chjama chì avemu vistu creà crea un znode è piglia trè paràmetri. Questu hè u percorsu à u znode, è deve esse specificatu in tuttu da a radica. È ancu questu hè qualchi dati chì vulemu trasfiriri quì. È u tipu di bandiera. È dopu a creazione torna a strada à u znode.
Siconda, pudete sguassà. U truccu quì hè chì u sicondu paràmetru, in più di u percorsu à u znode, pò specificà a versione. Dunque, quellu znode serà sguassatu se a so versione chì avemu trasferitu hè equivalente à quella chì esiste veramente.
Se ùn vulemu cuntrollà sta versione, allora passemu solu l'argumentu "-1".
Terzu, verifica l'esistenza di un znode. Ritorna true se u node esiste, false altrimenti.
È dopu apparisce u sguardu di bandiera, chì vi permette di monitorà stu node.
Pudete stabilisce sta bandiera ancu in un node inesistente è riceve una notificazione quandu appare. Questu pò ancu esse utile.
Un paru di più sfide sò getData. Hè chjaru chì pudemu riceve dati via znode. Tù dinù ponu aduprà flag watch. In questu casu, ùn installerà micca s'ellu ùn ci hè micca un node. Dunque, avete bisognu di capisce chì esiste, è dopu riceve dati.
Ci hè ancu SetData. Quì passemu a versione. E se passemu questu, i dati nantu à u znode di una certa versione seranu aghjurnati.
Pudete ancu specificà "-1" per escludiri stu cuntrollu.
Un altru mètudu utile hè uttene i zitelli. Pudemu ancu ottene una lista di tutti i znodes chì appartenenu. Pudemu monitorà questu mettendu a vigilazione di bandiera.
È u metudu sync permette à tutti i cambiamenti à esse mandatu in una volta, assicurendu cusì chì sò salvate è tutti i dati hè statu cumplettamente cambiatu.
Sè avemu tiratu analogie cù a prugrammazione regulare, allora quandu utilizate metudi cum'è scrive, chì scrive qualcosa à u discu, è dopu chì torna una risposta à voi, ùn ci hè micca garantitu chì avete scrittu i dati à u discu. E ancu quandu u sistema upirativu hè cunvinta chì tuttu hè statu scrittu, ci sò miccanismi in u discu stessu induve u prucessu passa per strati di buffers, è solu dopu chì i dati sò posti nantu à u discu.
A maiò parte di e chjama asincrone sò usate. Questu permette à u cliente di travaglià in parallelu cù e diverse richieste. Pudete utilizà l'approcciu sincronu, ma hè menu pruduttivu.
E duie operazioni chì avemu parlatu sò aghjurnamentu / scrittura, chì cambianu dati. Quessi sò create, setData, sync, delete. E leghje hè esiste, getData, getChildren.
Avà uni pochi di esempi di cumu pudete fà primitivi per travaglià in un sistema distribuitu. Per esempiu, in relazione à a cunfigurazione di qualcosa. Un novu travagliadore hè apparsu. Avemu aghjustatu a macchina è hà cuminciatu u prucessu. È ci sò e trè dumande seguenti. Cumu dumanda à ZooKeeper per a cunfigurazione? E se vulemu cambià a cunfigurazione, cumu si cambia? È dopu chì l'avemu cambiatu, cumu si facenu quelli travagliadori chì avemu avutu?
ZooKeeper rende questu relativamente faciule. Per esempiu, ci hè u nostru arbulu znode. Ci hè un node per a nostra applicazione quì, creamu un node supplementu in questu, chì cuntene dati da a cunfigurazione. Quessi ponu esse o micca paràmetri separati. Siccomu a dimensione hè chjuca, a dimensione di cunfigurazione hè di solitu ancu chjuca, cusì hè abbastanza pussibule di guardà quì.
Avete aduprà u metudu getData pè ottene a cunfigurazione per u travagliu da u node. Set à veru. Sè per qualchi ragiuni stu node ùn esiste micca, avemu da esse infurmatu quandu si prisenta, o quandu si cambia. Se vulemu sapè chì qualcosa hè cambiatu, allora l'avemu stabilitu à veru. E se i dati in questu node cambianu, avemu da sapè.
SetData. Avemu stabilitu i dati, stabilitu "-1", vale à dì ùn cuntrollamu micca a versione, assumemu chì avemu sempre una cunfigurazione, ùn avemu micca bisognu di guardà parechje cunfigurazioni. Sè avete bisognu di almacenà assai, vi tuccherà à aghjunghje un altru livellu. Quì cridemu chì ci hè solu unu, cusì aghjurnà solu l'ultimu, perchè ùn cuntrollamu micca a versione. À questu mumentu, tutti i clienti chì anu abbonatu prima ricevenu una notificazione chì qualcosa hà cambiatu in questu node. È dopu avè ricivutu, anu da dumandà dinò i dati. A notificazione hè chì ùn ricevenu micca i dati stessu, ma solu notificazione di cambiamenti. Dopu questu, anu da dumandà novi dati.
A seconda opzione per aduprà u primitivu hè appartenenza à u gruppu. Avemu una applicazione distribuita, ci sò una mansa di travagliadori è vulemu capisce chì sò tutti in u locu. Dunque, anu da esse registratu chì travaglianu in a nostra applicazione. È vulemu ancu sapè, sia da u prucessu Maestru sia in altrò, nantu à tutti i travagliadori attivi chì avemu avà.
Cumu facemu questu? Per l'applicazione, creemu un nodu di u travagliu è aghjunghje un sublivellu cù u metudu di creazione. Aghju un errore nantu à a slide. Quì avete bisognu sequenziale specificà, allora tutti i travagliadori seranu creati unu per unu. È l'applicazione, dumandendu tutte e dati nantu à i zitelli di stu node, riceve tutti i travagliadori attivi chì esistenu.
Questa hè una implementazione cusì terribile di cumu si pò esse fattu in codice Java. Accuminciamu da a fine, cù u metudu principale. Questa hè a nostra classe, creemu u so metudu. Cum'è u primu argumentu usemu l'ospite, induve ci cunnettamu, vale à dì l'avemu stabilitu cum'è un argumentu. È u sicondu argumentu hè u nome di u gruppu.
Cumu hè a cunnessione? Questu hè un esempiu simplice di l'API chì hè utilizatu. Tuttu hè relativamente simplice quì. Ci hè una classa standard ZooKeeper. Passemu l'ospiti. È stabilisce u timeout, per esempiu, à 5 seconde. È avemu un membru chjamatu ConnectedSignal. Essenzialmente, creemu un gruppu longu u percorsu trasmessu. Ùn avemu micca scrittu dati quì, ancu s'ellu si pudia esse scrittu qualcosa. È u node quì hè di u tipu persistente. Essenzialmente, questu hè un node regulare ordinariu chì esisterà tuttu u tempu. Questu hè induve a sessione hè creata. Questu hè l'implementazione di u cliente stessu. U nostru cliente mandarà missaghji periodichi chì indicanu chì a sessione hè viva. È quandu avemu finitu a sessione, chjamemu vicinu è questu hè, a sessione casca. Questu hè in casu chì qualcosa casca per noi, cusì chì ZooKeeper scopre nantu à questu è taglia a sessione.
Cumu chjude una risorsa? Quì tuttu hè un pocu più complicatu. Avemu un inseme di travagliadori, ci hè qualchì risorsa chì vulemu chjude. Per fà questu, creamu un node separatu, per esempiu, chjamatu lock1. S'è no pudemu crià, allora avemu un serratura quì. E s'è no puderemu crià, allura u travagliadore prova à ottene getData da quì, è postu chì u node hè digià statu creatu, allora avemu messu un watcher quì è u mumentu chì u statu di stu node cambia, avemu da sapè. È pudemu pruvà à avè u tempu per ricreà. Se avemu pigliatu stu node, hà pigliatu questu serratura, dopu chì ùn avemu più bisognu di u serratura, l'abbanduneremu, postu chì u node esiste solu in a sessione. Per quessa, sparirà. È un altru cliente, in u quadru di una altra sessione, puderà piglià a serratura nantu à questu node, o più bè, riceverà una notificazione chì qualcosa hà cambiatu è pò pruvà à fà in u tempu.
Un altru esempiu di cumu pudete sceglie u capu principale. Questu hè un pocu più cumplicatu, ma ancu relativamente simplice. Chì si passa quì ? Ci hè un node principale chì aggrega tutti i travagliadori. Cerchemu di ottene dati nantu à u capu. S'ellu hè successu successu, vale à dì avemu ricevutu qualchi dati, allura u nostru travagliadori principia à seguità stu capu. Credu chì ci hè digià un capu.
Se u capu hè mortu per qualchì mutivu, per esempiu, hè cascatu, allora pruvemu di creà un novu capu. È s'è no riesci, allura u nostru travagliadori diventa u capu. È se qualchissia in questu mumentu hà sappiutu di creà un novu capu, allora avemu da pruvà à capisce quale hè è poi seguità.
Quì nasce u chjamatu effettu di mandria, vale à dì l'effettu di mandria, perchè quandu un capu mori, quellu chì hè u primu in u tempu diventerà u capu.
Quandu pigliate una risorsa, pudete pruvà à utilizà un accostu ligeramente sfarente, chì hè a siguenti. Per esempiu, vulemu ottene una serratura, ma senza l'effettu hert. Consisterà in u fattu chì a nostra applicazione dumanda liste di tutti l'ID di node per un node digià esistente cù un serratura. E se prima chì u node per quale avemu creatu un serratura hè u più chjucu di u settore chì avemu ricevutu, allora questu significa chì avemu captu u serratura. Avemu verificatu chì avemu ricevutu un serratura. Comu verificatu, ci sarà una cundizione chì l'id chì avemu ricevutu quandu creanu un novu serratura hè minimu. È se l'avemu ricevutu, allora avemu travagliatu più.
Se ci hè un certu ID chì hè più chjucu di u nostru serratura, allora mettemu un observatore nantu à questu avvenimentu è aspittemu a notificazione finu à chì qualcosa cambia. Vale à dì, avemu ricevutu stu serratura. È finu à ch'ella casca, ùn diventeremu micca l'ID minimu è ùn riceveranu micca u serratura minimu, è cusì pudemu login. È se sta cundizione ùn hè micca scontru, allora andemu subitu quì è pruvate à ottene sta serratura di novu, perchè qualcosa puderia avè cambiatu in questu tempu.
In chì consiste ZooKeeper? Ci sò 4 cose principali. Questu hè processi di trasfurmazioni - Request. È ancu ZooKeeper Atomic Broadcast. Ci hè un Commit Log induve tutte e operazioni sò registrate. È a DB replicata in memoria stessu, vale à dì a basa di dati stessu induve stu arbulu tutale hè almacenatu.
Hè da nutà chì tutte l'operazioni di scrittura passanu per u Processore di Richiesta. È l'operazioni di lettura vanu direttamente à a basa di dati in memoria.
A basa di dati stessu hè cumpletamente replicata. Tutti i casi di ZooKeeper guardanu una copia cumpleta di e dati.
Per restaurà a basa di dati dopu un crash, ci hè un logu di Cummissione. A pràtica standard hè chì prima chì i dati entranu in memoria, hè scrittu quì per chì, s'ellu si crash, stu logu pò esse ghjucatu è u statu di u sistema pò esse restauratu. E snapshots periodichi di a basa di dati sò ancu utilizati.
ZooKeeper Atomic Broadcast hè una cosa chì hè utilizata per mantene e dati replicati.
ZAB internamente selezziunate un capu da u puntu di vista di u node ZooKeeper. Altri nodi diventanu i so seguitori è aspettanu alcune azzioni da ella. S'elli ricevenu entrate, li trasmettenu tutti à u capu. Prima eseguisce una operazione di scrittura è poi manda un missaghju nantu à ciò chì hà cambiatu à i so seguitori. Questu, in fattu, deve esse realizatu atomicamente, vale à dì l'operazione di registrazione è di trasmissione di tuttu ciò chì deve esse realizatu atomicamente, guarantiscenu cusì a cunsistenza di e dati.
Prucessa solu e dumande di scrittura. U so compitu principale hè di trasfurmà l'operazione in un aghjurnamentu transazzione. Questa hè una dumanda generata apposta.
È quì vale a pena nutà chì l'idempotenza di l'aghjurnamenti per a listessa operazione hè garantita. Chì ghjè ? Questa cosa, se eseguita duie volte, averà u listessu statu, vale à dì chì a dumanda stessu ùn cambia micca. È questu deve esse fattu per chì in casu di crash, pudete ripiglià l'operazione, rinviendu cusì i cambiamenti chì sò caduti in u mumentu. In questu casu, u statu di u sistema diventerà u stessu, vale à dì ùn deve esse u casu chì una seria di u stessu, per esempiu, prucessi di aghjurnamentu, hà purtatu à diverse stati finali di u sistema.
Source: www.habr.com
