Skip to content

Guia para Implementação do Great Expectations

1. Introdução ao Great Expectations

Great Expectations é uma biblioteca Python de código aberto para validação de dados, documentação e profiling. Ela permite que você crie testes de dados expressivos e flexíveis, que são incorporados ao seu pipeline de dados. Esses testes são conhecidos como "expectativas", que podem variar desde verificações simples, como se uma coluna existe, até testes mais complexos, como verificar a porcentagem de valores únicos. Para obter mais detalhes, consulte a documentação oficial do Great Expectations.

Este guia irá demonstrar como configurar o Great Expectations. Como exemplo prático, faremos referência ao projeto asset-data-eng, que já possui expectativas criadas para o pipeline VLGI.

2. Instalação do Great Expectations

A instalação inicial do Great Expectations é tão simples quanto instalar qualquer outra biblioteca Python. Você pode instalar usando o pip com o seguinte comando:

pip install great_expectations

Após inicie a instância de arquivos no projeto:

great_expectations init

3. Configurações

3.1. Configuração de Credenciais e Conexão com Banco de Dados

O Great Expectations permite que você configure suas credenciais para tornar seu projeto mais seguro e fácil de gerenciar. Ele também suporta uma variedade de conexões de banco de dados.

A configuração do banco deve estar em great_expectations/great_expectations.yml dentro da sessão datasources, nela você pode definir quantas conexões desejar, abaixo segue um exemplo:

datasources:
  asset_db: # Nome da primeira conexão
    class_name: Datasource
    execution_engine:
      class_name: SqlAlchemyExecutionEngine
      connection_string: ${asset_db_conn} # referência de credencial
    data_connectors:
      default_data_connector: # Definindo uma conexão padrão (você pode definir várias conexões diferentes para o mesmo banco)
        class_name: InferredAssetSqlDataConnector
        name: whole_table
  advisory_db: # Nome da segunda conexão
    class_name: Datasource
    execution_engine:
      class_name: SqlAlchemyExecutionEngine
      connection_string: ${advisory_db_conn} # referència de credencial
    data_connectors:
      default_data_connector:
        class_name: InferredAssetSqlDataConnector
        name: whole_table

As credenciais são normalmente armazenadas no arquivo great_expectations/uncommitted/config_variables.yml. Aqui está um exemplo de como isso pode ser configurado:

asset_db_conn: MYDBASSETCON

advisory_db_conn: MYDBVLGCON

Além disso, asset_db_conn e advisory_db_conn também podem ser definidas como variáveis de ambiente, contendo a string de conexão para o banco de dados Postgres.

Você pode encontrar os detalhes de como configurar as credenciais e a conexão com o banco de dados na documentação de configuração de credenciais e na documentação de conexão de banco de dados.

3.2. Criação de Checkpoints e Suites

Em Great Expectations, um "checkpoint" é um conjunto de expectativas e um conjunto de dados que são combinados para criar um "teste de dados". Uma "suite" é uma coleção de expectativas que descrevem um aspecto particular dos seus dados. Por exemplo, uma suite pode conter expectativas sobre a validade, unicidade e formato dos dados em uma tabela específica.

A criação de checkpoints e suites, etapas fundamentais ao utilizar o Great Expectations, pode ser feita pelos seguintes comandos:

# Criar suite
great_expectations suite new my_suite

# Criar checkpoint
great_expectations checkpoint new my_checkpoint

3.3. Tipos de Testes: Automáticos e Manuais

Ao criar uma suite com o comando great_expectations suite new, o Great Expectations perguntará se você quer gerar expectativas manualmente, conectando-se à base de dados, ou automaticamente. Independentemente da opção que você escolher, você pode sempre adicionar ou editar expectativas posteriormente.

3.4. Exemplo de Suites pelo Código via Notebook e por JSON

As suites de expectativas podem ser definidas diretamente no código Python ou em um arquivo JSON. Ao executar o comando great_expectations suite edit my_suite, o Great Expectations abrirá um notebook Jupyter onde você pode definir suas expectativas em código Python.

Você também pode definir suas expectativas em um arquivo JSON. Aqui está um exemplo de como uma suite pode ser definida em JSON:

{
  "data_asset_type": "Dataset",
  "expectation_suite_name": "default",
  "expectations": [
    {
      "expectation_type": "expect_column_to_exist",
      "kwargs": {
        "column": "my_column"
      }
    }
  ],
  "meta": {
    "great_expectations_version": "0.13.8"
  }
}

As suites são automaticamente armazenadas em great_expectations/expectations ao serem criadas via notebook. Contudo, é possível salvá-las manualmente nessa pasta através de um arquivo JSON.

Você pode encontrar exemplo de como é criado a expectativa via notebook na documentação oficial.

Você também pode consultar a documentação de funções de expectativas para obter mais detalhes sobre as diferentes expectativas disponíveis.

3.5. Criando um checkpoint

Após criar um checkpoint um notebook se abrirá e será necessário configurar instruções de como o checkpoint vai se conectar no banco, qual tabela acessar e quais expectativas executar, essa etapa é feita em Test Your Checkpoint Configuration e um exemplo simples de configuração via yaml seria esse:

my_checkpoint_name = "INCLUA_O_NOME_DO_CHECKPOINT"
db_name = "NOME_DO_BANCO" # No nosso exemplo criamos dois bancos chamado "asset_db" e "advisory_db"
data_connectors = "TIPO_DE_CONEXAO" # No nosso exemplo de datascourse chamamos um tipo de conexão como "default_data_connector"
table_name = "NOME_DA_TABELA" 
expectation = "NOME_DA_EXPECTATIVA" # Nessa situação é bom já ter a expectativa/suite criada, consulte a sessão 3.3 e 3.4

yaml_config = f"""
name: {my_checkpoint_name}
config_version: 1.0
class_name: SimpleCheckpoint
run_name_template: "%Y%m%d-%H%M%S-{my_checkpoint_name}"
validations:
  - batch_request: # Primeiro checkpoint/suite aqui
      datasource_name: {db_name}
      data_connector_name: {data_connectors}
      data_asset_name: {table_name}
    expectation_suite_name: {expectation}
  - batch_request: # Segundo checkpoint/suite aqui
      datasource_name: {db_name2}
      data_connector_name: {data_connectors2}
      data_asset_name: {table_name2}
    expectation_suite_name: {expectation2}
"""

4. Execução e Validação dos Testes

Depois de configurar suas expectativas e pipelines, você pode executá-las usando o seguinte comando:

great_expectations checkpoint run my_checkpoint

Este comando executará o checkpoint que você definiu e irá gerar um relatório sobre se suas expectativas foram cumpridas.

4.1. Análise do Relatório

Ao rodar o comando, será gerado um relatório, seja no terminal ou em um arquivo HTML que pode ser visualizado no seu navegador.

Este relatório é interativo, permitindo-lhe clicar nos testes executados para obter mais detalhes, e nas expectativas para ver como elas foram cumpridas.

Normalmente, o relatório é salvo no seguinte diretório:

/great_expectations/uncommitted/data_docs/local_site/index.html

4.1.1. Possível erro no Windows

Se você estiver usando o Windows, pode encontrar um problema onde clicar nos links do relatório não redireciona para a página correta. Isso pode ser devido a restrições de segurança no Windows para arquivos HTML locais.

Para contornar este problema, você pode abrir o arquivo manualmente. Os detalhes dos testes executados podem ser encontrados no diretório:

/great_expectations/uncommitted/data_docs/local_site/validations/<nome_do_seu_checkpoint>/<data_de_execucao>/<arquivo_de_teste>.html

E as expectativas podem ser encontradas no diretório:

/great_expectations/uncommitted/data_docs/local_site/expectations/<nome_da_sua_suite_de_expectativas>.html

Conclusão

O Great Expectations é uma ferramenta poderosa que adiciona uma camada de segurança e robustez aos seus pipelines de dados. Ao definir e testar expectativas sobre seus dados, você pode ter mais confiança de que os dados que estão sendo produzidos são precisos e confiáveis. Além disso, a documentação de dados do Great Expectations ajuda a aumentar a compreensão e a transparência sobre os seus dados. Ao implementar o Great Expectations em seus pipelines de dados, você estará melhor equipado para evitar erros, garantir a confiabilidade dos dados e promover uma melhor compreensão do seu fluxo de trabalho de dados.