Als je Sber-schalen hebt. Ab Initio gebruiken met Hive en GreenPlum

Enige tijd geleden stonden we voor de vraag om een ​​ETL-tool te kiezen voor het werken met Big Data. De eerder gebruikte Informatica BDM-oplossing beviel ons niet vanwege de beperkte functionaliteit. Het gebruik ervan is teruggebracht tot een raamwerk voor het starten van spark-submit-opdrachten. Er waren niet veel analogen op de markt die in principe konden werken met de hoeveelheid gegevens waarmee we dagelijks te maken hebben. Uiteindelijk hebben wij voor Ab Initio gekozen. Tijdens pilotdemonstraties vertoonde het product een zeer hoge gegevensverwerkingssnelheid. Er is bijna geen informatie over Ab Initio in het Russisch, dus besloten we om over onze ervaringen met Habré te praten.

Ab Initio heeft veel klassieke en ongebruikelijke transformaties, waarvan de code kan worden uitgebreid met behulp van zijn eigen PDL-taal. Voor een klein bedrijf zal zo'n krachtig hulpmiddel waarschijnlijk overdreven zijn, en de meeste mogelijkheden ervan kunnen duur en ongebruikt zijn. Maar als jouw schaal dichtbij die van Sberov ligt, dan kan Ab Initio interessant voor je zijn.

Het helpt een bedrijf om wereldwijd kennis te vergaren en een ecosysteem te ontwikkelen, en een ontwikkelaar om zijn vaardigheden in ETL te verbeteren, zijn kennis in de shell te verbeteren, biedt de mogelijkheid om de PDL-taal onder de knie te krijgen, geeft een visueel beeld van laadprocessen en vereenvoudigt de ontwikkeling vanwege de overvloed aan functionele componenten.

In dit bericht zal ik het hebben over de mogelijkheden van Ab Initio en vergelijkende kenmerken geven van zijn werk met Hive en GreenPlum.

• Beschrijving van het MDW-framework en werken aan de aanpassing ervan voor GreenPlum
• Ab Initio prestatievergelijking tussen Hive en GreenPlum
• Ab Initio werken met GreenPlum in Near Real Time-modus

De functionaliteit van dit product is zeer breed en vereist veel studietijd. Met de juiste werkvaardigheden en de juiste prestatie-instellingen zijn de resultaten van gegevensverwerking echter zeer indrukwekkend. Ab Initio gebruiken als ontwikkelaar kan een interessante ervaring opleveren. Dit is een nieuwe kijk op ETL-ontwikkeling, een hybride tussen een visuele omgeving en downloadontwikkeling in een scriptachtige taal.

Bedrijven ontwikkelen hun ecosystemen en deze tool komt meer dan ooit van pas. Met Ab Initio kunt u kennis over uw huidige bedrijf vergaren en deze kennis gebruiken om oude uit te breiden en nieuwe bedrijven te openen. Alternatieven voor Ab Initio zijn onder meer visuele ontwikkelomgevingen Informatica BDM en niet-visuele ontwikkelomgevingen Apache Spark.

Beschrijving van Ab Initio

Ab Initio is, net als andere ETL-tools, een verzameling producten.

Ab Initio GDE (Graphical Development Environment) is een omgeving voor de ontwikkelaar waarin hij datatransformaties configureert en deze verbindt met datastromen in de vorm van pijlen. In dit geval wordt een dergelijke reeks transformaties een grafiek genoemd:

De invoer- en uitvoerverbindingen van functionele componenten zijn poorten en bevatten velden die binnen transformaties zijn berekend. Verschillende grafieken die met elkaar zijn verbonden door stromen in de vorm van pijlen in de volgorde van uitvoering, worden een plan genoemd.

Er zijn enkele honderden functionele componenten, wat veel is. Velen van hen zijn zeer gespecialiseerd. De mogelijkheden van klassieke transformaties in Ab Initio zijn breder dan in andere ETL-tools. Join heeft bijvoorbeeld meerdere uitgangen. Naast het resultaat van het verbinden van gegevenssets, kunt u uitvoerrecords verkrijgen van invoergegevenssets waarvan de sleutels niet konden worden verbonden. U kunt ook afwijzingen, fouten en een logboek van de transformatiebewerking krijgen, dat in dezelfde kolom als een tekstbestand kan worden gelezen en met andere transformaties kan worden verwerkt:

Of u kunt bijvoorbeeld een gegevensontvanger materialiseren in de vorm van een tabel en de gegevens daaruit in dezelfde kolom lezen.

Er zijn originele transformaties. De Scan-transformatie heeft bijvoorbeeld functionaliteit die vergelijkbaar is met analytische functies. Er zijn transformaties met voor zichzelf sprekende namen: Gegevens maken, Excel lezen, Normaliseren, Sorteren binnen groepen, Programma uitvoeren, SQL uitvoeren, Samenvoegen met DB, enz. Grafieken kunnen runtimeparameters gebruiken, inclusief de mogelijkheid om parameters van of naar door te geven het besturingssysteem. Bestanden met een kant-en-klare set parameters die aan de grafiek worden doorgegeven, worden parametersets (psets) genoemd.

Zoals verwacht heeft Ab Initio GDE een eigen repository genaamd EME (Enterprise Meta Environment). Ontwikkelaars hebben de mogelijkheid om met lokale codeversies te werken en hun ontwikkelingen in de centrale repository in te checken.

Het is mogelijk om tijdens de uitvoering of na het uitvoeren van de grafiek op een willekeurige stroom te klikken die de transformatie verbindt en de gegevens te bekijken die tussen deze transformaties zijn doorgegeven:

Het is ook mogelijk om op een willekeurige stream te klikken en trackingdetails te bekijken: in hoeveel parallellen de transformatie heeft gewerkt, hoeveel lijnen en bytes zijn geladen in welke van de parallellen:

Het is mogelijk om de uitvoering van de grafiek in fasen te verdelen en aan te geven dat sommige transformaties eerst moeten worden uitgevoerd (in de nulfase), de volgende in de eerste fase, de volgende in de tweede fase, enz.

Voor elke transformatie kunt u de zogenaamde lay-out kiezen (waar deze wordt uitgevoerd): zonder parallellen of in parallelle threads, waarvan het aantal kan worden opgegeven. Tegelijkertijd kunnen tijdelijke bestanden die Ab Initio aanmaakt wanneer transformaties worden uitgevoerd, zowel in het serverbestandssysteem als in HDFS worden geplaatst.

Bij elke transformatie kunt u, op basis van het standaardsjabloon, uw eigen script in PDL maken, dat een beetje op een shell lijkt.

Met PDL kunt u de functionaliteit van transformaties uitbreiden en kunt u met name dynamisch (tijdens runtime) willekeurige codefragmenten genereren, afhankelijk van runtimeparameters.

Ab Initio heeft ook een goed ontwikkelde integratie met het besturingssysteem via shell. Concreet gebruikt Sberbank linux ksh. U kunt variabelen uitwisselen met de shell en deze gebruiken als grafiekparameters. U kunt de uitvoering van Ab Initio-grafieken vanuit de shell oproepen en Ab Initio beheren.

Naast Ab Initio GDE zijn er nog vele andere producten bij de levering inbegrepen. Er is een eigen Coöperatiesysteem dat claimt een besturingssysteem te worden genoemd. Er is een Control>Center waar u downloadstromen kunt plannen en monitoren. Er zijn producten waarmee ontwikkeling op een primitiever niveau kan worden uitgevoerd dan Ab Initio GDE toestaat.

Beschrijving van het MDW-framework en werken aan de aanpassing ervan voor GreenPlum

Naast zijn producten levert de leverancier het MDW-product (Metadata Driven Warehouse), een grafiekconfigurator die is ontworpen om te helpen bij typische taken van het vullen van datawarehouses of datakluisjes.

Het bevat op maat gemaakte (projectspecifieke) metadataparsers en kant-en-klare codegeneratoren.

Als invoer ontvangt MDW een datamodel, een configuratiebestand voor het opzetten van een verbinding met een database (Oracle, Teradata of Hive) en enkele andere instellingen. Het projectspecifieke deel implementeert het model bijvoorbeeld in een database. Het kant-en-klare deel van het product genereert grafieken en configuratiebestanden voor hen door gegevens in modeltabellen te laden. In dit geval worden grafieken (en psets) gemaakt voor verschillende manieren van initialiseren en incrementeel werk aan het bijwerken van entiteiten.

In het geval van Hive en RDBMS worden verschillende grafieken gegenereerd voor initialisatie en incrementele gegevensupdates.

In het geval van Hive worden de binnenkomende deltadata via Ab Initio Join verbonden met de data die vóór de update in de tabel stonden. Gegevensladers in MDW (zowel in Hive als RDBMS) voegen niet alleen nieuwe gegevens uit de delta in, maar sluiten ook de perioden van relevantie af van de gegevens waarvan de primaire sleutels de delta hebben ontvangen. Bovendien moet u het ongewijzigde deel van de gegevens herschrijven. Maar dit moet worden gedaan omdat Hive geen verwijder- of updatebewerkingen heeft.

In het geval van RDBMS zien grafieken voor incrementele gegevensupdates er optimaal uit, omdat RDBMS echte updatemogelijkheden hebben.

De ontvangen delta wordt in een tussentabel in de database geladen. Hierna wordt de delta verbonden met de gegevens die vóór de update in de tabel stonden. En dit gebeurt met behulp van SQL met behulp van een gegenereerde SQL-query. Vervolgens worden met behulp van de SQL-opdrachten delete+insert nieuwe gegevens uit de delta ingevoegd in de doeltabel en worden de perioden van relevantie van de gegevens waarvan de primaire sleutels de delta hebben ontvangen, gesloten.
Het is niet nodig om ongewijzigde gegevens te herschrijven.

We kwamen dus tot de conclusie dat MDW in het geval van Hive de hele tabel moet herschrijven omdat Hive geen updatefunctie heeft. En niets beters dan de gegevens volledig te herschrijven wanneer het updaten is uitgevonden. In het geval van RDBMS vonden de makers van het product het daarentegen noodzakelijk om de verbinding en het bijwerken van tabellen toe te vertrouwen aan het gebruik van SQL.

Voor een project bij Sberbank hebben we een nieuwe, herbruikbare implementatie van een databaseloader voor GreenPlum gemaakt. Dit is gedaan op basis van de versie die MDW voor Teradata genereert. Het was Teradata, en niet Oracle, die hierin het dichtst en het beste kwam, omdat... is eveneens een MPP-systeem. De werkwijze, maar ook de syntaxis, van Teradata en GreenPlum bleken vergelijkbaar.

Voorbeelden van MDW-kritieke verschillen tussen verschillende RDBMS's zijn als volgt. In GreenPlum moet je, in tegenstelling tot Teradata, bij het maken van tabellen een clausule schrijven

distributed by

Teradata schrijft:

delete <table> all

, en in GreenPlum schrijven ze

delete from <table>

In Oracle schrijven ze voor optimalisatiedoeleinden

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

, en Teradata en GreenPlum schrijven

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

We merken ook op dat het voor Ab Initio om met GreenPlum te werken noodzakelijk was om de GreenPlum-client op alle knooppunten van het Ab Initio-cluster te installeren. Dit komt omdat we vanaf alle knooppunten in ons cluster tegelijkertijd verbinding hebben gemaakt met GreenPlum. En om het lezen van GreenPlum parallel te laten verlopen en elke parallelle Ab Initio-thread zijn eigen deel van de gegevens uit GreenPlum te laten lezen, moesten we een constructie plaatsen die door Ab Initio werd begrepen in het 'waar'-gedeelte van SQL-query's

where ABLOCAL()

en bepaal de waarde van deze constructie door de parameterwaarde uit de transformatiedatabase op te geven

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

, die compileert naar zoiets als

mod(sk,10)=3

, d.w.z. je moet GreenPlum vragen om een ​​expliciet filter voor elke partitie. Voor andere databases (Teradata, Oracle) kan Ab Initio deze parallellisatie automatisch uitvoeren.

Ab Initio prestatievergelijking tussen Hive en GreenPlum

Sberbank voerde een experiment uit om de prestaties van MDW-gegenereerde grafieken in relatie tot Hive en in relatie tot GreenPlum te vergelijken. Als onderdeel van het experiment waren er in het geval van Hive vijf knooppunten op hetzelfde cluster als Ab Initio, en in het geval van GreenPlum waren er vier knooppunten op een afzonderlijk cluster. Die. Hive had wat hardwarevoordeel ten opzichte van GreenPlum.

We hebben twee paar grafieken overwogen die dezelfde taak uitvoerden: het bijwerken van gegevens in Hive en GreenPlum. Tegelijkertijd werden de grafieken gelanceerd die door de MDW-configurator werden gegenereerd:

• initiële belasting + incrementele belasting van willekeurig gegenereerde gegevens in een Hive-tabel
• initiële belasting + incrementele belasting van willekeurig gegenereerde gegevens in dezelfde GreenPlum-tabel

In beide gevallen (Hive en GreenPlum) voerden ze uploads uit naar 10 parallelle threads op hetzelfde Ab Initio-cluster. Ab Initio bewaarde tussentijdse gegevens voor berekeningen in HDFS (in termen van Ab Initio werd een MFS-indeling met HDFS gebruikt). In beide gevallen besloeg één regel willekeurig gegenereerde gegevens 200 bytes.

Het resultaat was als volgt:

Bijenkorf:

Eerste keer laden in Hive

Rijen ingevoegd
6 000 000
60 000 000
600 000 000

Initialisatieduur
downloads in seconden
41
203
1 601

Incrementeel laden in Hive

Aantal rijen beschikbaar in
doeltabel aan het begin van het experiment
6 000 000
60 000 000
600 000 000

Aantal deltalijnen toegepast
doeltabel tijdens het experiment
6 000 000
6 000 000
6 000 000

Duur van incrementeel
downloads in seconden
88
299
2 541

GroenPruim:

Eerste keer laden in GreenPlum

Rijen ingevoegd
6 000 000
60 000 000
600 000 000

Initialisatieduur
downloads in seconden
72
360
3 631

Incrementeel laden in GreenPlum

Aantal rijen beschikbaar in
doeltabel aan het begin van het experiment
6 000 000
60 000 000
600 000 000

Aantal deltalijnen toegepast
doeltabel tijdens het experiment
6 000 000
6 000 000
6 000 000

Duur van incrementeel
downloads in seconden
159
199
321

We zien dat de snelheid van het aanvankelijk laden in zowel Hive als GreenPlum lineair afhangt van de hoeveelheid gegevens en, om redenen van betere hardware, iets sneller is voor Hive dan voor GreenPlum.

Incrementeel laden in Hive is ook lineair afhankelijk van het volume van eerder geladen gegevens dat beschikbaar is in de doeltabel en verloopt vrij langzaam naarmate het volume groeit. Dit wordt veroorzaakt door de noodzaak om de doeltabel volledig te herschrijven. Dit betekent dat het toepassen van kleine wijzigingen in grote tabellen geen goed gebruik is voor Hive.

Incrementeel laden in GreenPlum is zwak afhankelijk van de hoeveelheid eerder geladen gegevens die beschikbaar zijn in de doeltabel en verloopt vrij snel. Dit gebeurde dankzij SQL Joins en de GreenPlum-architectuur, die de verwijderbewerking mogelijk maakt.

GreenPlum voegt dus de delta toe met behulp van de delete+insert-methode, maar Hive heeft geen verwijder- of updatebewerkingen, dus de hele data-array moest tijdens een incrementele update volledig worden herschreven. De vergelijking van de vetgedrukte cellen is het meest onthullend, omdat deze overeenkomt met de meest gebruikelijke optie voor het gebruik van resource-intensieve downloads. We zien dat GreenPlum Hive in deze test 8 keer versloeg.

Ab Initio werken met GreenPlum in Near Real Time-modus

In dit experiment testen we het vermogen van Ab Initio om de GreenPlum-tabel bijna in realtime bij te werken met willekeurig gegenereerde gegevensbrokken. Laten we eens kijken naar de GreenPlum-tabel dev42_1_db_usl.TESTING_SUBJ_org_finval, waarmee we zullen werken.

We zullen drie Ab Initio-grafieken gebruiken om ermee te werken:

1) Graph Create_test_data.mp – creëert gegevensbestanden in HDFS met 10 rijen in 6 parallelle threads. De gegevens zijn willekeurig, de structuur ervan is georganiseerd voor invoeging in onze tabel

2) Grafiek mdw_load.day_one.current.dev42_1_db_usl_testing_subj_org_finval.pset – MDW gegenereerde grafiek door het invoegen van gegevens in onze tabel in 10 parallelle threads te initialiseren (testgegevens gegenereerd door grafiek (1) worden gebruikt)

3) Grafiek mdw_load.regular.current.dev42_1_db_usl_testing_subj_org_finval.pset – een grafiek gegenereerd door MDW voor het incrementeel bijwerken van onze tabel in 10 parallelle threads met behulp van een deel van de nieuw ontvangen gegevens (delta) gegenereerd door grafiek (1)

Laten we het onderstaande script uitvoeren in de NRT-modus:

• 6 testlijnen genereren
• voer een initiële belasting uit en plaats 6 testrijen in een lege tabel
• herhaal de incrementele download 5 keer
  • 6 testlijnen genereren
  • een incrementele invoeging van 6 testrijen in de tabel uitvoeren (in dit geval wordt de vervaltijd van valid_to_ts ingesteld op de oude gegevens en worden recentere gegevens met dezelfde primaire sleutel ingevoegd)

Dit scenario emuleert de werkelijke werking van een bepaald bedrijfssysteem: een vrij groot deel van de nieuwe gegevens verschijnt in realtime en wordt onmiddellijk in GreenPlum gegoten.

Laten we nu eens kijken naar het logboek van het script:

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

Het blijkt deze foto:

Diagram
Begintijd
Eindtijd
Lengte

Maak_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

Maak_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

Maak_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

Maak_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

Maak_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

Maak_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

We zien dat in 6 minuten 000 ophoogregels worden verwerkt, wat behoorlijk snel is.
De gegevens in de doeltabel bleken als volgt verdeeld:

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;

U kunt de overeenkomst zien tussen de ingevoegde gegevens en de tijden waarop de grafieken zijn gelanceerd.
Dit betekent dat u met een zeer hoge frequentie stapsgewijs gegevens in GreenPlum in Ab Initio kunt laden en een hoge snelheid kunt waarnemen bij het invoegen van deze gegevens in GreenPlum. Het zal natuurlijk niet mogelijk zijn om één keer per seconde te starten, omdat Ab Initio, net als elke andere ETL-tool, tijd nodig heeft om te ‘opstarten’ wanneer het wordt gelanceerd.

Conclusie

Ab Initio wordt momenteel bij Sberbank gebruikt om een ​​Unified Semantic Data Layer (ESS) te bouwen. Dit project omvat het bouwen van een uniforme versie van de toestand van verschillende bancaire bedrijfsentiteiten. Informatie komt uit verschillende bronnen, waarvan de replica’s op Hadoop worden gemaakt. Op basis van de bedrijfsbehoeften wordt een datamodel opgesteld en worden datatransformaties beschreven. Ab Initio laadt informatie in het ESN en de gedownloade gegevens zijn niet alleen interessant voor het bedrijf zelf, maar dienen ook als bron voor het bouwen van datamarts. Tegelijkertijd maakt de functionaliteit van het product het mogelijk om verschillende systemen als ontvanger te gebruiken (Hive, Greenplum, Teradata, Oracle), waardoor het mogelijk wordt om eenvoudig gegevens voor een bedrijf klaar te maken in de verschillende formaten die het nodig heeft.

De mogelijkheden van Ab Initio zijn breed; het meegeleverde MDW-framework maakt het bijvoorbeeld mogelijk om technische en bedrijfshistorische gegevens out-of-the-box op te bouwen. Voor ontwikkelaars maakt Ab Initio het mogelijk om het wiel niet opnieuw uit te vinden, maar om veel bestaande functionele componenten te gebruiken, die in wezen bibliotheken zijn die nodig zijn bij het werken met data.

De auteur is een expert in de professionele gemeenschap van Sberbank SberProfi DWH/BigData. De professionele gemeenschap van SberProfi DWH/BigData is verantwoordelijk voor het ontwikkelen van competenties op gebieden als het Hadoop-ecosysteem, Teradata, Oracle DB, GreenPlum, evenals BI-tools Qlik, SAP BO, Tableau, enz.

Bron: www.habr.com