Lorsque vous avez des balances Sber. Utiliser Ab Initio avec Hive et GreenPlum

Il y a quelque temps, nous étions confrontés à la question du choix d'un outil ETL pour travailler avec le Big Data. La solution Informatica BDM utilisée précédemment ne nous convenait pas en raison de fonctionnalités limitées. Son utilisation a été réduite à un framework pour lancer des commandes spark-submit. Il n'y avait pas beaucoup d'analogues sur le marché qui étaient, en principe, capables de travailler avec le volume de données que nous traitons quotidiennement. Finalement, nous avons choisi Ab Initio. Lors des démonstrations pilotes, le produit a montré une vitesse de traitement des données très élevée. Il n'y a presque aucune information sur Ab Initio en russe, nous avons donc décidé de parler de notre expérience sur Habré.

Ab Initio propose de nombreuses transformations classiques et inhabituelles, dont le code peut être étendu à l'aide de son propre langage PDL. Pour une petite entreprise, un outil aussi puissant sera probablement excessif et la plupart de ses fonctionnalités risquent d’être coûteuses et inutilisées. Mais si votre échelle est proche de celle de Sberov, alors Ab Initio pourrait vous intéresser.

Il aide une entreprise à accumuler des connaissances à l'échelle mondiale et à développer un écosystème, et un développeur à améliorer ses compétences en ETL, à améliorer ses connaissances dans le shell, offre la possibilité de maîtriser le langage PDL, donne une image visuelle des processus de chargement et simplifie le développement. en raison de l'abondance de composants fonctionnels.

Dans cet article, je parlerai des capacités d'Ab Initio et fournirai des caractéristiques comparatives de son travail avec Hive et GreenPlum.

• Description du framework MDW et travail sur sa personnalisation pour GreenPlum
• Comparaison des performances Ab Initio entre Hive et GreenPlum
• Travailler Ab Initio avec GreenPlum en mode temps quasi réel

Les fonctionnalités de ce produit sont très larges et nécessitent beaucoup de temps pour être étudiées. Cependant, avec les compétences professionnelles appropriées et les paramètres de performances appropriés, les résultats du traitement des données sont très impressionnants. Utiliser Ab Initio pour un développeur peut offrir une expérience intéressante. Il s'agit d'une nouvelle approche du développement ETL, un hybride entre un environnement visuel et le développement de téléchargement dans un langage de type script.

Les entreprises développent leurs écosystèmes et cet outil est plus que jamais utile. Avec Ab Initio, vous pouvez accumuler des connaissances sur votre entreprise actuelle et utiliser ces connaissances pour développer d'anciennes entreprises et en ouvrir de nouvelles. Les alternatives à Ab Initio incluent les environnements de développement visuels Informatica BDM et les environnements de développement non visuels Apache Spark.

Description d'Ab Initio

Ab Initio, comme les autres outils ETL, est un ensemble de produits.

Ab Initio GDE (Graphical Development Environment) est un environnement pour le développeur dans lequel il configure les transformations de données et les connecte avec des flux de données sous forme de flèches. Dans ce cas, un tel ensemble de transformations est appelé un graphe :

Les connexions d'entrée et de sortie des composants fonctionnels sont des ports et contiennent des champs calculés dans les transformations. Plusieurs graphiques reliés par des flux sous forme de flèches dans l'ordre de leur exécution sont appelés un plan.

Il existe plusieurs centaines de composants fonctionnels, ce qui est beaucoup. Beaucoup d’entre eux sont hautement spécialisés. Les capacités des transformations classiques dans Ab Initio sont plus larges que dans les autres outils ETL. Par exemple, Join a plusieurs sorties. En plus du résultat de la connexion des ensembles de données, vous pouvez obtenir des enregistrements de sortie d'ensembles de données d'entrée dont les clés n'ont pas pu être connectées. Vous pouvez également obtenir des rejets, des erreurs et un journal de l'opération de transformation, qui peut être lu dans la même colonne qu'un fichier texte et traité avec d'autres transformations :

Ou, par exemple, vous pouvez matérialiser un récepteur de données sous la forme d'un tableau et en lire les données dans la même colonne.

Il y a des transformations originales. Par exemple, la transformation Scan possède des fonctionnalités similaires aux fonctions analytiques. Il existe des transformations avec des noms explicites : Créer des données, Lire Excel, Normaliser, Trier au sein de groupes, Exécuter un programme, Exécuter SQL, Joindre avec une base de données, etc. Les graphiques peuvent utiliser des paramètres d'exécution, y compris la possibilité de transmettre des paramètres depuis ou vers le système d'exploitation. Les fichiers contenant un ensemble de paramètres prêts à l'emploi transmis au graphique sont appelés ensembles de paramètres (psets).

Comme prévu, Ab Initio GDE possède son propre référentiel appelé EME (Enterprise Meta Environment). Les développeurs ont la possibilité de travailler avec des versions locales du code et d'enregistrer leurs développements dans le référentiel central.

Il est possible, pendant l'exécution ou après l'exécution du graphe, de cliquer sur n'importe quel flux reliant la transformation et de regarder les données qui sont passées entre ces transformations :

Il est également possible de cliquer sur n'importe quel flux et de voir les détails du suivi - dans combien de parallèles la transformation a fonctionné, combien de lignes et d'octets ont été chargés dans quels parallèles :

Il est possible de diviser l'exécution du graphique en phases et de marquer que certaines transformations doivent être effectuées en premier (dans la phase zéro), les suivantes dans la première phase, les suivantes dans la deuxième phase, etc.

Pour chaque transformation, vous pouvez choisir ce qu'on appelle la mise en page (où elle sera exécutée) : sans parallèles ou en threads parallèles, dont le nombre peut être précisé. Dans le même temps, les fichiers temporaires créés par Ab Initio lors de l'exécution des transformations peuvent être placés à la fois dans le système de fichiers du serveur et dans HDFS.

Dans chaque transformation, en fonction du modèle par défaut, vous pouvez créer votre propre script en PDL, qui ressemble un peu à un shell.

Avec PDL, vous pouvez étendre les fonctionnalités des transformations et, en particulier, vous pouvez générer dynamiquement (au moment de l'exécution) des fragments de code arbitraires en fonction des paramètres d'exécution.

Ab Initio dispose également d'une intégration bien développée avec le système d'exploitation via le shell. Plus précisément, Sberbank utilise Linux KSH. Vous pouvez échanger des variables avec le shell et les utiliser comme paramètres graphiques. Vous pouvez appeler l'exécution des graphiques Ab Initio depuis le shell et administrer Ab Initio.

En plus d'Ab Initio GDE, de nombreux autres produits sont inclus dans la livraison. Il existe son propre système de coopération qui prétend être appelé système d'exploitation. Il existe un Control>Center où vous pouvez planifier et surveiller les flux de téléchargement. Il existe des produits permettant d'effectuer du développement à un niveau plus primitif que ce que permet Ab Initio GDE.

Description du framework MDW et travail sur sa personnalisation pour GreenPlum

Parallèlement à ses produits, le fournisseur fournit le produit MDW (Metadata Driven Warehouse), qui est un configurateur de graphiques conçu pour faciliter les tâches typiques de remplissage d'entrepôts de données ou de coffres-forts de données.

Il contient des analyseurs de métadonnées personnalisés (spécifiques au projet) et des générateurs de code prêts à l'emploi.

En entrée, MDW reçoit un modèle de données, un fichier de configuration pour établir une connexion à une base de données (Oracle, Teradata ou Hive) et quelques autres paramètres. La partie spécifique au projet, par exemple, déploie le modèle dans une base de données. La partie prête à l'emploi du produit génère des graphiques et des fichiers de configuration en chargeant les données dans des tables de modèles. Dans ce cas, des graphiques (et des psets) sont créés pour plusieurs modes d'initialisation et de travail incrémentiel de mise à jour des entités.

Dans le cas de Hive et du SGBDR, différents graphiques sont générés pour l'initialisation et les mises à jour incrémentielles des données.

Dans le cas de Hive, les données delta entrantes sont connectées via Ab Initio Join aux données qui se trouvaient dans la table avant la mise à jour. Les chargeurs de données dans MDW (à la fois dans Hive et dans RDBMS) insèrent non seulement de nouvelles données du delta, mais ferment également les périodes de pertinence des données dont les clés primaires ont reçu le delta. De plus, vous devez réécrire la partie inchangée des données. Mais cela doit être fait car Hive n'a pas d'opérations de suppression ou de mise à jour.

Dans le cas des SGBDR, les graphiques pour la mise à jour incrémentielle des données semblent plus optimaux, car les SGBDR ont de réelles capacités de mise à jour.

Le delta reçu est chargé dans une table intermédiaire de la base de données. Après cela, le delta est connecté aux données qui se trouvaient dans la table avant la mise à jour. Et cela se fait en utilisant SQL à l'aide d'une requête SQL générée. Ensuite, à l'aide des commandes SQL delete+insert, les nouvelles données du delta sont insérées dans la table cible et les périodes de pertinence des données dont les clés primaires ont reçu le delta sont fermées.
Il n'est pas nécessaire de réécrire les données inchangées.

Nous sommes donc arrivés à la conclusion que dans le cas de Hive, MDW doit réécrire la table entière car Hive n'a pas de fonction de mise à jour. Et rien de mieux que de réécrire complètement les données lorsque la mise à jour a été inventée. Dans le cas du SGBDR, au contraire, les créateurs du produit ont jugé nécessaire de confier la connexion et la mise à jour des tables à l'utilisation de SQL.

Pour un projet chez Sberbank, nous avons créé une nouvelle implémentation réutilisable d'un chargeur de base de données pour GreenPlum. Cela a été fait sur la base de la version générée par MDW pour Teradata. C'est Teradata, et non Oracle, qui s'en rapproche le plus et le meilleur, car... est également un système MPP. Les méthodes de travail ainsi que la syntaxe de Teradata et de GreenPlum se sont révélées similaires.

Des exemples de différences critiques pour MDW entre différents SGBDR sont les suivants. Dans GreenPlum, contrairement à Teradata, lors de la création de tables, vous devez écrire une clause

distributed by

Teradata écrit :

delete <table> all

, et dans GreenPlum ils écrivent

delete from <table>

Dans Oracle, à des fins d'optimisation, ils écrivent

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

, et Teradata et GreenPlum écrivent

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

Notons également que pour qu'Ab Initio fonctionne avec GreenPlum, il était nécessaire d'installer le client GreenPlum sur tous les nœuds du cluster Ab Initio. En effet, nous nous sommes connectés à GreenPlum simultanément à partir de tous les nœuds de notre cluster. Et pour que la lecture depuis GreenPlum soit parallèle et que chaque thread Ab Initio parallèle puisse lire sa propre partie des données depuis GreenPlum, nous avons dû placer une construction comprise par Ab Initio dans la section « où » des requêtes SQL.

where ABLOCAL()

et déterminer la valeur de cette construction en précisant le paramètre de lecture de la base de données de transformation

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

, qui se compile en quelque chose comme

mod(sk,10)=3

, c'est à dire. vous devez demander à GreenPlum un filtre explicite pour chaque partition. Pour les autres bases de données (Teradata, Oracle), Ab Initio peut effectuer cette parallélisation automatiquement.

Comparaison des performances Ab Initio entre Hive et GreenPlum

Sberbank a mené une expérience pour comparer les performances des graphiques générés par MDW par rapport à Hive et par rapport à GreenPlum. Dans le cadre de l'expérience, dans le cas de Hive, il y avait 5 nœuds sur le même cluster qu'Ab Initio, et dans le cas de GreenPlum, il y avait 4 nœuds sur un cluster distinct. Ceux. Hive avait un certain avantage matériel sur GreenPlum.

Nous avons considéré deux paires de graphiques effectuant la même tâche de mise à jour des données dans Hive et GreenPlum. Parallèlement, les graphiques générés par le configurateur MDW ont été lancés :

• chargement initial + chargement incrémentiel de données générées aléatoirement dans une table Hive
• chargement initial + chargement incrémentiel de données générées aléatoirement dans la même table GreenPlum

Dans les deux cas (Hive et GreenPlum), ils ont effectué des téléchargements vers 10 threads parallèles sur le même cluster Ab Initio. Ab Initio a enregistré les données intermédiaires pour les calculs dans HDFS (dans le cadre d'Ab Initio, la présentation MFS utilisant HDFS a été utilisée). Une ligne de données générées aléatoirement occupait 200 octets dans les deux cas.

Le résultat était comme ceci :

Ruche:

Chargement initial dans Hive

Lignes insérées
+6 (000)000
+60 (000)000
+600 (000)000

Durée d'initialisation
téléchargements en quelques secondes
41
203
+1 (601)XNUMX XNUMX

Chargement incrémentiel dans Hive

Nombre de lignes disponibles dans
table cible au début de l'expérience
+6 (000)000
+60 (000)000
+600 (000)000

Nombre de lignes delta appliquées à
table cible pendant l'expérience
+6 (000)000
+6 (000)000
+6 (000)000

Durée de l'incrément
téléchargements en quelques secondes
88
299
+2 (541)XNUMX XNUMX

Prune Verte :

Chargement initial dans GreenPlum

Lignes insérées
+6 (000)000
+60 (000)000
+600 (000)000

Durée d'initialisation
téléchargements en quelques secondes
72
360
+3 (631)XNUMX XNUMX

Chargement incrémentiel dans GreenPlum

Nombre de lignes disponibles dans
table cible au début de l'expérience
+6 (000)000
+60 (000)000
+600 (000)000

Nombre de lignes delta appliquées à
table cible pendant l'expérience
+6 (000)000
+6 (000)000
+6 (000)000

Durée de l'incrément
téléchargements en quelques secondes
159
199
321

Nous voyons que la vitesse de chargement initial dans Hive et GreenPlum dépend linéairement de la quantité de données et, pour des raisons de meilleur matériel, elle est légèrement plus rapide pour Hive que pour GreenPlum.

Le chargement incrémentiel dans Hive dépend également de manière linéaire du volume de données précédemment chargées disponibles dans la table cible et se déroule assez lentement à mesure que le volume augmente. Cela est dû à la nécessité de réécrire complètement la table cible. Cela signifie qu’appliquer de petites modifications à de grandes tables n’est pas un bon cas d’utilisation pour Hive.

Le chargement incrémentiel dans GreenPlum dépend faiblement du volume de données précédemment chargées disponibles dans la table cible et se déroule assez rapidement. Cela s'est produit grâce aux jointures SQL et à l'architecture GreenPlum, qui permet l'opération de suppression.

Ainsi, GreenPlum ajoute le delta à l'aide de la méthode delete+insert, mais Hive n'a pas d'opérations de suppression ou de mise à jour, donc l'ensemble du tableau de données a été forcé d'être entièrement réécrit lors d'une mise à jour incrémentielle. La comparaison des cellules surlignées en gras est des plus révélatrices, puisqu'elle correspond à l'option la plus courante pour utiliser des téléchargements gourmands en ressources. Nous voyons que GreenPlum a battu Hive dans ce test par 8 fois.

Travailler Ab Initio avec GreenPlum en mode temps quasi réel

Dans cette expérience, nous testerons la capacité d'Ab Initio à mettre à jour la table GreenPlum avec des blocs de données générés aléatoirement en temps quasi réel. Considérons la table GreenPlum dev42_1_db_usl.TESTING_SUBJ_org_finval, avec laquelle nous allons travailler.

Nous utiliserons trois graphiques Ab Initio pour travailler avec :

1) Graph Create_test_data.mp – crée des fichiers de données dans HDFS avec 10 6 000 de lignes dans 000 threads parallèles. Les données sont aléatoires, leur structure est organisée pour être insérée dans notre tableau

2) Graphique mdw_load.day_one.current.dev42_1_db_usl_testing_subj_org_finval.pset – Graphique généré par MDW en initialisant l'insertion des données dans notre table dans 10 threads parallèles (les données de test générées par le graphique (1) sont utilisées)

3) Graphique mdw_load.regular.current.dev42_1_db_usl_testing_subj_org_finval.pset – un graphique généré par MDW pour la mise à jour incrémentielle de notre table dans 10 threads parallèles en utilisant une partie des données fraîchement reçues (delta) générées par le graphique (1)

Exécutons le script ci-dessous en mode NRT :

• générer 6 000 000 de lignes de test
• effectuer un chargement initial insérer 6 000 000 de lignes de test dans une table vide
• répéter le téléchargement incrémentiel 5 fois
  • générer 6 000 000 de lignes de test
  • effectuer une insertion incrémentielle de 6 000 000 de lignes de test dans la table (dans ce cas, le délai d'expiration valid_to_ts est défini sur les anciennes données et des données plus récentes avec la même clé primaire sont insérées)

Ce scénario émule le mode de fonctionnement réel d'un certain système d'entreprise - une assez grande partie des nouvelles données apparaît en temps réel et est immédiatement déversée dans GreenPlum.

Regardons maintenant le journal du script :

Démarrez Create_test_data.input.pset le 2020/06/04 à 11:49:11
Terminez Create_test_data.input.pset le 2020/06/04 à 11:49:37
Démarrez mdw_load.day_one.current.dev42_1_db_usl_testing_subj_org_finval.pset le 2020/06/04 à 11:49:37
Terminez mdw_load.day_one.current.dev42_1_db_usl_testing_subj_org_finval.pset le 2020/06/04 à 11:50:42
Démarrez Create_test_data.input.pset le 2020/06/04 à 11:50:42
Terminez Create_test_data.input.pset le 2020/06/04 à 11:51:06
Démarrez mdw_load.regular.current.dev42_1_db_usl_testing_subj_org_finval.pset le 2020/06/04 à 11:51:06
Terminez mdw_load.regular.current.dev42_1_db_usl_testing_subj_org_finval.pset le 2020/06/04 à 11:53:41
Démarrez Create_test_data.input.pset le 2020/06/04 à 11:53:41
Terminez Create_test_data.input.pset le 2020/06/04 à 11:54:04
Démarrez mdw_load.regular.current.dev42_1_db_usl_testing_subj_org_finval.pset le 2020/06/04 à 11:54:04
Terminez mdw_load.regular.current.dev42_1_db_usl_testing_subj_org_finval.pset le 2020/06/04 à 11:56:51
Démarrez Create_test_data.input.pset le 2020/06/04 à 11:56:51
Terminez Create_test_data.input.pset le 2020/06/04 à 11:57:14
Démarrez mdw_load.regular.current.dev42_1_db_usl_testing_subj_org_finval.pset le 2020/06/04 à 11:57:14
Terminez mdw_load.regular.current.dev42_1_db_usl_testing_subj_org_finval.pset le 2020/06/04 à 11:59:55
Démarrez Create_test_data.input.pset le 2020/06/04 à 11:59:55
Terminez Create_test_data.input.pset le 2020/06/04 à 12:00:23
Démarrez mdw_load.regular.current.dev42_1_db_usl_testing_subj_org_finval.pset le 2020/06/04 à 12:00:23
Terminez mdw_load.regular.current.dev42_1_db_usl_testing_subj_org_finval.pset le 2020/06/04 à 12:03:23
Démarrez Create_test_data.input.pset le 2020/06/04 à 12:03:23
Terminez Create_test_data.input.pset le 2020/06/04 à 12:03:49
Démarrez mdw_load.regular.current.dev42_1_db_usl_testing_subj_org_finval.pset le 2020/06/04 à 12:03:49
Terminez mdw_load.regular.current.dev42_1_db_usl_testing_subj_org_finval.pset le 2020/06/04 à 12:06:46

Il s'avère que cette image :

Graphique
Heure de début
Heure de fin
Longueur

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

On voit que 6 000 000 de lignes d'incrément sont traitées en 3 minutes, ce qui est assez rapide.
Les données de la table cible se sont avérées réparties comme suit :

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;

Vous pouvez voir la correspondance des données insérées avec les heures de lancement des graphiques.
Cela signifie que vous pouvez exécuter un chargement incrémentiel de données dans GreenPlum dans Ab Initio à une fréquence très élevée et observer une vitesse élevée d'insertion de ces données dans GreenPlum. Bien entendu, il ne sera pas possible de se lancer une fois par seconde, car Ab Initio, comme tout outil ETL, met du temps à « démarrer » au lancement.

Conclusion

Ab Initio est actuellement utilisé à la Sberbank pour créer une couche de données sémantiques unifiée (ESS). Ce projet consiste à construire une version unifiée de l'état des différentes entités bancaires. Les informations proviennent de diverses sources, dont les répliques sont préparées sur Hadoop. En fonction des besoins de l'entreprise, un modèle de données est préparé et les transformations des données sont décrites. Ab Initio charge les informations dans l'ESN et les données téléchargées présentent non seulement un intérêt pour l'entreprise en soi, mais servent également de source pour créer des datamarts. Parallèlement, la fonctionnalité du produit permet d'utiliser différents systèmes comme récepteur (Hive, Greenplum, Teradata, Oracle), ce qui permet de préparer facilement les données d'une entreprise dans les différents formats dont elle a besoin.

Les capacités d'Ab Initio sont étendues ; par exemple, le framework MDW inclus permet de créer des données historiques techniques et commerciales prêtes à l'emploi. Pour les développeurs, Ab Initio permet de ne pas réinventer la roue, mais d'utiliser de nombreux composants fonctionnels existants, qui sont essentiellement des bibliothèques nécessaires pour travailler avec des données.

L'auteur est un expert de la communauté professionnelle de la Sberbank SberProfi DWH/BigData. La communauté professionnelle SberProfi DWH/BigData est chargée de développer des compétences dans des domaines tels que l'écosystème Hadoop, Teradata, Oracle DB, GreenPlum, ainsi que les outils BI Qlik, SAP BO, Tableau, etc.

Source: habr.com