Pular para o conteúdo principal

Implementação de uma camada semântica com dbt: Um guia prático

Saiba como criar uma camada semântica com o dbt, transformando dados brutos em métricas consistentes para ferramentas de análise e BI!
Actualizado 23 de jan. de 2025  · 18 min de leitura

Muitas empresas modernas dependem de camadas semânticas para preencher a lacuna entre os dados brutos armazenados em data warehouses como o Snowflake e os insights em painéis ou relatórios. 

Uma camada semântica é uma abstração que define métricas, medidas e dimensões consistentes para análises e relatórios.

Neste tutorial, exploraremos como implementar uma camada semântica usando o dbt (data build tool), uma estrutura popular de transformação e modelagem de dados. Este guia inclui exemplos práticos e insights para ajudar você a dominar o conceito.

O que é uma camada semântica e por que ela é importante?

Uma camada semântica converte dados brutos em métricas e dimensões consistentes e reutilizáveis, simplificando a análise de dados. É uma ferramenta para manter a uniformidade entre equipes e ferramentas.

Benefícios de uma camada semântica

  • Definições de dados consistentes: Garante que as métricas de negócios, como receita, taxa de rotatividade, crescimento anual, valor médio do pedido etc., sejam definidas de maneira uniforme. Isso elimina a confusão causada por equipes diferentes que usam definições inconsistentes e ajuda a manter a confiança nos dados em toda a organização.
  • Colaboração aprimorada: Facilita a comunicação e o alinhamento entre as equipes técnicas e não técnicas. Ao fornecer uma camada de dados unificada, as equipes técnicas podem se concentrar na precisão dos dados, enquanto as equipes comerciais aproveitam métricas claras e acessíveis para tomar decisões estratégicas.
  • Aceleração do tempo de percepção: Reduz a ambiguidade, permitindo uma tomada de decisão mais rápida. Com uma camada semântica, as partes interessadas podem acessar e analisar rapidamente métricas confiáveis, minimizando o tempo gasto na reconciliação de dados ou na resolução de discrepâncias.

Por que o dbt é ideal para criar uma camada semântica

Vamos ver o que torna o dbt a ferramenta perfeita para permitir que os engenheiros de dados e análise criem uma camada semântica.

Uma captura de tela mostrando a arquitetura de modelagem com dbt

Diagrama conceitual da camada semântica da dbt, cuprtesy of dbt Labs

Modelagem modular de dados

O dbt permite que você divida transformações complexas de dados em modelos modulares reutilizáveis. Esses modelos podem ser dispostos em camadas hierárquicas, onde os modelos de dados fundamentais alimentam os modelos analíticos de nível superior. 

Essa abordagem torna o pipeline sustentável e permite que as equipes colaborem com mais eficiência, isolando as alterações em modelos específicos sem afetar todo o sistema.

Para saber mais sobre os conceitos básicos e as práticas recomendadas do dbt para modelagem de dados, consulte o tutorial dbt: 7 Conceitos que você deve saber para engenheiros de dados. Ele oferece percepções que complementam as estratégias descritas aqui.

Definições de métricas centralizadas

Com o dbt, a lógica comercial e as métricas são definidas em um único local, garantindo a consistência em várias ferramentas de análise. Ao usar o recurso de métricas do dbt, você pode definir KPIs como receita, taxas de conversão ou rotatividade uma vez e usá-los em painéis, relatórios e análises sem redefinição. Isso reduz as discrepâncias e garante a integridade dos dados.

Controle de versão e documentação

A integração do dbtcom o Git facilita o controle de versão robusto, permitindo que você rastreie e audite as alterações ao longo do tempo. Juntamente com a documentação gerada automaticamente, o dbt cria uma referência viva e acessível para todas as transformaçõese métricas de dados. Isso resulta em transparência e permite que novos membros da equipe se integrem rapidamente, explorando o pipeline de dados documentado.

Integração com ferramentas de BI

O dbt funciona com plataformas de BI, como Looker, Tableau e Mode, permitindo a integração da camada semântica em ferramentas de visualização. Usando as exposições dbt, você pode vincular diretamente os modelos dbt aos painéis de BI, garantindo que todas as atualizações nos modelos de dados sejam refletidas na análise sem intervenção manual.

Torne-se um engenheiro de dados

Torne-se um engenheiro de dados por meio do aprendizado avançado de Python
Comece a aprender de graça

Configurando seu projeto dbt

Normalmente, o dbt fica sobre armazéns de dados na nuvem, como o Snowflake ou o Google BigQuery. No entanto, para manter as coisas simples neste tutorial, vamos nos conectar a um banco de dados DuckDB localmente.

1. Pré-requisitos

  • Instale o Python em seu computador se ele ainda não tiver sido instalado.

2. Instalação das ferramentas necessárias

Use o pip para instalar a CLI do dbt:

pip install dbt-core

Instale o DuckDB via pip:

pip install duckdb

Instale o adaptador DuckDB via pip:

pip install dbt-duckdb

3. Inicialização do projeto dbt

Crie um novo projeto dbt:

dbt init project_name

Esse comando criará um projeto no seu diretório atual, que terá a seguinte aparência:

project_name/
├── analyses/
├── logs/
├── macros/
├── models/
├── seeds/
├── snapshots/
├── tests/
├── .gitignore
├── dbt_project.yml

4. Configurando a conexão com o DuckDB

Edite o arquivo profiles.yml, geralmente localizado na pasta ~/.dbt/. Se ele não existir, crie um:

project_name:  # This matches the name in dbt_project.yml file
  target: dev
  outputs:
    dev:
      type: duckdb
      path: path/to/demo_database.duckdb  
      threads: 1

O profiles.yml contém o ponteiro para o local do arquivo do banco de dados .duckdb, que você deve indicar no path

Você pode criar um novo banco de dados ou fazer o download de uma pequena amostra a partir daqui. Na próxima seção, usarei o arquivo duckdb-demo.duckdb da mesma fonte .

Para criar um novo arquivo de banco de dados duckDB, basta executar o seguinte:

import duckdb
duckdb.connect('/path/to/your/duckdb/database.duckdb')

5. Testando a conexão

Agora, podemos testar executando dbt debug para verificar se tudo funciona. Certifique-se de que você esteja na pasta do projeto antes de executar o comando:

cd /path/to/your/project/
dbt debug

Se tudo estiver configurado corretamente, você receberá algo parecido com isso em troca (todos os caminhos são redigidos por motivos de privacidade):

15:20:00  Running with dbt=1.9.1
15:20:00  dbt version: 1.9.1
15:20:00  python version: 3.11.5
15:20:00  python path: ...
15:20:00  os info: Windows-10-10.0.22631-SP0
15:20:00  Using profiles dir at ....
15:20:00  Using profiles.yml file at ...
15:20:00  Using dbt_project.yml file at ...
15:20:00  adapter type: duckdb
15:20:00  adapter version: 1.9.1
15:20:00  Configuration:
15:20:00    profiles.yml file [OK found and valid]
15:20:00    dbt_project.yml file [OK found and valid]
15:20:00  Required dependencies:
15:20:00   - git [OK found]

15:20:00  Connection:
15:20:00    database: demo_database
15:20:00    schema: main
15:20:00    path: ...
15:20:00    config_options: None
15:20:00    extensions: None
15:20:00    settings: {}
15:20:00    external_root: .
15:20:00    use_credential_provider: None
15:20:00    attach: None
15:20:00    filesystems: None
15:20:00    remote: None
15:20:00    plugins: None
15:20:00    disable_transactions: False
15:20:00  Registered adapter: duckdb=1.9.1
15:20:01    Connection test: [OK connection ok]

Criando uma camada semântica com o dbt

Parabéns por você ter chegado até aqui! Você configurou com sucesso seu primeiro projeto dbt.

Agora, vamos ver como criar uma camada semântica sobre um banco de dados. Para fazer isso, você pode importar seus próprios dados de CSV para o DuckDB ou fazer o download de um pequeno arquivo de banco de dados de amostra (5 MB) aqui.

Em seguida, podemos escrever um script Python simples para explorar o que esse arquivo de banco de dados contém:

import duckdb

# Connect to the database
conn = duckdb.connect("duckdb-demo.duckdb")

# Get list of tables
tables = conn.execute(
    "SELECT table_name FROM information_schema.tables WHERE table_schema='main'"
).fetchall()

print(f"\nNumber of tables in database: {len(tables)}")

print("Table names:")
for t in tables:
    print(f"- {t[0]}")

print("\nTables in database:")
for table in tables:
    print(f"- {table[0]}")

    # Get schema for each table
    schema = conn.execute(f"DESCRIBE {table[0]}").fetchall()
    print("\nSchema:")
    for col in schema:
        print(f"  {col[0]}: {col[1]}")

    # Preview data
    data = conn.execute(f"SELECT * FROM {table[0]} LIMIT 5").fetchall()
    print("\nFirst 5 rows:")
    for row in data:
        print(f"  {row}")
    print("\n---")

# Close connection
conn.close()

Saída (truncada para fins de brevidade):

Number of tables in database: 17
Table names:
- bank_failures
- boxplot
- calendar
- ...

Tables in database:
- bank_failures

Schema:
  c1: BIGINT
  Bank: VARCHAR
  City: VARCHAR
  State: VARCHAR
  Date: DATE
  Acquired by: VARCHAR
  Assets ($mil.): DOUBLE

First 5 rows:
  (1, 'Douglass National Bank', 'Kansas City', 'Missouri', datetime.date(2008, 1, 25), 'Liberty Bank and Trust', 58.5)
  (2, 'Hume Bank', 'Hume', 'Missouri', datetime.date(2008, 3, 7), 'Security Bank', 18.7)
...
…

Esse banco de dados tem 17 tabelas. No entanto, para este tutorial, usaremos apenas a tabela bank_failures. Esta tabela contém detalhes financeiros históricos de bancos falidos nos EUA.

1. Definição dos modelos SQL

Os modelos SQL são a base de qualquer projeto de dbt. Eles representam as transformações estruturadas de dados brutos em um formato mais analítico. 

Para este tutorial, definiremos dois arquivos SQL na pasta models/

Crie um novo arquivo na pasta models do seu projeto chamado base_bank_failures.sql:

SELECT *
FROM bank_failures

Esse arquivo extrai diretamente os dados brutos da tabela bank_failures. Ele funciona como o modelo básico, ao qual os modelos subsequentes podem fazer referência.

Depois disso, crie outro arquivo chamado clean_bank_failures.sql:

SELECT
    State,
    COUNT(*) AS total_failures,
    SUM("Assets ($mil.)" ) AS total_assets
FROM
    {{ ref('base_bank_failures') }}
GROUP BY
    State

Esse arquivo se baseia no modelo base_bank_failures (usando a função ref() ) para agregar e limpar os dados, preparando-os para análise. Ele resume o total de falhas e ativos por estado.

2. Criando um arquivo metrics.yml

O arquivo metrics.yml define métricas centralizadas e reutilizáveis que garantem a consistência entre análises e painéis.

No nosso caso, ele descreverá métricas como total_assets e avg_assets_per_failure, tornando-as disponíveis para uso em ferramentas de BI e outras consultas:

version: 2
models:
  - name: clean_bank_failures
    description: "Aggregated data about bank failures."
    columns:
      - name: State
        tests:
          - unique
      - name: "Assets ($mil.)"
    metrics:
      - name: total_assets
        label: Total Assets
        type: sum
        expression: "Assets ($mil.)"
        description: "Total assets of failed banks, aggregated by state."

      - name: avg_assets_per_failure
        label: Average Assets per Failure
        type: average
        expression: "Assets ($mil.)"
        description: "Average assets for each bank failure."

3. Criando um arquivo exposures.yml

O arquivo exposures.yml vincula seus modelos dbt a ferramentas externas, como o Tableau ou o Looker. Ele documenta essas conexões, garantindo rastreabilidade e consistência.

Esse arquivo especifica que o modelo clean_bank_failures é usado em um painel do Tableau, fornecendo detalhes sobre o proprietário e a dependência:

exposures:
  - name: tableau_dashboard
    type: dashboard
    url: https://tableau.yourcompany.com/workbook
    owner:
      name: Data Team
      email: datateam@yourcompany.com
    depends_on:
      - ref('clean_bank_failures')

Criação e teste da camada semântica

Para validar e criar seu projeto dbt com êxito, aqui estão alguns comandos úteis que você pode usar:

1. Crie os modelos: Execute o comando dbt build para materializar todos os modelos, aplicar testes e executar seeds e snapshots. Esse comando combina as funcionalidades de dbt run e dbt test:

dbt build

2. Teste os modelos: Se você quiser validar seus dados apenas com testes após a criação, use o comando dbt test. Isso garante que todos os testes de qualidade de dados (por exemplo, verificações de exclusividade e não nulo) sejam aplicados aos seus modelos.

dbt test

3. Executar modelos ou testes específicos: Para executar apenas modelos ou testes específicos, forneça seus nomes como argumentos. Por exemplo, para executar um único modelo:

dbt run --select clean_bank_failures

Para testar uma coluna específica:

dbt test --select clean_bank_failures.State

Integração da camada semântica com ferramentas de BI

Para conectar o dbt a ferramentas de BI, como Looker ou Tableau, siga estas etapas para expor a camada semântica de forma eficaz e garantir que as ferramentas de BI possam fazer referência direta aos modelos e métricas do dbt:

1. Ativação de exposições no dbt

Em seu projeto dbt, crie um arquivo exposures.yml na pasta models, que tem a seguinte aparência:

exposures:
  - name: tableau_dashboard
    type: dashboard
    url: https://tableau.yourcompany.com/workbook
    owner:
      name: Your Name
      email: email@yourcompany.com
    depends_on:
      - ref('clean_bank_failures')

2. Preparando a conexão com o banco de dados

  • Certifique-se de que os modelos de dados transformados estejam disponíveis em seu banco de dados (por exemplo, Snowflake, BigQuery, DuckDB).
  • Execute dbt build para materializar os modelos dbt no banco de dados.

3. Conectando o Tableau a modelos dbt

  • Abra o Tableau Desktop e crie uma nova conexão com seu banco de dados.
  • Selecione o esquema em que os modelos dbt estão armazenados.
  • Arraste e solte os modelos dbt (por exemplo, clean_bank_failures) na área de trabalho do Tableau.

4. Definição de métricas no Tableau

  • No Tableau, use as métricas definidas pelo dbt, como total_assets ou avg_assets_per_failure, diretamente em suas visualizações para garantir a consistência.
  • Crie campos calculados, se necessário, para aprimorar as visualizações.

5. Conectando o Looker a modelos dbt

  • No Looker, navegue até o painel de administração e configure uma conexão com seu banco de dados.
  • Crie uma visualização LookML para cada modelo dbt importando o esquema e os campos.
  • Use as métricas total_assets ou avg_assets_per_failure definidas no dbt para criar Looker Explores e dashboards consistentes.

Práticas recomendadas para a implementação de uma camada semântica com o dbt

Agora que você tem uma visão geral das etapas envolvidas na criação de uma camada semântica com o dbt, vamos analisar algumas práticas recomendadas. 

Centralizar a lógica de negócios

Defina todas as regras de negócios no dbt para garantir a consistência e a capacidade de manutenção. Ao centralizar a lógica de negócios, você elimina definições redundantes nas ferramentas, criando uma única fonte de verdade que todas as partes interessadas podem atualizar e entender facilmente. 

Modularizar modelos

Divida as transformações em componentes lógicos e reutilizáveis. Por exemplo, crie modelos básicos para dados brutos, modelos intermediários para dados limpos e transformados e modelos finais para dados prontos para análise. 

Essa estrutura modular simplifica a solução de problemas, promove a reutilização do código e permite a colaboração entre os membros da equipe, que podem trabalhar em componentes individuais sem interromper todo o pipeline.

Documentar tudo

Aproveite a documentação automatizada do dbt para manter sua camada semântica bem organizada e transparente. 

Use descrições em arquivos YAML para fornecer explicações claras sobre modelos, métricas e colunas. 

Atualize a documentação regularmente para refletir as alterações e use os gráficos de linhagem gerados automaticamente pelo dbt para visualizar as relações entre os modelos. Isso garante que a camada semântica permaneça acessível e fácil de navegar para todos os usuários.

Ferramentas como o pacote dbt-utils podem otimizar significativamente os fluxos de trabalho do dbt, fornecendo macros e utilitários pré-criados que simplificam o desenvolvimento do modelo e garantem uma documentação completa.

Conclusão

A modelagem modular de dados do dbt, as definições centralizadas de métricas, o controle robusto de versões e a integração com ferramentas de BI podem ajudar você a garantir dados consistentes, confiáveis e acessíveis para análises e relatórios.

Este tutorial orientou você na configuração de um projeto dbt, na criação de modelos SQL, na definição de métricas reutilizáveis e na integração da camada semântica com ferramentas de visualização como Tableau e Looker.

Para saber mais sobre o dbt, confira o excelente curso Introduction to dbt!

Torne-se um engenheiro de dados

Comprove suas habilidades como engenheiro de dados pronto para o trabalho.

Moez Ali's photo
Author
Moez Ali
LinkedIn
Twitter

Cientista de dados, fundador e criador do PyCaret

Temas

Saiba mais sobre engenharia de dados com estes cursos!

curso

Introduction to Data Engineering

4 hr
116K
Learn about the world of data engineering in this short course, covering tools and topics like ETL and cloud computing.
Ver DetalhesRight Arrow
Iniciar curso
Ver maisRight Arrow
Relacionado

blog

O que são modelos semânticos do Power BI?

Saiba mais sobre modelos semânticos no Power BI, seus componentes, modos e práticas recomendadas para criá-los e gerenciá-los.
Joleen Bothma's photo

Joleen Bothma

7 min

blog

O que é um banco de dados gráfico? Um guia para iniciantes

Explore o intrincado mundo dos bancos de dados gráficos com nosso guia para iniciantes. Entenda as relações entre os dados, aprofunde-se na comparação entre bancos de dados relacionais e gráficos e explore casos de uso práticos.
Kurtis Pykes 's photo

Kurtis Pykes

11 min

tutorial

Tutorial do Chroma DB: Um guia passo a passo

Com o Chroma DB, você pode gerenciar facilmente documentos de texto, converter texto em embeddings e fazer pesquisas de similaridade.
Abid Ali Awan's photo

Abid Ali Awan

10 min

tutorial

Tutorial de visão geral do banco de dados SQL

Neste tutorial, você aprenderá sobre bancos de dados em SQL.
DataCamp Team's photo

DataCamp Team

3 min

tutorial

Hierarquias do Power BI: Um guia abrangente

Saiba como criar, editar, excluir e implementar hierarquias no Power BI.
Joleen Bothma's photo

Joleen Bothma

11 min

tutorial

Introdução aos acionadores SQL: Um guia para desenvolvedores

Saiba como usar os acionadores SQL para automatizar tarefas, manter a integridade dos dados e melhorar o desempenho do banco de dados. Experimente exemplos práticos como os comandos CREATE, ALTER e DROP no MySQL e no Oracle.
Oluseye Jeremiah's photo

Oluseye Jeremiah

13 min

Ver maisVer mais