Când ai cântare Sber. Folosind Ab Initio cu Hive și GreenPlum

Cu ceva timp în urmă, ne-am confruntat cu problema alegerii unui instrument ETL pentru lucrul cu Big Data. Soluția Informatica BDM folosită anterior nu ni s-a potrivit din cauza funcționalității limitate. Utilizarea sa a fost redusă la un cadru pentru lansarea comenzilor spark-submit. Pe piață nu erau mulți analogi care să fie, în principiu, capabili să lucreze cu volumul de date cu care ne confruntăm în fiecare zi. La final am ales Ab Initio. În timpul demonstrațiilor pilot, produsul a arătat o viteză foarte mare de procesare a datelor. Aproape că nu există informații despre Ab Initio în limba rusă, așa că am decis să vorbim despre experiența noastră pe Habré.

Ab Initio are multe transformări clasice și neobișnuite, al căror cod poate fi extins folosind propriul limbaj PDL. Pentru o afacere mică, un instrument atât de puternic va fi probabil exagerat, iar majoritatea capacităților sale pot fi costisitoare și neutilizate. Dar dacă scara ta este aproape de cea a lui Sberov, atunci Ab Initio poate fi interesant pentru tine.

Ajută o afacere să acumuleze cunoștințe la nivel global și să dezvolte un ecosistem, iar un dezvoltator să-și îmbunătățească abilitățile în ETL, să-și îmbunătățească cunoștințele în shell, oferă posibilitatea de a stăpâni limbajul PDL, oferă o imagine vizuală a proceselor de încărcare și simplifică dezvoltarea datorită abundenţei componentelor funcţionale.

În această postare voi vorbi despre capacitățile Ab Initio și voi oferi caracteristici comparative ale lucrului său cu Hive și GreenPlum.

• Descrierea cadrului MDW și lucrul la personalizarea acestuia pentru GreenPlum
• Comparația performanței Ab Initio între Hive și GreenPlum
• Lucrul Ab Initio cu GreenPlum în modul în timp aproape real

Funcționalitatea acestui produs este foarte largă și necesită mult timp pentru studiu. Cu toate acestea, cu abilitățile de lucru adecvate și setările potrivite de performanță, rezultatele prelucrării datelor sunt foarte impresionante. Utilizarea Ab Initio pentru un dezvoltator poate oferi o experiență interesantă. Aceasta este o nouă interpretare a dezvoltării ETL, un hibrid între un mediu vizual și dezvoltarea de descărcare într-un limbaj asemănător unui script.

Companiile își dezvoltă ecosistemele și acest instrument este util mai mult ca niciodată. Cu Ab Initio, puteți acumula cunoștințe despre afacerea dvs. actuală și puteți utiliza aceste cunoștințe pentru a extinde afaceri vechi și a deschide noi afaceri. Alternativele la Ab Initio includ mediile de dezvoltare vizuală Informatica BDM și mediile de dezvoltare non-vizuală Apache Spark.

Descrierea Ab Initio

Ab Initio, ca și alte instrumente ETL, este o colecție de produse.

Ab Initio GDE (Graphical Development Environment) este un mediu pentru dezvoltator în care acesta configurează transformările de date și le conectează cu fluxurile de date sub formă de săgeți. În acest caz, un astfel de set de transformări se numește grafic:

Conexiunile de intrare și de ieșire ale componentelor funcționale sunt porturi și conțin câmpuri calculate în cadrul transformărilor. Mai multe grafice conectate prin fluxuri sub formă de săgeți în ordinea executării lor se numesc plan.

Există câteva sute de componente funcționale, ceea ce este mult. Multe dintre ele sunt foarte specializate. Capacitățile transformărilor clasice în Ab Initio sunt mai largi decât în ​​alte instrumente ETL. De exemplu, Join are mai multe ieșiri. Pe lângă rezultatul conectării seturilor de date, puteți obține înregistrări de ieșire ale seturilor de date de intrare ale căror chei nu au putut fi conectate. De asemenea, puteți obține respingeri, erori și un jurnal al operației de transformare, care poate fi citit în aceeași coloană ca un fișier text și procesat cu alte transformări:

Sau, de exemplu, puteți materializa un receptor de date sub forma unui tabel și puteți citi datele din acesta în aceeași coloană.

Există transformări originale. De exemplu, transformarea Scanare are o funcționalitate similară cu funcțiile analitice. Există transformări cu nume care se explică de la sine: Creare date, Citire Excel, Normalizare, Sortare în grupuri, Rulare program, Rulare SQL, Unire cu DB etc. Graficele pot folosi parametri de rulare, inclusiv posibilitatea de a trece parametri de la sau către sistemul de operare. Fișierele cu un set gata de parametri transmis graficului se numesc seturi de parametri (psets).

După cum era de așteptat, Ab Initio GDE are propriul său depozit numit EME (Enterprise Meta Environment). Dezvoltatorii au posibilitatea de a lucra cu versiuni locale de cod și de a verifica dezvoltările lor în depozitul central.

Este posibil, în timpul execuției sau după executarea graficului, să faceți clic pe orice flux care conectează transformarea și să priviți datele care au trecut între aceste transformări:

De asemenea, este posibil să dați clic pe orice flux și să vedeți detaliile de urmărire - câte paralele a funcționat transformarea, câte linii și octeți au fost încărcați în care dintre paralele:

Este posibil să împărțiți execuția graficului în faze și să marcați că unele transformări trebuie efectuate mai întâi (în faza zero), următoarele în prima fază, următoarele în a doua fază etc.

Pentru fiecare transformare, puteți alege așa-numitul layout (unde va fi executat): fără paralele sau în fire paralele, al căror număr poate fi specificat. În același timp, fișierele temporare pe care Ab Initio le creează atunci când se execută transformări pot fi plasate atât în ​​sistemul de fișiere server, cât și în HDFS.

În fiecare transformare, pe baza șablonului implicit, vă puteți crea propriul script în PDL, care este un pic ca un shell.

Cu PDL puteți extinde funcționalitatea transformărilor și, în special, puteți genera dinamic (în timpul rulării) fragmente de cod arbitrare în funcție de parametrii de rulare.

Ab Initio are, de asemenea, o integrare bine dezvoltată cu sistemul de operare prin shell. Mai exact, Sberbank folosește linux ksh. Puteți schimba variabile cu shell-ul și le puteți utiliza ca parametri grafici. Puteți apela execuția graficelor Ab Initio din shell și puteți administra Ab Initio.

Pe lângă Ab Initio GDE, multe alte produse sunt incluse în livrare. Există propriul său sistem de cooperare cu pretenția de a fi numit sistem de operare. Există un Control>Centru unde puteți programa și monitoriza fluxurile de descărcare. Există produse pentru dezvoltarea la un nivel mai primitiv decât permite Ab Initio GDE.

Descrierea cadrului MDW și lucrul la personalizarea acestuia pentru GreenPlum

Împreună cu produsele sale, furnizorul furnizează produsul MDW (Metadata Driven Warehouse), care este un configurator grafic conceput pentru a ajuta la sarcinile tipice de populare a depozitelor de date sau a seifurilor de date.

Conține analizatoare de metadate personalizate (specifice proiectului) și generatoare de cod gata făcute din cutie.

Ca intrare, MDW primește un model de date, un fișier de configurare pentru stabilirea unei conexiuni la o bază de date (Oracle, Teradata sau Hive) și alte setări. Partea specifică proiectului, de exemplu, implementează modelul într-o bază de date. Partea ieșită din cutie a produsului generează grafice și fișiere de configurare pentru acestea prin încărcarea datelor în tabele model. În acest caz, graficele (și pseturile) sunt create pentru mai multe moduri de inițializare și lucru incremental la actualizarea entităților.

În cazurile Hive și RDBMS, sunt generate diferite grafice pentru inițializare și actualizări incrementale ale datelor.

În cazul Hive, datele delta primite sunt conectate prin Ab Initio Join cu datele care erau în tabel înainte de actualizare. Încărcătoarele de date din MDW (atât în ​​Hive, cât și în RDBMS) nu numai că introduc date noi din deltă, ci și închid perioadele de relevanță ale datelor ale căror chei primare au primit delta. În plus, trebuie să rescrieți partea neschimbată a datelor. Dar acest lucru trebuie făcut deoarece Hive nu are operațiuni de ștergere sau actualizare.

În cazul RDBMS, graficele pentru actualizarea incrementală a datelor arată mai optim, deoarece RDBMS au capabilități reale de actualizare.

Delta primită este încărcată într-un tabel intermediar din baza de date. După aceasta, delta este conectată la datele care erau în tabel înainte de actualizare. Și acest lucru se face folosind SQL folosind o interogare SQL generată. Apoi, folosind comenzile SQL ștergere+inserare, date noi din delta sunt inserate în tabelul țintă și perioadele de relevanță ale datelor ale căror chei primare au primit delta sunt închise.
Nu este nevoie să rescrieți datele neschimbate.

Așa că am ajuns la concluzia că în cazul lui Hive, MDW trebuie să meargă să rescrie întregul tabel deoarece Hive nu are o funcție de actualizare. Și nimic mai bun decât rescrierea completă a datelor atunci când actualizarea a fost inventată. În cazul RDBMS, dimpotrivă, creatorii produsului au considerat necesar să încredințeze conectarea și actualizarea tabelelor utilizării SQL.

Pentru un proiect la Sberbank, am creat o nouă implementare reutilizabilă a unui încărcător de baze de date pentru GreenPlum. Acest lucru a fost realizat pe baza versiunii pe care MDW o generează pentru Teradata. Teradata, și nu Oracle, a fost cel mai aproape și cel mai bine pentru asta, pentru că... este, de asemenea, un sistem MPP. Metodele de lucru, precum și sintaxa, ale Teradata și GreenPlum s-au dovedit a fi similare.

Exemple de diferențe critice MDW între diferite RDBMS-uri sunt următoarele. În GreenPlum, spre deosebire de Teradata, atunci când creați tabele trebuie să scrieți o clauză

distributed by

Teradata scrie:

delete <table> all

, iar în GreenPlum scriu

delete from <table>

În Oracle, în scopuri de optimizare ei scriu

delete from t where rowid in (<соединение t с дельтой>)

, iar Teradata și GreenPlum scriu

delete from t where exists (select * from delta where delta.pk=t.pk)

De asemenea, observăm că pentru ca Ab Initio să funcționeze cu GreenPlum, a fost necesar să instalați clientul GreenPlum pe toate nodurile clusterului Ab Initio. Acest lucru se datorează faptului că ne-am conectat la GreenPlum simultan de la toate nodurile din clusterul nostru. Și pentru ca citirea din GreenPlum să fie paralelă și fiecare fir paralel Ab Initio să citească propria sa porțiune de date din GreenPlum, a trebuit să plasăm o construcție înțeleasă de Ab Initio în secțiunea „unde” a interogărilor SQL

where ABLOCAL()

si determinati valoarea acestei constructii prin specificarea citirii parametrilor din baza de date de transformare

ablocal_expr=«string_concat("mod(t.", string_filter_out("{$TABLE_KEY}","{}"), ",", (decimal(3))(number_of_partitions()),")=", (decimal(3))(this_partition()))»

, care se compilează la ceva de genul

mod(sk,10)=3

, adică trebuie să solicitați GreenPlum cu un filtru explicit pentru fiecare partiție. Pentru alte baze de date (Teradata, Oracle), Ab Initio poate efectua această paralelizare automat.

Comparația performanței Ab Initio între Hive și GreenPlum

Sberbank a efectuat un experiment pentru a compara performanța graficelor generate de MDW în raport cu Hive și în raport cu GreenPlum. Ca parte a experimentului, în cazul Hive au existat 5 noduri pe același cluster cu Ab Initio, iar în cazul GreenPlum au fost 4 noduri pe un cluster separat. Acestea. Hive a avut un avantaj hardware față de GreenPlum.

Am luat în considerare două perechi de grafice care efectuează aceeași sarcină de actualizare a datelor în Hive și GreenPlum. Totodată, au fost lansate graficele generate de configuratorul MDW:

• încărcare inițială + încărcare incrementală a datelor generate aleatoriu într-un tabel Hive
• încărcare inițială + încărcare incrementală a datelor generate aleatoriu în același tabel GreenPlum

În ambele cazuri (Hive și GreenPlum) au rulat încărcări pe 10 fire paralele pe același cluster Ab Initio. Ab Initio a salvat datele intermediare pentru calcule în HDFS (în ceea ce privește Ab Initio, a fost utilizată aspectul MFS folosind HDFS). O linie de date generate aleatoriu a ocupat 200 de octeți în ambele cazuri.

Rezultatul a fost cam acesta:

Stup:

Încărcarea inițială în Hive

Rânduri introduse
6 000 000
60 000 000
600 000 000

Durata de inițializare
descărcări în câteva secunde
41
203
1 601

Încărcare incrementală în Hive

Numărul de rânduri disponibile în
tabelul țintă la începutul experimentului
6 000 000
60 000 000
600 000 000

Numărul de linii delta aplicate
tabelul țintă în timpul experimentului
6 000 000
6 000 000
6 000 000

Durata incrementalului
descărcări în câteva secunde
88
299
2 541

GreenPlum:

Încărcarea inițială în GreenPlum

Rânduri introduse
6 000 000
60 000 000
600 000 000

Durata de inițializare
descărcări în câteva secunde
72
360
3 631

Încărcare incrementală în GreenPlum

Numărul de rânduri disponibile în
tabelul țintă la începutul experimentului
6 000 000
60 000 000
600 000 000

Numărul de linii delta aplicate
tabelul țintă în timpul experimentului
6 000 000
6 000 000
6 000 000

Durata incrementalului
descărcări în câteva secunde
159
199
321

Vedem că viteza de încărcare inițială atât în ​​Hive, cât și în GreenPlum depinde liniar de cantitatea de date și, din motive de hardware mai bun, este puțin mai rapidă pentru Hive decât pentru GreenPlum.

Încărcarea incrementală în Hive depinde, de asemenea, liniar de volumul datelor încărcate anterior disponibile în tabelul țintă și continuă destul de lent pe măsură ce volumul crește. Acest lucru este cauzat de necesitatea de a rescrie complet tabelul țintă. Aceasta înseamnă că aplicarea unor mici modificări la tabele uriașe nu este un caz de utilizare bun pentru Hive.

Încărcarea incrementală în GreenPlum depinde slab de volumul de date încărcate anterior disponibile în tabelul țintă și se desfășoară destul de repede. Acest lucru s-a întâmplat datorită SQL Joins și arhitecturii GreenPlum, care permite operația de ștergere.

Deci, GreenPlum adaugă delta folosind metoda ștergere+inserare, dar Hive nu are operații de ștergere sau actualizare, astfel încât întreaga matrice de date a fost forțată să fie rescrisă în întregime în timpul unei actualizări incrementale. Comparația celulelor evidențiate cu caractere aldine este cea mai revelatoare, deoarece corespunde celei mai comune opțiuni de utilizare a descărcărilor care necesită mult resurse. Vedem că GreenPlum l-a învins pe Hive în acest test de 8 ori.

Lucrul Ab Initio cu GreenPlum în modul în timp aproape real

În acest experiment, vom testa capacitatea lui Ab Initio de a actualiza tabelul GreenPlum cu bucăți de date generate aleatoriu în timp aproape real. Să luăm în considerare tabelul GreenPlum dev42_1_db_usl.TESTING_SUBJ_org_finval, cu care vom lucra.

Vom folosi trei grafice Ab Initio pentru a lucra cu el:

1) Graph Create_test_data.mp – creează fișiere de date în HDFS cu 10 de rânduri în 6 fire paralele. Datele sunt aleatorii, structura lor este organizată pentru inserarea în tabelul nostru

2) Graficul mdw_load.day_one.current.dev42_1_db_usl_testing_subj_org_finval.pset – graficul generat de MDW prin inițializarea inserării datelor în tabelul nostru în 10 fire paralele (se folosesc datele de testare generate de graficul (1))

3) Graficul mdw_load.regular.current.dev42_1_db_usl_testing_subj_org_finval.pset – un grafic generat de MDW pentru actualizarea incrementală a tabelului nostru în 10 fire paralele folosind o porțiune de date proaspăt primite (delta) generate de graficul (1)

Să rulăm scriptul de mai jos în modul NRT:

• genera 6 de linii de testare
• efectuați o încărcare inițială introduceți 6 de rânduri de testare într-un tabel gol
• repetați descărcarea incrementală de 5 ori
  • genera 6 de linii de testare
  • efectuați o inserare incrementală de 6 de rânduri de testare în tabel (în acest caz, timpul de expirare valid_to_ts este setat la datele vechi și sunt inserate date mai recente cu aceeași cheie primară)

Acest scenariu emulează modul de funcționare real al unui anumit sistem de afaceri - o parte destul de mare de date noi apar în timp real și este imediat turnată în GreenPlum.

Acum să ne uităm la jurnalul scriptului:

Începeți Create_test_data.input.pset la 2020-06-04 11:49:11
Terminați Create_test_data.input.pset la 2020-06-04 11:49:37
Începeți mdw_load.day_one.current.dev42_1_db_usl_testing_subj_org_finval.pset la 2020-06-04 11:49:37
Terminați mdw_load.day_one.current.dev42_1_db_usl_testing_subj_org_finval.pset la 2020-06-04 11:50:42
Începeți Create_test_data.input.pset la 2020-06-04 11:50:42
Terminați Create_test_data.input.pset la 2020-06-04 11:51:06
Începeți mdw_load.regular.current.dev42_1_db_usl_testing_subj_org_finval.pset la 2020-06-04 11:51:06
Terminați mdw_load.regular.current.dev42_1_db_usl_testing_subj_org_finval.pset la 2020-06-04 11:53:41
Începeți Create_test_data.input.pset la 2020-06-04 11:53:41
Terminați Create_test_data.input.pset la 2020-06-04 11:54:04
Începeți mdw_load.regular.current.dev42_1_db_usl_testing_subj_org_finval.pset la 2020-06-04 11:54:04
Terminați mdw_load.regular.current.dev42_1_db_usl_testing_subj_org_finval.pset la 2020-06-04 11:56:51
Începeți Create_test_data.input.pset la 2020-06-04 11:56:51
Terminați Create_test_data.input.pset la 2020-06-04 11:57:14
Începeți mdw_load.regular.current.dev42_1_db_usl_testing_subj_org_finval.pset la 2020-06-04 11:57:14
Terminați mdw_load.regular.current.dev42_1_db_usl_testing_subj_org_finval.pset la 2020-06-04 11:59:55
Începeți Create_test_data.input.pset la 2020-06-04 11:59:55
Terminați Create_test_data.input.pset la 2020-06-04 12:00:23
Începeți mdw_load.regular.current.dev42_1_db_usl_testing_subj_org_finval.pset la 2020-06-04 12:00:23
Terminați mdw_load.regular.current.dev42_1_db_usl_testing_subj_org_finval.pset la 2020-06-04 12:03:23
Începeți Create_test_data.input.pset la 2020-06-04 12:03:23
Terminați Create_test_data.input.pset la 2020-06-04 12:03:49
Începeți mdw_load.regular.current.dev42_1_db_usl_testing_subj_org_finval.pset la 2020-06-04 12:03:49
Terminați mdw_load.regular.current.dev42_1_db_usl_testing_subj_org_finval.pset la 2020-06-04 12:06:46

Rezultă această poză:

Grafic
Începeți timp
Timp de sosire
Lungime

Create_test_data.input.pset
04.06.2020 11: 49: 11
04.06.2020 11: 49: 37
00:00:26

mdw_load.day_one.current.
dev42_1_db_usl_testing_subj_org_finval.pset
04.06.2020 11: 49: 37
04.06.2020 11: 50: 42
00:01:05

Create_test_data.input.pset
04.06.2020 11: 50: 42
04.06.2020 11: 51: 06
00:00:24

mdw_load.regular.current.
dev42_1_db_usl_testing_subj_org_finval.pset
04.06.2020 11: 51: 06
04.06.2020 11: 53: 41
00:02:35

Create_test_data.input.pset
04.06.2020 11: 53: 41
04.06.2020 11: 54: 04
00:00:23

mdw_load.regular.current.
dev42_1_db_usl_testing_subj_org_finval.pset
04.06.2020 11: 54: 04
04.06.2020 11: 56: 51
00:02:47

Create_test_data.input.pset
04.06.2020 11: 56: 51
04.06.2020 11: 57: 14
00:00:23

mdw_load.regular.current.
dev42_1_db_usl_testing_subj_org_finval.pset
04.06.2020 11: 57: 14
04.06.2020 11: 59: 55
00:02:41

Create_test_data.input.pset
04.06.2020 11: 59: 55
04.06.2020 12: 00: 23
00:00:28

mdw_load.regular.current.
dev42_1_db_usl_testing_subj_org_finval.pset
04.06.2020 12: 00: 23
04.06.2020 12: 03: 23
00:03:00

Create_test_data.input.pset
04.06.2020 12: 03: 23
04.06.2020 12: 03: 49
00:00:26

mdw_load.regular.current.
dev42_1_db_usl_testing_subj_org_finval.pset
04.06.2020 12: 03: 49
04.06.2020 12: 06: 46
00:02:57

Vedem că 6 de linii incrementale sunt procesate în 000 minute, ceea ce este destul de rapid.
Datele din tabelul țintă s-au dovedit a fi distribuite după cum urmează:

select valid_from_ts, valid_to_ts, count(1), min(sk), max(sk) from dev42_1_db_usl.TESTING_SUBJ_org_finval group by valid_from_ts, valid_to_ts order by 1,2;

Puteți vedea corespondența datelor introduse cu orele în care au fost lansate graficele.
Aceasta înseamnă că puteți rula încărcarea incrementală a datelor în GreenPlum în Ab Initio cu o frecvență foarte mare și puteți observa o viteză mare de inserare a acestor date în GreenPlum. Desigur, nu va fi posibilă lansarea o dată pe secundă, deoarece Ab Initio, ca orice instrument ETL, necesită timp pentru a „porni” atunci când este lansat.

Concluzie

Ab Initio este utilizat în prezent la Sberbank pentru a construi un strat de date semantice unificate (ESS). Acest proiect presupune construirea unei versiuni unificate a stării diferitelor entități de afaceri bancare. Informațiile provin din diverse surse, ale căror replici sunt pregătite pe Hadoop. Pe baza nevoilor afacerii, este pregătit un model de date și sunt descrise transformările datelor. Ab Initio încarcă informații în ESN, iar datele descărcate nu sunt doar de interes pentru afacere în sine, ci servesc și ca sursă pentru construirea de magazine de date. În același timp, funcționalitatea produsului vă permite să utilizați diverse sisteme ca receptor (Hive, Greenplum, Teradata, Oracle), ceea ce face posibilă pregătirea cu ușurință a datelor pentru o afacere în diferitele formate de care are nevoie.

Capacitățile Ab Initio sunt largi, de exemplu, cadrul MDW inclus face posibilă construirea de date tehnice și istorice de afaceri. Pentru dezvoltatori, Ab Initio face posibilă să nu reinventeze roata, ci să folosească multe componente funcționale existente, care sunt în esență biblioteci necesare atunci când se lucrează cu date.

Autorul este un expert în comunitatea profesională a Sberbank SberProfi DWH/BigData. Comunitatea profesională SberProfi DWH/BigData este responsabilă pentru dezvoltarea competențelor în domenii precum ecosistemul Hadoop, Teradata, Oracle DB, GreenPlum, precum și instrumentele BI Qlik, SAP BO, Tableau etc.

Sursa: www.habr.com