När du har Sber-våg. Använder Ab Initio med Hive och GreenPlum

För en tid sedan stod vi inför frågan om att välja ett ETL-verktyg för att arbeta med Big Data. Den tidigare använda Informatica BDM-lösningen passade inte oss på grund av begränsad funktionalitet. Dess användning har reducerats till ett ramverk för att starta gnist-submit-kommandon. Det fanns inte många analoger på marknaden som i princip var kapabla att arbeta med den mängd data som vi hanterar varje dag. Till slut valde vi Ab Initio. Under pilotdemonstrationer visade produkten mycket hög databehandlingshastighet. Det finns nästan ingen information om Ab Initio på ryska, så vi bestämde oss för att prata om vår upplevelse på Habré.

Ab Initio har många klassiska och ovanliga transformationer, vars kod kan utökas med sitt eget PDL-språk. För ett litet företag kommer ett så kraftfullt verktyg sannolikt att vara överdrivet, och de flesta av dess funktioner kan vara dyra och oanvända. Men om din skala ligger nära Sberovs, kan Ab Initio vara intressant för dig.

Det hjälper ett företag att samla kunskap globalt och utveckla ett ekosystem, och en utvecklare att förbättra sina färdigheter i ETL, förbättra sina kunskaper i skalet, ger möjlighet att behärska PDL-språket, ger en visuell bild av laddningsprocesser och förenklar utveckling på grund av överflöd av funktionella komponenter.

I det här inlägget kommer jag att prata om funktionerna hos Ab Initio och ge jämförande egenskaper för dess arbete med Hive och GreenPlum.

• Beskrivning av MDW-ramverket och arbetet med dess anpassning för GreenPlum
• Ab Initio prestandajämförelse mellan Hive och GreenPlum
• Arbeta Ab Initio med GreenPlum i nästan realtidsläge

Funktionaliteten hos denna produkt är mycket bred och kräver mycket tid att studera. Men med rätt arbetsförmåga och rätt prestationsinställningar är resultaten av databehandlingen mycket imponerande. Att använda Ab Initio för en utvecklare kan ge en intressant upplevelse. Detta är en ny version av ETL-utveckling, en hybrid mellan en visuell miljö och nedladdningsutveckling i ett skriptliknande språk.

Företag utvecklar sina ekosystem och detta verktyg kommer till nytta mer än någonsin. Med Ab Initio kan du samla kunskap om din nuvarande verksamhet och använda denna kunskap för att expandera gamla och öppna nya verksamheter. Alternativ till Ab Initio inkluderar visuella utvecklingsmiljöer Informatica BDM och icke-visuella utvecklingsmiljöer Apache Spark.

Beskrivning av Ab Initio

Ab Initio är, liksom andra ETL-verktyg, en samling produkter.

Ab Initio GDE (Graphical Development Environment) är en miljö för utvecklaren där han konfigurerar datatransformationer och kopplar ihop dem med dataflöden i form av pilar. I det här fallet kallas en sådan uppsättning transformationer en graf:

In- och utgångsanslutningarna för funktionella komponenter är portar och innehåller fält som beräknas inom transformationer. Flera grafer sammankopplade med flöden i form av pilar i ordningsföljden för deras utförande kallas en plan.

Det finns flera hundra funktionella komponenter, vilket är mycket. Många av dem är högt specialiserade. Möjligheterna för klassiska transformationer i Ab Initio är bredare än i andra ETL-verktyg. Till exempel har Join flera utgångar. Förutom resultatet av att ansluta datauppsättningar kan du få utdataposter för indatauppsättningar vars nycklar inte kunde anslutas. Du kan också få avslag, fel och en logg över transformationsoperationen, som kan läsas i samma kolumn som en textfil och bearbetas med andra transformationer:

Eller, till exempel, kan du materialisera en datamottagare i form av en tabell och läsa data från den i samma kolumn.

Det finns ursprungliga transformationer. Till exempel har Scan-transformationen funktionalitet som liknar analytiska funktioner. Det finns transformationer med självförklarande namn: Skapa data, Läs Excel, Normalisera, Sortera inom grupper, Kör program, Kör SQL, Join with DB, etc. Grafer kan använda körtidsparametrar, inklusive möjligheten att skicka parametrar från eller till operativsystemet. Filer med en färdig uppsättning parametrar som skickas till grafen kallas parameteruppsättningar (psets).

Som väntat har Ab Initio GDE ett eget arkiv som heter EME (Enterprise Meta Environment). Utvecklare har möjlighet att arbeta med lokala versioner av kod och checka in sin utveckling i det centrala arkivet.

Det är möjligt, under exekvering eller efter exekvering av grafen, att klicka på vilket flöde som helst som förbinder transformationen och titta på data som passerade mellan dessa transformationer:

Det är också möjligt att klicka på valfri ström och se spårningsdetaljer - hur många paralleller transformationen fungerade i, hur många rader och bytes som laddades in i vilken av parallellerna:

Det är möjligt att dela upp utförandet av grafen i faser och markera att vissa transformationer måste utföras först (i nollfasen), nästa i första fasen, nästa i andra fasen osv.

För varje transformation kan du välja den så kallade layouten (där den kommer att exekveras): utan paralleller eller i parallella trådar, vars antal kan anges. Samtidigt kan temporära filer som Ab Initio skapar när transformationer körs placeras både i serverns filsystem och i HDFS.

I varje transformation, baserat på standardmallen, kan du skapa ditt eget skript i PDL, som är lite som ett skal.

Med PDL kan du utöka funktionaliteten för transformationer och i synnerhet kan du dynamiskt (vid körning) generera godtyckliga kodfragment beroende på körtidsparametrar.

Ab Initio har även välutvecklad integration med OS via skal. Specifikt använder Sberbank linux ksh. Du kan utbyta variabler med skalet och använda dem som grafparametrar. Du kan anropa exekveringen av Ab Initio-grafer från skalet och administrera Ab Initio.

Förutom Ab Initio GDE ingår många andra produkter i leveransen. Det finns ett eget Co>Operation System med anspråk på att kallas ett operativsystem. Det finns ett kontroll>center där du kan schemalägga och övervaka nedladdningsflöden. Det finns produkter för att göra utveckling på en mer primitiv nivå än vad Ab Initio GDE tillåter.

Beskrivning av MDW-ramverket och arbetet med dess anpassning för GreenPlum

Tillsammans med sina produkter levererar leverantören MDW-produkten (Metadata Driven Warehouse), som är en grafkonfigurator utformad för att hjälpa till med typiska uppgifter för att fylla datalager eller datavalv.

Den innehåller anpassade (projektspecifika) metadataparsers och färdiga kodgeneratorer direkt.

Som indata får MDW en datamodell, en konfigurationsfil för att sätta upp en anslutning till en databas (Oracle, Teradata eller Hive) och några andra inställningar. Den projektspecifika delen distribuerar till exempel modellen till en databas. Den out-of-the-box-delen av produkten genererar grafer och konfigurationsfiler för dem genom att ladda data i modelltabeller. I det här fallet skapas grafer (och psets) för flera lägen för initialisering och inkrementellt arbete med att uppdatera enheter.

I fallen Hive och RDBMS genereras olika grafer för initiering och inkrementella datauppdateringar.

När det gäller Hive kopplas inkommande deltadata via Ab Initio Join med data som fanns i tabellen före uppdateringen. Dataladdare i MDW (både i Hive och RDBMS) infogar inte bara ny data från deltat, utan stänger också relevansperioderna för de data vars primärnycklar tog emot deltat. Dessutom måste du skriva om den oförändrade delen av datan. Men detta måste göras eftersom Hive inte har raderings- eller uppdateringsåtgärder.

När det gäller RDBMS ser grafer för inkrementell datauppdatering mer optimala ut, eftersom RDBMS har verkliga uppdateringsmöjligheter.

Det mottagna deltat laddas in i en mellantabell i databasen. Efter detta kopplas deltat till den data som fanns i tabellen före uppdateringen. Och detta görs med hjälp av SQL med en genererad SQL-fråga. Därefter, med hjälp av SQL-kommandona delete+insert, infogas ny data från deltat i måltabellen och relevansperioderna för data vars primärnycklar fick delta stängs.
Det finns inget behov av att skriva om oförändrade data.

Så vi kom till slutsatsen att i fallet med Hive måste MDW gå för att skriva om hela tabellen eftersom Hive inte har en uppdateringsfunktion. Och inget bättre än att helt skriva om data när uppdateringen har uppfunnits. När det gäller RDBMS, tvärtom, fann skaparna av produkten det nödvändigt att anförtro anslutningen och uppdateringen av tabeller till användningen av SQL.

För ett projekt på Sberbank skapade vi en ny, återanvändbar implementering av en databasladdare för GreenPlum. Detta gjordes baserat på den version som MDW genererar för Teradata. Det var Teradata, och inte Oracle, som kom närmast och bäst för detta, eftersom... är också ett MPP-system. Arbetsmetoderna, liksom syntaxen, för Teradata och GreenPlum visade sig vara likartade.

Exempel på MDW-kritiska skillnader mellan olika RDBMS:er är följande. I GreenPlum, till skillnad från Teradata, måste du skriva en klausul när du skapar tabeller

distributed by

Teradata skriver:

delete <table> all

, och i GreenPlum skriver de

delete from <table>

I Oracle skriver de i optimeringssyfte

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

, och Teradata och GreenPlum skriver

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

Vi noterar också att för att Ab Initio skulle fungera med GreenPlum var det nödvändigt att installera GreenPlum-klienten på alla noder i Ab Initio-klustret. Detta beror på att vi anslutit till GreenPlum samtidigt från alla noder i vårt kluster. Och för att läsning från GreenPlum skulle vara parallell och varje parallell Ab Initio-tråd skulle läsa sin egen del av data från GreenPlum, var vi tvungna att placera en konstruktion som Ab Initio förstår i avsnittet "var" i SQL-frågor

where ABLOCAL()

och bestämma värdet av denna konstruktion genom att specificera parameteravläsningen från transformationsdatabasen

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

, som kompilerar till något liknande

mod(sk,10)=3

, dvs. du måste fråga GreenPlum med ett explicit filter för varje partition. För andra databaser (Teradata, Oracle) kan Ab Initio utföra denna parallellisering automatiskt.

Ab Initio prestandajämförelse mellan Hive och GreenPlum

Sberbank genomförde ett experiment för att jämföra prestandan för MDW-genererade grafer i förhållande till Hive och i förhållande till GreenPlum. Som en del av experimentet, i fallet med Hive, fanns det 5 noder på samma kluster som Ab Initio, och i fallet med GreenPlum fanns det 4 noder på ett separat kluster. De där. Hive hade vissa hårdvarufördelar jämfört med GreenPlum.

Vi övervägde två par grafer som utför samma uppgift att uppdatera data i Hive och GreenPlum. Samtidigt lanserades graferna som genererades av MDW-konfiguratorn:

• initial laddning + inkrementell belastning av slumpmässigt genererad data till en Hive-tabell
• initial laddning + inkrementell laddning av slumpmässigt genererad data till samma GreenPlum-tabell

I båda fallen (Hive och GreenPlum) körde de uppladdningar till 10 parallella trådar på samma Ab Initio-kluster. Ab Initio sparade mellanliggande data för beräkningar i HDFS (när det gäller Ab Initio användes MFS-layout med HDFS). En rad slumpmässigt genererade data upptog 200 byte i båda fallen.

Resultatet blev så här:

Bikupa:

Initial laddning i Hive

Rader infogade
6 000 000
60 000 000
600 000 000

Initieringens varaktighet
nedladdningar på några sekunder
41
203
1 601

Inkrementell laddning i Hive

Antal rader tillgängliga i
måltabell i början av experimentet
6 000 000
60 000 000
600 000 000

Antal deltalinjer som tillämpas på
måltabell under experimentet
6 000 000
6 000 000
6 000 000

Varaktighet av inkrementell
nedladdningar på några sekunder
88
299
2 541

GreenPlum:

Initial laddning i GreenPlum

Rader infogade
6 000 000
60 000 000
600 000 000

Initieringens varaktighet
nedladdningar på några sekunder
72
360
3 631

Inkrementell laddning i GreenPlum

Antal rader tillgängliga i
måltabell i början av experimentet
6 000 000
60 000 000
600 000 000

Antal deltalinjer som tillämpas på
måltabell under experimentet
6 000 000
6 000 000
6 000 000

Varaktighet av inkrementell
nedladdningar på några sekunder
159
199
321

Vi ser att den initiala laddningshastigheten i både Hive och GreenPlum linjärt beror på mängden data och, av bättre hårdvara, är den något snabbare för Hive än för GreenPlum.

Inkrementell laddning i Hive beror också linjärt på volymen av tidigare laddade data som finns tillgängliga i måltabellen och fortsätter ganska långsamt när volymen växer. Detta orsakas av behovet av att skriva om måltabellen helt. Detta betyder att det inte är ett bra användningsfall för Hive att tillämpa små ändringar på stora tabeller.

Inkrementell laddning i GreenPlum beror svagt på volymen av tidigare laddade data som är tillgängliga i måltabellen och går ganska snabbt. Detta hände tack vare SQL Joins och GreenPlum-arkitekturen, som tillåter raderingsoperationen.

Så, GreenPlum lägger till deltat med metoden delete+insert, men Hive har inga borttagnings- eller uppdateringsoperationer, så hela datamatrisen tvingades skrivas om helt under en inkrementell uppdatering. Jämförelsen av cellerna markerade i fet stil är mest avslöjande, eftersom den motsvarar det vanligaste alternativet för att använda resurskrävande nedladdningar. Vi ser att GreenPlum slog Hive i detta test med 8 gånger.

Arbeta Ab Initio med GreenPlum i nästan realtidsläge

I det här experimentet kommer vi att testa Ab Initios förmåga att uppdatera GreenPlum-tabellen med slumpmässigt genererade databitar i nästan realtid. Låt oss överväga GreenPlum-tabellen dev42_1_db_usl.TESTING_SUBJ_org_finval, som vi kommer att arbeta med.

Vi kommer att använda tre Ab Initio-grafer för att arbeta med det:

1) Graph Create_test_data.mp – skapar datafiler i HDFS med 10 6 000 rader i 000 parallella trådar. Uppgifterna är slumpmässiga, dess struktur är organiserad för att infogas i vår tabell

2) Graf mdw_load.day_one.current.dev42_1_db_usl_testing_subj_org_finval.pset – MDW-genererad graf genom att initiera datainfogning i vår tabell i 10 parallella trådar (testdata som genereras av graf (1) används)

3) Graf mdw_load.regular.current.dev42_1_db_usl_testing_subj_org_finval.pset – en graf som genereras av MDW för inkrementell uppdatering av vår tabell i 10 parallella trådar med hjälp av en del av nyligen mottagen data (delta) genererad av graf (1)

Låt oss köra skriptet nedan i NRT-läge:

• generera 6 000 000 testrader
• utför en initial laddning, infoga 6 000 000 testrader i en tom tabell
• upprepa inkrementell nedladdning 5 gånger
  • generera 6 000 000 testrader
  • utför en inkrementell infogning av 6 000 000 testrader i tabellen (i det här fallet sätts giltighetstiden för valid_to_ts till den gamla data och nyare data med samma primärnyckel infogas)

Det här scenariot emulerar det verkliga driftsättet för ett visst affärssystem - en ganska stor del av ny data dyker upp i realtid och hälls omedelbart in i GreenPlum.

Låt oss nu titta på skriptets logg:

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

Det visar sig denna bild:

Diagrammet
Starttid
Sluttid
Längd

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 att 6 000 000 inkrementrader bearbetas på 3 minuter, vilket är ganska snabbt.
Uppgifterna i måltabellen visade sig vara fördelade enligt följande:

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 överensstämmelsen mellan de infogade uppgifterna och tidpunkterna när graferna lanserades.
Detta innebär att du kan köra inkrementell laddning av data i GreenPlum i Ab Initio med en mycket hög frekvens och observera en hög hastighet för att infoga denna data i GreenPlum. Naturligtvis kommer det inte att vara möjligt att starta en gång i sekunden, eftersom Ab Initio, som alla ETL-verktyg, kräver tid för att "starta upp" när den startas.

Slutsats

Ab Initio används för närvarande på Sberbank för att bygga ett Unified Semantic Data Layer (ESS). Detta projekt innebär att bygga en enhetlig version av tillståndet för olika bankverksamhetsenheter. Information kommer från olika källor, vars repliker är framtagna på Hadoop. Utifrån affärsbehov utarbetas en datamodell och datatransformationer beskrivs. Ab Initio laddar in information i ESN och den nedladdade datan är inte bara av intresse för verksamheten i sig, utan fungerar också som en källa för att bygga datamarts. Samtidigt låter produktens funktionalitet använda olika system som mottagare (Hive, Greenplum, Teradata, Oracle), vilket gör det möjligt att enkelt förbereda data för en verksamhet i de olika format den kräver.

Ab Initios möjligheter är breda, till exempel gör det medföljande MDW-ramverket det möjligt att bygga tekniska och affärshistoriska data direkt. För utvecklare gör Ab Initio det möjligt att inte uppfinna hjulet på nytt, utan att använda många befintliga funktionella komponenter, som i huvudsak är bibliotek som behövs när man arbetar med data.

Författaren är expert inom det professionella samhället Sberbank SberProfi DWH/BigData. SberProfi DWH/BigData professionella community ansvarar för att utveckla kompetens inom områden som Hadoop-ekosystemet, Teradata, Oracle DB, GreenPlum, samt BI-verktyg Qlik, SAP BO, Tableau, etc.

Källa: will.com