Cando teñas escalas Sber. Usando Ab Initio con Hive e GreenPlum

Hai tempo, enfrontámonos á cuestión de escoller unha ferramenta ETL para traballar con Big Data. A solución Informatica BDM usada anteriormente non nos conveña debido a unha funcionalidade limitada. O seu uso reduciuse a un marco para lanzar comandos spark-submit. Non había moitos análogos no mercado que, en principio, fosen capaces de traballar co volume de datos co que tratamos cada día. Ao final escollemos Ab Initio. Durante as demostracións piloto, o produto mostrou unha velocidade de procesamento de datos moi alta. Case non hai información sobre Ab Initio en ruso, así que decidimos falar da nosa experiencia en Habré.

Ab Initio ten moitas transformacións clásicas e pouco comúns, cuxo código se pode ampliar mediante a súa propia linguaxe PDL. Para unha pequena empresa, unha ferramenta tan poderosa probablemente será excesiva e a maioría das súas capacidades poden ser caras e sen usar. Pero se a túa escala está próxima á de Sberov, entón Ab Initio pode ser interesante para ti.

Axuda a unha empresa a acumular coñecementos a nivel mundial e a desenvolver un ecosistema, e a un desenvolvedor a mellorar as súas habilidades en ETL, mellorar os seus coñecementos no shell, ofrece a oportunidade de dominar a linguaxe PDL, dá unha imaxe visual dos procesos de carga e simplifica o desenvolvemento. debido á abundancia de compoñentes funcionais.

Neste post falarei das capacidades de Ab Initio e ofrecerei características comparativas do seu traballo con Hive e GreenPlum.

• Descrición do framework MDW e traballo na súa personalización para GreenPlum
• Comparación do rendemento de Ab Initio entre Hive e GreenPlum
• Traballando ab Initio con GreenPlum en modo case tempo real

A funcionalidade deste produto é moi ampla e require moito tempo para estudar. Non obstante, coas habilidades de traballo adecuadas e a configuración de rendemento correcta, os resultados do procesamento de datos son moi impresionantes. Usar Ab Initio para un programador pode proporcionar unha experiencia interesante. Esta é unha nova versión do desenvolvemento de ETL, un híbrido entre un ambiente visual e o desenvolvemento de descargas nunha linguaxe de guión.

As empresas están a desenvolver os seus ecosistemas e esta ferramenta é máis útil que nunca. Con Ab Initio, podes acumular coñecementos sobre o teu negocio actual e utilizar estes coñecementos para ampliar e abrir novos negocios. As alternativas a Ab Initio inclúen entornos de desenvolvemento visual Informatica BDM e entornos de desenvolvemento non visuais Apache Spark.

Descrición de Ab Initio

Ab Initio, como outras ferramentas ETL, é unha colección de produtos.

Ab Initio GDE (Graphical Development Environment) é un entorno para o desenvolvedor no que configura as transformacións de datos e as conecta con fluxos de datos en forma de frechas. Neste caso, este conxunto de transformacións chámase gráfica:

As conexións de entrada e saída dos compoñentes funcionais son portos e conteñen campos calculados dentro das transformacións. Denomínanse planos varios gráficos conectados por fluxos en forma de frechas na orde da súa execución.

Hai varios centos de compoñentes funcionais, o que é moito. Moitos deles están altamente especializados. As capacidades das transformacións clásicas en Ab Initio son máis amplas que noutras ferramentas ETL. Por exemplo, Join ten varias saídas. Ademais do resultado de conectar conxuntos de datos, pode obter rexistros de saída dos conxuntos de datos de entrada cuxas claves non se puideron conectar. Tamén pode obter rexeitamentos, erros e un rexistro da operación de transformación, que se pode ler na mesma columna que un ficheiro de texto e procesarse con outras transformacións:

Ou, por exemplo, pode materializar un receptor de datos en forma de táboa e ler os datos del na mesma columna.

Hai transformacións orixinais. Por exemplo, a transformación Scania ten unha funcionalidade similar ás funcións analíticas. Existen transformacións con nomes que se explican por si mesmos: Crear datos, Ler Excel, Normalizar, Ordenar dentro de grupos, Executar programa, Executar SQL, Unirse con base de datos, etc. Os gráficos poden usar parámetros de tempo de execución, incluíndo a posibilidade de pasar parámetros desde ou a. o sistema operativo. Os ficheiros cun conxunto prefabricado de parámetros pasados ​​ao gráfico chámanse conxuntos de parámetros (psets).

Como era de esperar, Ab Initio GDE ten o seu propio repositorio chamado EME (Enterprise Meta Environment). Os desenvolvedores teñen a oportunidade de traballar con versións locais de código e comprobar os seus desenvolvementos no repositorio central.

É posible, durante a execución ou despois de executar o gráfico, facer clic en calquera fluxo que conecte a transformación e mirar os datos que pasaron entre estas transformacións:

Tamén é posible facer clic en calquera fluxo e ver os detalles do seguimento: cantos paralelos funcionou a transformación, cantas liñas e bytes se cargaron en cal dos paralelos:

É posible dividir a execución da gráfica en fases e marcar que hai que realizar primeiramente algunhas transformacións (na fase cero), as seguintes na primeira fase, as seguintes na segunda fase, etc.

Para cada transformación, pódese escoller o chamado esquema (onde se executará): sen paralelos ou en fíos paralelos, cuxo número pode especificarse. Ao mesmo tempo, os ficheiros temporais que Ab Initio crea cando se executan transformacións pódense colocar tanto no sistema de ficheiros do servidor como en HDFS.

En cada transformación, baseándose no modelo predeterminado, podes crear o teu propio script en PDL, que é un pouco como un shell.

Con PDL, pode estender a funcionalidade das transformacións e, en particular, pode xerar de forma dinámica (en tempo de execución) fragmentos de código arbitrarios dependendo dos parámetros do tempo de execución.

Ab Initio tamén ten unha integración ben desenvolvida co sistema operativo vía shell. En concreto, Sberbank usa linux ksh. Podes intercambiar variables co shell e usalas como parámetros de gráficos. Podes chamar á execución de gráficos Ab Initio desde o shell e administrar Ab Initio.

Ademais de Ab Initio GDE, na entrega inclúense moitos outros produtos. Existe o seu propio Sistema de Co>Operación coa pretensión de chamarse sistema operativo. Hai un Control>Centro onde podes programar e supervisar os fluxos de descarga. Hai produtos para facer desenvolvemento a un nivel máis primitivo do que permite Ab Initio GDE.

Descrición do framework MDW e traballo na súa personalización para GreenPlum

Xunto cos seus produtos, o vendedor fornece o produto MDW (Metadata Driven Warehouse), que é un configurador de gráficos deseñado para axudar nas tarefas típicas de poboar almacéns de datos ou bóvedas de datos.

Contén analizadores de metadatos personalizados (específicos do proxecto) e xeradores de código listos para usar.

Como entrada, MDW recibe un modelo de datos, un ficheiro de configuración para establecer unha conexión a unha base de datos (Oracle, Teradata ou Hive) e algunhas outras opcións. A parte específica do proxecto, por exemplo, desprega o modelo nunha base de datos. A parte integrada do produto xera gráficos e ficheiros de configuración para eles cargando datos en táboas modelo. Neste caso, créanse gráficos (e psets) para varios modos de inicialización e traballo incremental na actualización de entidades.

Nos casos de Hive e RDBMS, xéranse diferentes gráficos para a inicialización e actualizacións incrementais de datos.

No caso de Hive, os datos delta entrantes conéctanse mediante Ab Initio Join cos datos que estaban na táboa antes da actualización. Os cargadores de datos en MDW (tanto en Hive como en RDBMS) non só introducen novos datos do delta, senón que tamén pechan os períodos de relevancia dos datos cuxas claves primarias recibiron o delta. Ademais, ten que reescribir a parte sen cambios dos datos. Pero isto ten que facerse porque Hive non ten operacións de eliminación ou actualización.

No caso dos RDBMS, os gráficos para a actualización incremental de datos parecen máis óptimos, porque os RDBMS teñen capacidades de actualización reais.

O delta recibido cárgase nunha táboa intermedia da base de datos. Despois diso, o delta conéctase aos datos que estaban na táboa antes da actualización. E isto faise usando SQL usando unha consulta SQL xerada. A continuación, mediante os comandos SQL eliminar+inserir, insírense novos datos do delta na táboa de destino e péchanse os períodos de relevancia dos datos cuxas claves primarias recibiron o delta.
Non é necesario reescribir os datos sen cambios.

Entón chegamos á conclusión de que no caso de Hive, MDW ten que ir a reescribir toda a táboa porque Hive non ten unha función de actualización. E nada mellor que reescribir completamente os datos cando se inventou a actualización. No caso do RDBMS, pola contra, os creadores do produto consideraron necesario confiar a conexión e actualización das táboas ao uso de SQL.

Para un proxecto en Sberbank, creamos unha nova implementación reutilizable dun cargador de bases de datos para GreenPlum. Isto fíxose baseándose na versión que MDW xera para Teradata. Foi Teradata, e non Oracle, o que máis se achegou e mellor para iso, porque... tamén é un sistema MPP. Os métodos de traballo, así como a sintaxe, de Teradata e GreenPlum resultaron ser similares.

Os seguintes exemplos de diferenzas críticas para MDW entre diferentes RDBMS son os seguintes. En GreenPlum, a diferenza de Teradata, ao crear táboas hai que escribir unha cláusula

distributed by

Teradata escribe:

delete <table> all

, e en GreenPlum escriben

delete from <table>

En Oracle, escriben con fins de optimización

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

, e Teradata e GreenPlum escriben

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

Tamén observamos que para que Ab Initio funcione con GreenPlum, foi necesario instalar o cliente GreenPlum en todos os nodos do clúster Ab Initio. Isto débese a que nos conectamos a GreenPlum simultaneamente desde todos os nodos do noso clúster. E para que a lectura de GreenPlum fose paralela e cada fío paralelo de Ab Initio lese a súa propia porción de datos de GreenPlum, tivemos que colocar unha construción entendida por Ab Initio na sección "onde" das consultas SQL.

where ABLOCAL()

e determine o valor desta construción especificando a lectura de parámetros da base de datos de transformación

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

, que se compila en algo así

mod(sk,10)=3

, é dicir. ten que solicitar a GreenPlum un filtro explícito para cada partición. Para outras bases de datos (Teradata, Oracle), Ab Initio pode realizar esta paralelización automaticamente.

Comparación do rendemento de Ab Initio entre Hive e GreenPlum

Sberbank realizou un experimento para comparar o rendemento dos gráficos xerados por MDW en relación con Hive e con GreenPlum. Como parte do experimento, no caso de Hive había 5 nodos no mesmo clúster que Ab Initio, e no caso de GreenPlum había 4 nodos nun clúster separado. Eses. Hive tiña algunha vantaxe de hardware sobre GreenPlum.

Consideramos dous pares de gráficos que realizan a mesma tarefa de actualización de datos en Hive e GreenPlum. Ao mesmo tempo, puxéronse en marcha os gráficos xerados polo configurador MDW:

• carga inicial + carga incremental de datos xerados aleatoriamente nunha táboa Hive
• carga inicial + carga incremental de datos xerados aleatoriamente na mesma táboa GreenPlum

En ambos os casos (Hive e GreenPlum) realizaron cargas a 10 fíos paralelos no mesmo clúster Ab Initio. Ab Initio gardou os datos intermedios para os cálculos en HDFS (en termos de Ab Initio, utilizouse o deseño de MFS usando HDFS). Unha liña de datos xerados aleatoriamente ocupaba 200 bytes en ambos os casos.

O resultado foi así:

Colmea:

Carga inicial en Hive

Filas inseridas
6 000 000
60 000 000
600 000 000

Duración da inicialización
descargas en segundos
41
203
1 601

Carga incremental en Hive

Número de filas dispoñibles en
táboa de obxectivos ao comezo do experimento
6 000 000
60 000 000
600 000 000

Número de liñas delta aplicadas
táboa de obxectivos durante o experimento
6 000 000
6 000 000
6 000 000

Duración do incremento
descargas en segundos
88
299
2 541

GreenPlum:

Carga inicial en GreenPlum

Filas inseridas
6 000 000
60 000 000
600 000 000

Duración da inicialización
descargas en segundos
72
360
3 631

Carga incremental en GreenPlum

Número de filas dispoñibles en
táboa de obxectivos ao comezo do experimento
6 000 000
60 000 000
600 000 000

Número de liñas delta aplicadas
táboa de obxectivos durante o experimento
6 000 000
6 000 000
6 000 000

Duración do incremento
descargas en segundos
159
199
321

Vemos que a velocidade de carga inicial tanto en Hive como en GreenPlum depende linealmente da cantidade de datos e, por razóns de mellor hardware, é lixeiramente máis rápida para Hive que para GreenPlum.

A carga incremental en Hive tamén depende linealmente do volume de datos cargados previamente dispoñibles na táboa de destino e avanza bastante lentamente a medida que o volume crece. Isto é causado pola necesidade de reescribir completamente a táboa de destino. Isto significa que aplicar pequenos cambios a táboas enormes non é un bo caso de uso para Hive.

A carga incremental en GreenPlum depende débilmente do volume de datos cargados previamente dispoñibles na táboa de destino e avanza con bastante rapidez. Isto ocorreu grazas a SQL Joins e á arquitectura GreenPlum, que permite a operación de eliminación.

Entón, GreenPlum engade o delta usando o método delete+insert, pero Hive non ten operacións de eliminación ou actualización, polo que toda a matriz de datos foi obrigada a reescribirse completamente durante unha actualización incremental. A comparación das celas destacadas en negriña é a máis reveladora, xa que se corresponde coa opción máis común para o uso de descargas con uso intensivo de recursos. Vemos que GreenPlum gañou a Hive nesta proba en 8 veces.

Traballando ab Initio con GreenPlum en modo case tempo real

Neste experimento, probaremos a capacidade de Ab Initio para actualizar a táboa GreenPlum con anacos de datos xerados aleatoriamente en tempo case real. Consideremos a táboa de GreenPlum dev42_1_db_usl.TESTING_SUBJ_org_finval, coa que traballaremos.

Usaremos tres gráficos Ab Initio para traballar con el:

1) Gráfico Create_test_data.mp: crea ficheiros de datos en HDFS con 10 de filas en 6 fíos paralelos. Os datos son aleatorios, a súa estrutura está organizada para a súa inserción na nosa táboa

2) Gráfico mdw_load.day_one.current.dev42_1_db_usl_testing_subj_org_finval.pset: gráfico xerado por MDW inicializando a inserción de datos na nosa táboa en 10 fíos paralelos (utilízanse os datos de proba xerados polo gráfico (1))

3) Gráfico mdw_load.regular.current.dev42_1_db_usl_testing_subj_org_finval.pset: un gráfico xerado por MDW para a actualización incremental da nosa táboa en 10 fíos paralelos utilizando unha parte dos datos recentemente recibidos (delta) xerados polo gráfico (1)

Imos executar o seguinte script en modo NRT:

• xerar 6 liñas de proba
• realizar unha carga inicial inserir 6 filas de proba nunha táboa baleira
• repita a descarga incremental 5 veces
  • xerar 6 liñas de proba
  • realizar unha inserción incremental de 6 de filas de proba na táboa (neste caso, o tempo de caducidade valid_to_ts establécese nos datos antigos e insírense os datos máis recentes coa mesma clave primaria)

Este escenario emula o modo de funcionamento real dun determinado sistema empresarial: unha parte bastante grande dos novos datos aparecen en tempo real e vértense inmediatamente en GreenPlum.

Agora vexamos o rexistro do script:

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

Resulta esta imaxe:

Gráfico
Hora de inicio
Tempo de remate
lonxitude

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

Vemos que 6 de liñas de incremento son procesadas en 000 minutos, o que é bastante rápido.
Os datos da táboa de destino resultaron estar distribuídos do seguinte xeito:

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;

Podes ver a correspondencia dos datos inseridos coas veces que se lanzaron os gráficos.
Isto significa que pode executar a carga incremental de datos en GreenPlum en Ab Initio cunha frecuencia moi alta e observar unha alta velocidade de inserción destes datos en GreenPlum. Por suposto, non será posible lanzar unha vez por segundo, xa que Ab Initio, como calquera ferramenta ETL, require tempo para "iniciarse" cando se inicia.

Conclusión

Ab Initio utilízase actualmente en Sberbank para construír unha capa de datos semánticos unificadas (ESS). Este proxecto consiste en construír unha versión unificada do estado de varias entidades empresariais bancarias. A información procede de varias fontes, cuxas réplicas están preparadas en Hadoop. En función das necesidades empresariais, prepárase un modelo de datos e descríbense as transformacións dos datos. Ab Initio carga información no ESN e os datos descargados non só son de interese para a empresa en si, senón que tamén serven como fonte para crear data marts. Ao mesmo tempo, a funcionalidade do produto permite utilizar varios sistemas como receptor (Hive, Greenplum, Teradata, Oracle), o que permite preparar facilmente datos para unha empresa nos distintos formatos que precisa.

As capacidades de Ab Initio son amplas; por exemplo, o marco MDW incluído fai posible crear datos históricos técnicos e comerciais listos para usar. Para os desenvolvedores, Ab Initio fai posible non reinventar a roda, senón utilizar moitos compoñentes funcionais existentes, que son esencialmente bibliotecas necesarias cando se traballa con datos.

O autor é un experto na comunidade profesional de Sberbank SberProfi DWH/BigData. A comunidade profesional SberProfi DWH/BigData é a responsable do desenvolvemento de competencias en áreas como o ecosistema Hadoop, Teradata, Oracle DB, GreenPlum, así como as ferramentas de BI Qlik, SAP BO, Tableau, etc.

Fonte: www.habr.com