Når du har Sber vægte. Brug af Ab Initio med Hive og GreenPlum

For noget tid siden stod vi over for spørgsmålet om at vælge et ETL-værktøj til at arbejde med Big Data. Den tidligere brugte Informatica BDM-løsning passede ikke til os på grund af begrænset funktionalitet. Dens brug er blevet reduceret til en ramme for lancering af gnist-submit-kommandoer. Der var ikke mange analoger på markedet, der i princippet var i stand til at arbejde med den mængde data, vi beskæftiger os med hver dag. Til sidst valgte vi Ab Initio. Under pilotdemonstrationer viste produktet meget høj databehandlingshastighed. Der er næsten ingen information om Ab Initio på russisk, så vi besluttede at tale om vores oplevelse på Habré.

Ab Initio har mange klassiske og usædvanlige transformationer, hvis kode kan udvides med sit eget PDL-sprog. For en lille virksomhed vil et så stærkt værktøj sandsynligvis være overkill, og de fleste af dets muligheder kan være dyre og ubrugte. Men hvis din skala er tæt på Sberovs, så kan Ab Initio være interessant for dig.

Det hjælper en virksomhed med at akkumulere viden globalt og udvikle et økosystem, og en udvikler til at forbedre sine færdigheder i ETL, forbedre sin viden i skallen, giver mulighed for at mestre PDL-sproget, giver et visuelt billede af indlæsningsprocesser og forenkler udvikling på grund af overfloden af ​​funktionelle komponenter.

I dette indlæg vil jeg tale om Ab Initio's muligheder og give komparative karakteristika for dets arbejde med Hive og GreenPlum.

• Beskrivelse af MDW-rammen og arbejdet med dens tilpasning til GreenPlum
• Ab Initio præstationssammenligning mellem Hive og GreenPlum
• Arbejder Ab Initio med GreenPlum i næsten realtidstilstand

Funktionaliteten af ​​dette produkt er meget bred og kræver meget tid at studere. Men med de rette arbejdsfærdigheder og de rigtige præstationsindstillinger er resultaterne af databehandling meget imponerende. At bruge Ab Initio til en udvikler kan give en interessant oplevelse. Dette er et nyt bud på ETL-udvikling, en hybrid mellem et visuelt miljø og downloadudvikling i et script-lignende sprog.

Virksomheder udvikler deres økosystemer, og dette værktøj kommer mere praktisk end nogensinde før. Med Ab Initio kan du akkumulere viden om din nuværende forretning og bruge denne viden til at udvide gamle og åbne nye virksomheder. Alternativer til Ab Initio omfatter visuelle udviklingsmiljøer Informatica BDM og ikke-visuelle udviklingsmiljøer Apache Spark.

Beskrivelse af Ab Initio

Ab Initio er ligesom andre ETL-værktøjer en samling af produkter.

Ab Initio GDE (Graphical Development Environment) er et miljø for udvikleren, hvor han konfigurerer datatransformationer og forbinder dem med datastrømme i form af pile. I dette tilfælde kaldes et sådant sæt af transformationer en graf:

Indgangs- og udgangsforbindelserne for funktionelle komponenter er porte og indeholder felter beregnet inden for transformationer. Flere grafer forbundet med strømninger i form af pile i rækkefølgen af ​​deres udførelse kaldes en plan.

Der er flere hundrede funktionelle komponenter, hvilket er meget. Mange af dem er højt specialiserede. Mulighederne for klassiske transformationer i Ab Initio er bredere end i andre ETL-værktøjer. For eksempel har Join flere udgange. Ud over resultatet af at forbinde datasæt, kan du få outputposter af inputdatasæt, hvis nøgler ikke kunne forbindes. Du kan også få afslag, fejl og en log over transformationsoperationen, som kan læses i samme kolonne som en tekstfil og behandles med andre transformationer:

Eller du kan for eksempel materialisere en datamodtager i form af en tabel og læse data fra den i samme kolonne.

Der er originale transformationer. For eksempel har Scan-transformationen funktionalitet, der ligner analytiske funktioner. Der er transformationer med selvforklarende navne: Opret Data, Læs Excel, Normaliser, Sortér i grupper, Kør program, Kør SQL, Join med DB osv. Grafer kan bruge køretidsparametre, herunder muligheden for at overføre parametre fra eller til operativsystemet. Filer med et færdigt sæt parametre, der er sendt til grafen, kaldes parametersæt (psets).

Som forventet har Ab Initio GDE sit eget repository kaldet EME (Enterprise Meta Environment). Udviklere har mulighed for at arbejde med lokale versioner af kode og tjekke deres udvikling ind i det centrale lager.

Det er muligt, under udførelse eller efter udførelse af grafen, at klikke på et hvilket som helst flow, der forbinder transformationen og se på de data, der passerede mellem disse transformationer:

Det er også muligt at klikke på en hvilken som helst strøm og se sporingsdetaljer - hvor mange paralleller transformationen fungerede i, hvor mange linjer og bytes blev indlæst i hvilke af parallellerne:

Det er muligt at opdele udførelsen af ​​grafen i faser og markere, at nogle transformationer skal udføres først (i nulfasen), de næste i første fase, de næste i anden fase osv.

For hver transformation kan du vælge det såkaldte layout (hvor det vil blive udført): uden paralleller eller i parallelle tråde, hvis antal kan angives. Samtidig kan midlertidige filer, som Ab Initio opretter, når transformationer kører, placeres både i serverfilsystemet og i HDFS.

I hver transformation kan du, baseret på standardskabelonen, oprette dit eget script i PDL, som er lidt ligesom en shell.

Med PDL kan du udvide funktionaliteten af ​​transformationer, og især kan du dynamisk (ved runtime) generere vilkårlige kodefragmenter afhængigt af runtime-parametre.

Ab Initio har også veludviklet integration med OS via shell. Specifikt bruger Sberbank linux ksh. Du kan udveksle variabler med skallen og bruge dem som grafparametre. Du kan kalde udførelsen af ​​Ab Initio-grafer fra skallen og administrere Ab Initio.

Udover Ab Initio GDE er der mange andre produkter med i leveringen. Der er sit eget Co>Operation System med et krav om at blive kaldt et operativsystem. Der er et kontrol>center, hvor du kan planlægge og overvåge downloadflows. Der er produkter til at lave udvikling på et mere primitivt niveau end Ab Initio GDE tillader.

Beskrivelse af MDW-rammen og arbejdet med dens tilpasning til GreenPlum

Sammen med sine produkter leverer leverandøren MDW (Metadata Driven Warehouse) produktet, som er en grafkonfigurator designet til at hjælpe med typiske opgaver med udfyldning af datavarehuse eller databokse.

Den indeholder brugerdefinerede (projektspecifikke) metadataparsere og færdiglavede kodegeneratorer ud af kassen.

Som input modtager MDW en datamodel, en konfigurationsfil til opsætning af en forbindelse til en database (Oracle, Teradata eller Hive) og nogle andre indstillinger. Den projektspecifikke del implementerer for eksempel modellen til en database. Out-of-the-box-delen af ​​produktet genererer grafer og konfigurationsfiler til dem ved at indlæse data i modeltabeller. I dette tilfælde oprettes grafer (og psets) til flere initialiseringstilstande og trinvis arbejde med at opdatere entiteter.

I tilfælde af Hive og RDBMS genereres forskellige grafer til initialisering og trinvise dataopdateringer.

I tilfælde af Hive forbindes de indgående deltadata via Ab Initio Join med de data, der var i tabellen før opdateringen. Dataindlæsere i MDW (både i Hive og RDBMS) indsætter ikke kun nye data fra deltaet, men lukker også perioderne med relevans for de data, hvis primære nøgler modtog deltaet. Derudover skal du omskrive den uændrede del af dataene. Men dette skal gøres, fordi Hive ikke har slette- eller opdateringsoperationer.

I tilfælde af RDBMS ser grafer for inkrementel dataopdatering mere optimale ud, fordi RDBMS har reelle opdateringsmuligheder.

Det modtagne delta indlæses i en mellemtabel i databasen. Herefter forbindes deltaet med de data, der var i tabellen før opdateringen. Og dette gøres ved hjælp af SQL ved hjælp af en genereret SQL-forespørgsel. Dernæst, ved hjælp af SQL-kommandoerne delete+insert, indsættes nye data fra deltaet i måltabellen, og perioderne med relevans for de data, hvis primære nøgler modtog deltaet, lukkes.
Der er ingen grund til at omskrive uændrede data.

Så vi kom til den konklusion, at i tilfælde af Hive, skal MDW gå for at omskrive hele tabellen, fordi Hive ikke har en opdateringsfunktion. Og intet bedre end helt at omskrive dataene, når opdateringen er opfundet. I tilfælde af RDBMS, tværtimod, fandt skaberne af produktet det nødvendigt at overlade forbindelsen og opdateringen af ​​tabeller til brugen af ​​SQL.

Til et projekt hos Sberbank skabte vi en ny, genbrugelig implementering af en databaseindlæser til GreenPlum. Dette blev gjort baseret på den version, som MDW genererer til Teradata. Det var Teradata, og ikke Oracle, der kom tættest på og bedst til dette, fordi... er også et MPP-system. Arbejdsmetoderne såvel som syntaksen for Teradata og GreenPlum viste sig at være ens.

Eksempler på MDW-kritiske forskelle mellem forskellige RDBMS'er er som følger. I GreenPlum, i modsætning til Teradata, skal du skrive en klausul, når du opretter tabeller

distributed by

Teradata skriver:

delete <table> all

, og i GreenPlum skriver de

delete from <table>

I Oracle skriver de til optimeringsformål

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

, og Teradata og GreenPlum skriver

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

Vi bemærker også, at for at Ab Initio kunne arbejde med GreenPlum, var det nødvendigt at installere GreenPlum-klienten på alle noder i Ab Initio-klyngen. Dette skyldes, at vi koblede til GreenPlum samtidigt fra alle noder i vores klynge. Og for at læsning fra GreenPlum kunne være parallel, og hver parallel Ab Initio-tråd kunne læse sin egen del af data fra GreenPlum, var vi nødt til at placere en konstruktion, som Ab Initio forstår, i "hvor"-sektionen af ​​SQL-forespørgsler

where ABLOCAL()

og bestemme værdien af ​​denne konstruktion ved at specificere parameterlæsningen fra transformationsdatabasen

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

, som kompilerer til noget som

mod(sk,10)=3

, dvs. du skal bede GreenPlum med et eksplicit filter for hver partition. For andre databaser (Teradata, Oracle) kan Ab Initio udføre denne parallelisering automatisk.

Ab Initio præstationssammenligning mellem Hive og GreenPlum

Sberbank gennemførte et eksperiment for at sammenligne ydeevnen af ​​MDW-genererede grafer i forhold til Hive og i forhold til GreenPlum. Som en del af eksperimentet var der i tilfælde af Hive 5 noder på samme klynge som Ab Initio, og i tilfælde af GreenPlum var der 4 noder på en separat klynge. De der. Hive havde en vis hardwarefordel i forhold til GreenPlum.

Vi overvejede to par grafer, der udfører den samme opgave med at opdatere data i Hive og GreenPlum. Samtidig blev graferne genereret af MDW-konfiguratoren lanceret:

• indledende belastning + trinvis belastning af tilfældigt genererede data i en Hive-tabel
• indledende belastning + trinvis belastning af tilfældigt genererede data i den samme GreenPlum-tabel

I begge tilfælde (Hive og GreenPlum) kørte de uploads til 10 parallelle tråde på den samme Ab Initio-klynge. Ab Initio gemte mellemdata til beregninger i HDFS (i forhold til Ab Initio blev MFS-layout ved hjælp af HDFS brugt). En linje med tilfældigt genererede data optog 200 bytes i begge tilfælde.

Resultatet blev således:

Vinter:

Indledende indlæsning i Hive

Rækker indsat
6 000 000
60 000 000
600 000 000

Initialiseringens varighed
downloads på få sekunder
41
203
1 601

Inkrementel indlæsning i Hive

Antal tilgængelige rækker i
måltabel i begyndelsen af ​​eksperimentet
6 000 000
60 000 000
600 000 000

Antal deltalinjer anvendt på
måltabel under forsøget
6 000 000
6 000 000
6 000 000

Varighed af inkrementel
downloads på få sekunder
88
299
2 541

GreenPlum:

Indledende indlæsning i GreenPlum

Rækker indsat
6 000 000
60 000 000
600 000 000

Initialiseringens varighed
downloads på få sekunder
72
360
3 631

Inkrementel belastning i GreenPlum

Antal tilgængelige rækker i
måltabel i begyndelsen af ​​eksperimentet
6 000 000
60 000 000
600 000 000

Antal deltalinjer anvendt på
måltabel under forsøget
6 000 000
6 000 000
6 000 000

Varighed af inkrementel
downloads på få sekunder
159
199
321

Vi ser, at hastigheden af ​​indledende indlæsning i både Hive og GreenPlum lineært afhænger af mængden af ​​data, og af hensyn til bedre hardware er den lidt hurtigere for Hive end for GreenPlum.

Inkrementel indlæsning i Hive afhænger også lineært af mængden af ​​tidligere indlæste data, der er tilgængelige i måltabellen, og fortsætter ret langsomt, efterhånden som volumen vokser. Dette er forårsaget af behovet for at omskrive måltabellen fuldstændigt. Det betyder, at det ikke er en god brugssag for Hive at anvende små ændringer på store borde.

Inkrementel indlæsning i GreenPlum afhænger svagt af mængden af ​​tidligere indlæste data, der er tilgængelige i måltabellen og fortsætter ret hurtigt. Dette skete takket være SQL Joins og GreenPlum-arkitekturen, som tillader sletningsoperationen.

Så GreenPlum tilføjer deltaet ved hjælp af delete+insert-metoden, men Hive har ikke slette- eller opdateringsoperationer, så hele dataarrayet blev tvunget til at blive omskrevet helt under en trinvis opdatering. Sammenligningen af ​​cellerne fremhævet med fed er mest afslørende, da den svarer til den mest almindelige mulighed for at bruge ressourcekrævende downloads. Vi ser, at GreenPlum slog Hive i denne test med 8 gange.

Arbejder Ab Initio med GreenPlum i næsten realtidstilstand

I dette eksperiment vil vi teste Ab Initios evne til at opdatere GreenPlum-tabellen med tilfældigt genererede bidder af data i næsten realtid. Lad os overveje GreenPlum-tabellen dev42_1_db_usl.TESTING_SUBJ_org_finval, som vi vil arbejde med.

Vi vil bruge tre Ab Initio-grafer til at arbejde med det:

1) Graph Create_test_data.mp – opretter datafiler i HDFS med 10 rækker i 6 parallelle tråde. Dataene er tilfældige, dens struktur er organiseret til indsættelse i vores tabel

2) Graf mdw_load.day_one.current.dev42_1_db_usl_testing_subj_org_finval.pset – MDW-genereret graf ved at initialisere dataindsættelse i vores tabel i 10 parallelle tråde (testdata genereret af graf (1) bruges)

3) Graf mdw_load.regular.current.dev42_1_db_usl_testing_subj_org_finval.pset – en graf genereret af MDW til trinvis opdatering af vores tabel i 10 parallelle tråde ved hjælp af en del af frisk modtagne data (delta) genereret af graf (1)

Lad os køre nedenstående script i NRT-tilstand:

• generere 6 testlinjer
• udføre en indledende belastning, indsæt 6 testrækker i en tom tabel
• gentag trinvis download 5 gange
  • generere 6 testlinjer
  • udfør en trinvis indsættelse af 6 testrækker i tabellen (i dette tilfælde er valid_to_ts-udløbstiden indstillet til de gamle data, og nyere data med den samme primærnøgle indsættes)

Dette scenarie emulerer den virkelige drift af et bestemt forretningssystem - en ret stor del af nye data vises i realtid og hældes straks ind i GreenPlum.

Lad os nu se på scriptets log:

Start Create_test_data.input.pset kl. 2020-06-04 11:49:11
Afslut Create_test_data.input.pset kl. 2020-06-04 11:49:37
Start mdw_load.day_one.current.dev42_1_db_usl_testing_subj_org_finval.pset kl. 2020-06-04 11:49:37
Afslut mdw_load.day_one.current.dev42_1_db_usl_testing_subj_org_finval.pset kl. 2020-06-04 11:50:42
Start Create_test_data.input.pset kl. 2020-06-04 11:50:42
Afslut Create_test_data.input.pset kl. 2020-06-04 11:51:06
Start mdw_load.regular.current.dev42_1_db_usl_testing_subj_org_finval.pset kl. 2020-06-04 11:51:06
Afslut mdw_load.regular.current.dev42_1_db_usl_testing_subj_org_finval.pset kl. 2020-06-04 11:53:41
Start Create_test_data.input.pset kl. 2020-06-04 11:53:41
Afslut Create_test_data.input.pset kl. 2020-06-04 11:54:04
Start mdw_load.regular.current.dev42_1_db_usl_testing_subj_org_finval.pset kl. 2020-06-04 11:54:04
Afslut mdw_load.regular.current.dev42_1_db_usl_testing_subj_org_finval.pset kl. 2020-06-04 11:56:51
Start Create_test_data.input.pset kl. 2020-06-04 11:56:51
Afslut Create_test_data.input.pset kl. 2020-06-04 11:57:14
Start mdw_load.regular.current.dev42_1_db_usl_testing_subj_org_finval.pset kl. 2020-06-04 11:57:14
Afslut mdw_load.regular.current.dev42_1_db_usl_testing_subj_org_finval.pset kl. 2020-06-04 11:59:55
Start Create_test_data.input.pset kl. 2020-06-04 11:59:55
Afslut Create_test_data.input.pset kl. 2020-06-04 12:00:23
Start mdw_load.regular.current.dev42_1_db_usl_testing_subj_org_finval.pset kl. 2020-06-04 12:00:23
Afslut mdw_load.regular.current.dev42_1_db_usl_testing_subj_org_finval.pset kl. 2020-06-04 12:03:23
Start Create_test_data.input.pset kl. 2020-06-04 12:03:23
Afslut Create_test_data.input.pset kl. 2020-06-04 12:03:49
Start mdw_load.regular.current.dev42_1_db_usl_testing_subj_org_finval.pset kl. 2020-06-04 12:03:49
Afslut mdw_load.regular.current.dev42_1_db_usl_testing_subj_org_finval.pset kl. 2020-06-04 12:06:46

Det viser sig dette billede:

Graf
Start tid
Afslut tid
Længde

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

Vi ser, at 6 inkrementlinjer behandles på 000 minutter, hvilket er ret hurtigt.
Dataene i måltabellen viste sig at være fordelt som følger:

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;

Du kan se overensstemmelsen mellem de indsatte data og de tidspunkter, graferne blev lanceret.
Dette betyder, at du kan køre trinvis indlæsning af data i GreenPlum i Ab Initio med en meget høj frekvens og observere en høj hastighed med at indsætte disse data i GreenPlum. Det vil selvfølgelig ikke være muligt at starte en gang i sekundet, da Ab Initio, ligesom ethvert ETL-værktøj, kræver tid til at "starte op", når det startes.

Konklusion

Ab Initio bruges i øjeblikket hos Sberbank til at bygge et Unified Semantic Data Layer (ESS). Dette projekt involverer opbygning af en samlet version af tilstanden for forskellige bankforretningsenheder. Oplysninger kommer fra forskellige kilder, hvis replikaer er udarbejdet på Hadoop. Ud fra forretningsbehov udarbejdes en datamodel og datatransformationer beskrives. Ab Initio indlæser information i ESN, og de downloadede data er ikke kun af interesse for virksomheden i sig selv, men fungerer også som en kilde til opbygning af data marts. Samtidig giver produktets funktionalitet mulighed for at bruge forskellige systemer som modtager (Hive, Greenplum, Teradata, Oracle), hvilket gør det muligt nemt at udarbejde data til en virksomhed i de forskellige formater, den kræver.

Ab Initios muligheder er brede; for eksempel gør det inkluderede MDW-rammeværk det muligt at bygge tekniske og forretningshistoriske data ud af boksen. For udviklere gør Ab Initio det muligt ikke at genopfinde hjulet, men at bruge mange eksisterende funktionelle komponenter, som i det væsentlige er biblioteker, der er nødvendige, når man arbejder med data.

Forfatteren er ekspert i det professionelle samfund af Sberbank SberProfi DWH/BigData. Det professionelle SberProfi DWH/BigData-miljø er ansvarligt for at udvikle kompetencer inden for områder som Hadoop-økosystemet, Teradata, Oracle DB, GreenPlum, samt BI-værktøjer Qlik, SAP BO, Tableau mv.

Kilde: www.habr.com