Quando você tem escamas Sber. Usando Ab Initio com Hive e GreenPlum

Há algum tempo nos deparamos com a questão de escolher uma ferramenta ETL para trabalhar com Big Data. A solução Informatica BDM usada anteriormente não nos agradou devido à funcionalidade limitada. Seu uso foi reduzido a uma estrutura para lançar comandos spark-submit. Não existiam muitos análogos no mercado que fossem, em princípio, capazes de trabalhar com o volume de dados com que lidamos todos os dias. No final escolhemos Ab Initio. Durante as demonstrações piloto, o produto apresentou velocidade de processamento de dados muito alta. Quase não há informações sobre Ab Initio em russo, então decidimos falar sobre nossa experiência no Habré.

Ab Initio possui muitas transformações clássicas e incomuns, cujo código pode ser estendido usando sua própria linguagem PDL. Para uma pequena empresa, uma ferramenta tão poderosa provavelmente será um exagero e a maioria de seus recursos pode ser cara e não utilizada. Mas se a sua escala estiver próxima da de Sberov, então Ab Initio pode ser interessante para você.

Ajuda uma empresa a acumular conhecimento globalmente e desenvolver um ecossistema, e um desenvolvedor a melhorar suas habilidades em ETL, melhorar seu conhecimento no shell, oferece a oportunidade de dominar a linguagem PDL, fornece uma imagem visual dos processos de carregamento e simplifica o desenvolvimento devido à abundância de componentes funcionais.

Neste post falarei sobre as capacidades do Ab Initio e fornecerei características comparativas de seu trabalho com Hive e GreenPlum.

• Descrição do framework MDW e trabalho em sua customização para GreenPlum
• Comparação de desempenho Ab Initio entre Hive e GreenPlum
• Trabalhando Ab Initio com GreenPlum no modo Quase em Tempo Real

A funcionalidade deste produto é muito ampla e requer muito tempo de estudo. No entanto, com as habilidades de trabalho adequadas e as configurações de desempenho corretas, os resultados do processamento de dados são muito impressionantes. Usar o Ab Initio para um desenvolvedor pode proporcionar uma experiência interessante. Esta é uma nova abordagem ao desenvolvimento ETL, um híbrido entre um ambiente visual e desenvolvimento de download em uma linguagem semelhante a script.

As empresas estão desenvolvendo seus ecossistemas e esta ferramenta é mais útil do que nunca. Com o Ab Initio, você pode acumular conhecimento sobre o seu negócio atual e usar esse conhecimento para expandir antigos e abrir novos negócios. Alternativas ao Ab Initio incluem ambientes de desenvolvimento visual Informatica BDM e ambientes de desenvolvimento não visuais Apache Spark.

Descrição do Ab Initio

Ab Initio, como outras ferramentas ETL, é uma coleção de produtos.

Ab Initio GDE (Graphical Development Environment) é um ambiente para o desenvolvedor no qual ele configura transformações de dados e as conecta com fluxos de dados em forma de setas. Neste caso, tal conjunto de transformações é chamado de gráfico:

As conexões de entrada e saída dos componentes funcionais são portas e contêm campos calculados nas transformações. Vários gráficos conectados por fluxos em forma de setas na ordem de execução são chamados de plano.

Existem várias centenas de componentes funcionais, o que é muito. Muitos deles são altamente especializados. As capacidades das transformações clássicas no Ab Initio são mais amplas do que em outras ferramentas ETL. Por exemplo, Join tem múltiplas saídas. Além do resultado da conexão de conjuntos de dados, você pode obter registros de saída de conjuntos de dados de entrada cujas chaves não puderam ser conectadas. Você também pode obter rejeições, erros e um log da operação de transformação, que pode ser lido na mesma coluna de um arquivo de texto e processado com outras transformações:

Ou, por exemplo, você pode materializar um receptor de dados na forma de uma tabela e ler os dados dele na mesma coluna.

Existem transformações originais. Por exemplo, a transformação Scan possui funcionalidade semelhante às funções analíticas. Existem transformações com nomes autoexplicativos: Criar Dados, Ler Excel, Normalizar, Classificar dentro de Grupos, Executar Programa, Executar SQL, Unir com BD, etc. Os gráficos podem usar parâmetros de tempo de execução, incluindo a possibilidade de passar parâmetros de ou para o sistema operacional. Arquivos com um conjunto pronto de parâmetros passados ​​​​para o gráfico são chamados de conjuntos de parâmetros (psets).

Como esperado, Ab Initio GDE possui seu próprio repositório chamado EME (Enterprise Meta Environment). Os desenvolvedores têm a oportunidade de trabalhar com versões locais de código e registrar seus desenvolvimentos no repositório central.

É possível, durante a execução ou após a execução do gráfico, clicar em qualquer fluxo que conecte a transformação e observar os dados que passaram entre essas transformações:

Também é possível clicar em qualquer fluxo e ver detalhes do rastreamento - em quantos paralelos a transformação funcionou, quantas linhas e bytes foram carregados em quais dos paralelos:

É possível dividir a execução do gráfico em fases e marcar que algumas transformações precisam ser realizadas primeiro (na fase zero), as próximas na primeira fase, as próximas na segunda fase, etc.

Para cada transformação, você pode escolher o chamado layout (onde será executado): sem paralelos ou em threads paralelos, cujo número pode ser especificado. Ao mesmo tempo, os arquivos temporários criados pelo Ab Initio durante a execução das transformações podem ser colocados no sistema de arquivos do servidor e no HDFS.

Em cada transformação, com base no modelo padrão, você pode criar seu próprio script em PDL, que é um pouco como um shell.

Com PDL, você pode estender a funcionalidade das transformações e, em particular, pode gerar dinamicamente (em tempo de execução) fragmentos de código arbitrários dependendo dos parâmetros de tempo de execução.

Ab Initio também possui integração bem desenvolvida com o SO via shell. Especificamente, o Sberbank usa linux ksh. Você pode trocar variáveis ​​com o shell e usá-las como parâmetros gráficos. Você pode chamar a execução de gráficos Ab Initio a partir do shell e administrar Ab Initio.

Além do Ab Initio GDE, muitos outros produtos estão incluídos na entrega. Existe seu próprio sistema de cooperação que pretende ser chamado de sistema operacional. Existe uma Central de Controle onde você pode agendar e monitorar fluxos de download. Existem produtos para fazer o desenvolvimento em um nível mais primitivo do que o Ab Initio GDE permite.

Descrição do framework MDW e trabalho em sua customização para GreenPlum

Junto com seus produtos, o fornecedor fornece o produto MDW (Metadata Driven Warehouse), que é um configurador gráfico projetado para ajudar em tarefas típicas de preenchimento de data warehouses ou cofres de dados.

Ele contém analisadores de metadados personalizados (específicos do projeto) e geradores de código prontos para uso.

Como entrada, o MDW recebe um modelo de dados, um arquivo de configuração para estabelecer uma conexão com um banco de dados (Oracle, Teradata ou Hive) e algumas outras configurações. A parte específica do projeto, por exemplo, implanta o modelo em um banco de dados. A parte pronta para uso do produto gera gráficos e arquivos de configuração para eles, carregando dados em tabelas de modelo. Nesse caso, gráficos (e psets) são criados para diversos modos de inicialização e trabalho incremental na atualização de entidades.

Nos casos de Hive e RDBMS, diferentes gráficos são gerados para inicialização e atualizações incrementais de dados.

No caso do Hive, os dados delta recebidos são conectados via Ab Initio Join com os dados que estavam na tabela antes da atualização. Os carregadores de dados no MDW (tanto no Hive quanto no RDBMS) não apenas inserem novos dados do delta, mas também fecham os períodos de relevância dos dados cujas chaves primárias receberam o delta. Além disso, você terá que reescrever a parte inalterada dos dados. Mas isso tem que ser feito porque o Hive não possui operações de exclusão ou atualização.

No caso de RDBMS, os gráficos para atualização incremental de dados parecem mais ideais, porque os RDBMS possuem capacidades reais de atualização.

O delta recebido é carregado em uma tabela intermediária no banco de dados. Depois disso, o delta é conectado aos dados que estavam na tabela antes da atualização. E isso é feito usando SQL usando uma consulta SQL gerada. A seguir, através dos comandos SQL delete+insert, novos dados do delta são inseridos na tabela alvo e os períodos de relevância dos dados cujas chaves primárias receberam o delta são fechados.
Não há necessidade de reescrever dados inalterados.

Então chegamos à conclusão que no caso do Hive, o MDW tem que reescrever a tabela inteira porque o Hive não possui uma função de atualização. E nada melhor do que reescrever completamente os dados quando a atualização for inventada. No caso do RDBMS, ao contrário, os criadores do produto consideraram necessário confiar a conexão e atualização das tabelas ao uso do SQL.

Para um projeto no Sberbank, criamos uma implementação nova e reutilizável de um carregador de banco de dados para GreenPlum. Isso foi feito com base na versão que o MDW gera para o Teradata. Foi a Teradata, e não a Oracle, quem chegou mais perto e melhor para isso, porque... também é um sistema MPP. Os métodos de trabalho, bem como a sintaxe, do Teradata e do GreenPlum revelaram-se semelhantes.

Exemplos de diferenças críticas de MDW entre diferentes RDBMSs são os seguintes. No GreenPlum, ao contrário do Teradata, ao criar tabelas você precisa escrever uma cláusula

distributed by

Teradata escreve:

delete <table> all

, e no GreenPlum eles escrevem

delete from <table>

No Oracle, para fins de otimização eles escrevem

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

, e Teradata e GreenPlum escrevem

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

Observamos também que para que o Ab Initio funcionasse com o GreenPlum, foi necessário instalar o cliente GreenPlum em todos os nós do cluster Ab Initio. Isso ocorre porque nos conectamos ao GreenPlum simultaneamente de todos os nós do nosso cluster. E para que a leitura do GreenPlum fosse paralela e cada thread Ab Initio paralelo pudesse ler sua própria porção de dados do GreenPlum, tivemos que colocar uma construção entendida por Ab Initio na seção “onde” das consultas SQL

where ABLOCAL()

e determine o valor desta construção especificando a leitura do parâmetro do banco de dados de transformação

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

, que compila para algo como

mod(sk,10)=3

, ou seja você deve solicitar ao GreenPlum um filtro explícito para cada partição. Para outros bancos de dados (Teradata, Oracle), o Ab Initio pode realizar essa paralelização automaticamente.

Comparação de desempenho Ab Initio entre Hive e GreenPlum

O Sberbank conduziu um experimento para comparar o desempenho dos gráficos gerados pelo MDW em relação ao Hive e em relação ao GreenPlum. Como parte do experimento, no caso do Hive havia 5 nós no mesmo cluster do Ab Initio, e no caso do GreenPlum havia 4 nós em um cluster separado. Aqueles. O Hive tinha alguma vantagem de hardware sobre o GreenPlum.

Consideramos dois pares de gráficos realizando a mesma tarefa de atualização de dados no Hive e no GreenPlum. Ao mesmo tempo, foram lançados os gráficos gerados pelo configurador MDW:

• carga inicial + carga incremental de dados gerados aleatoriamente em uma tabela Hive
• carga inicial + carga incremental de dados gerados aleatoriamente na mesma tabela GreenPlum

Em ambos os casos (Hive e GreenPlum) eles executaram uploads para 10 threads paralelos no mesmo cluster Ab Initio. Ab Initio salvou dados intermediários para cálculos em HDFS (em termos de Ab Initio, foi usado layout MFS usando HDFS). Uma linha de dados gerados aleatoriamente ocupava 200 bytes em ambos os casos.

O resultado foi assim:

Colmeia:

Carregamento inicial no Hive

Linhas inseridas
6 000 000
60 000 000
600 000 000

Duração da inicialização
downloads em segundos
41
203
1 601

Carregamento incremental no Hive

Número de linhas disponíveis em
tabela de destino no início do experimento
6 000 000
60 000 000
600 000 000

Número de linhas delta aplicadas a
tabela de destino durante o experimento
6 000 000
6 000 000
6 000 000

Duração incremental
downloads em segundos
88
299
2 541

Ameixa verde:

Carregamento inicial no GreenPlum

Linhas inseridas
6 000 000
60 000 000
600 000 000

Duração da inicialização
downloads em segundos
72
360
3 631

Carregamento incremental no GreenPlum

Número de linhas disponíveis em
tabela de destino no início do experimento
6 000 000
60 000 000
600 000 000

Número de linhas delta aplicadas a
tabela de destino durante o experimento
6 000 000
6 000 000
6 000 000

Duração incremental
downloads em segundos
159
199
321

Vemos que a velocidade de carregamento inicial tanto no Hive quanto no GreenPlum depende linearmente da quantidade de dados e, por razões de melhor hardware, é um pouco mais rápida para o Hive do que para o GreenPlum.

O carregamento incremental no Hive também depende linearmente do volume de dados carregados anteriormente disponíveis na tabela de destino e prossegue lentamente à medida que o volume aumenta. Isso é causado pela necessidade de reescrever completamente a tabela de destino. Isso significa que aplicar pequenas alterações em tabelas enormes não é um bom caso de uso para o Hive.

O carregamento incremental no GreenPlum depende fracamente da quantidade de dados carregados anteriormente disponíveis na tabela de destino e prossegue rapidamente. Isso aconteceu graças ao SQL Joins e à arquitetura GreenPlum, que permite a operação de exclusão.

Portanto, GreenPlum adiciona o delta usando o método delete+insert, mas o Hive não possui operações de exclusão ou atualização, portanto, toda a matriz de dados foi forçada a ser totalmente reescrita durante uma atualização incremental. A comparação das células destacadas em negrito é mais reveladora, pois corresponde à opção mais comum de utilização de downloads que consomem muitos recursos. Vemos que o GreenPlum venceu o Hive neste teste por 8 vezes.

Trabalhando Ab Initio com GreenPlum no modo Quase em Tempo Real

Neste experimento, testaremos a capacidade do Ab Initio de atualizar a tabela GreenPlum com blocos de dados gerados aleatoriamente quase em tempo real. Consideremos a tabela GreenPlum dev42_1_db_usl.TESTING_SUBJ_org_finval, com a qual trabalharemos.

Usaremos três gráficos Ab Initio para trabalhar com ele:

1) Gráfico Create_test_data.mp – cria arquivos de dados em HDFS com 10 de linhas em 6 threads paralelos. Os dados são aleatórios, sua estrutura está organizada para inserção em nossa tabela

2) Gráfico mdw_load.day_one.current.dev42_1_db_usl_testing_subj_org_finval.pset – gráfico gerado por MDW inicializando a inserção de dados em nossa tabela em 10 threads paralelos (dados de teste gerados pelo gráfico (1) são usados)

3) Gráfico mdw_load.regular.current.dev42_1_db_usl_testing_subj_org_finval.pset – um gráfico gerado pelo MDW para atualização incremental de nossa tabela em 10 threads paralelos usando uma porção de dados recém-recebidos (delta) gerados pelo gráfico (1)

Vamos executar o script abaixo no modo NRT:

• gerar 6 de linhas de teste
• execute um carregamento inicial e insira 6 de linhas de teste em uma tabela vazia
• repita o download incremental 5 vezes
  • gerar 6 de linhas de teste
  • execute uma inserção incremental de 6 de linhas de teste na tabela (neste caso, o tempo de expiração valid_to_ts é definido para os dados antigos e dados mais recentes com a mesma chave primária são inseridos)

Este cenário emula o modo de operação real de um determinado sistema de negócios - uma porção bastante grande de novos dados aparece em tempo real e é imediatamente despejada no GreenPlum.

Agora vamos dar uma olhada no log do script:

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

Acontece esta foto:

Gráfico
Hora de início
Hora de término
Comprimento

Criar_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

Criar_test_data.input.pset
04.06.2020 11: 50: 42
04.06.2020 11: 51: 06
00:00:24

mdw_load.regular.atual.
dev42_1_db_usl_testing_subj_org_finval.pset
04.06.2020 11: 51: 06
04.06.2020 11: 53: 41
00:02:35

Criar_test_data.input.pset
04.06.2020 11: 53: 41
04.06.2020 11: 54: 04
00:00:23

mdw_load.regular.atual.
dev42_1_db_usl_testing_subj_org_finval.pset
04.06.2020 11: 54: 04
04.06.2020 11: 56: 51
00:02:47

Criar_test_data.input.pset
04.06.2020 11: 56: 51
04.06.2020 11: 57: 14
00:00:23

mdw_load.regular.atual.
dev42_1_db_usl_testing_subj_org_finval.pset
04.06.2020 11: 57: 14
04.06.2020 11: 59: 55
00:02:41

Criar_test_data.input.pset
04.06.2020 11: 59: 55
04.06.2020 12: 00: 23
00:00:28

mdw_load.regular.atual.
dev42_1_db_usl_testing_subj_org_finval.pset
04.06.2020 12: 00: 23
04.06.2020 12: 03: 23
00:03:00

Criar_test_data.input.pset
04.06.2020 12: 03: 23
04.06.2020 12: 03: 49
00:00:26

mdw_load.regular.atual.
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 linhas de incremento são processadas em 000 minutos, o que é bastante rápido.
Os dados na tabela de destino foram distribuídos da seguinte forma:

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;

Você pode ver a correspondência dos dados inseridos com os horários em que os gráficos foram lançados.
Isso significa que você pode executar o carregamento incremental de dados no GreenPlum no Ab Initio com uma frequência muito alta e observar uma alta velocidade de inserção desses dados no GreenPlum. Claro, não será possível lançar uma vez por segundo, pois o Ab Initio, como qualquer ferramenta ETL, requer tempo para “iniciar” quando lançado.

Conclusão

Ab Initio é atualmente usado no Sberbank para construir uma Camada de Dados Semântica Unificada (ESS). Este projeto envolve a construção de uma versão unificada do estado de diversas entidades empresariais bancárias. As informações vêm de diversas fontes, cujas réplicas são preparadas no Hadoop. Com base nas necessidades do negócio, um modelo de dados é preparado e as transformações dos dados são descritas. Ab Initio carrega informações no ESN e os dados baixados não são apenas de interesse do negócio em si, mas também servem como fonte para a construção de data marts. Ao mesmo tempo, a funcionalidade do produto permite utilizar vários sistemas como receptor (Hive, Greenplum, Teradata, Oracle), o que permite preparar facilmente os dados para um negócio nos vários formatos que necessita.

As capacidades do Ab Initio são amplas; por exemplo, a estrutura MDW incluída torna possível criar dados históricos técnicos e de negócios prontos para uso. Para os desenvolvedores, o Ab Initio permite não reinventar a roda, mas sim utilizar muitos componentes funcionais existentes, que são essencialmente bibliotecas necessárias ao trabalhar com dados.

O autor é um especialista na comunidade profissional do Sberbank SberProfi DWH/BigData. A comunidade profissional SberProfi DWH/BigData é responsável pelo desenvolvimento de competências em áreas como ecossistema Hadoop, Teradata, Oracle DB, GreenPlum, bem como ferramentas de BI Qlik, SAP BO, Tableau, etc.

Fonte: habr.com