curso
Implementação de uma camada semântica com dbt: Um guia prático
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.
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
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
ouavg_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
ouavg_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
Saiba mais sobre engenharia de dados com estes cursos!
curso
Introduction to Snowflake
curso
Introduction to dbt

blog
O que são modelos semânticos do Power BI?
blog
O que é um banco de dados gráfico? Um guia para iniciantes
tutorial
Tutorial do Chroma DB: Um guia passo a passo
tutorial
Tutorial de visão geral do banco de dados SQL

DataCamp Team
3 min
tutorial
Hierarquias do Power BI: Um guia abrangente
tutorial
Introdução aos acionadores SQL: Um guia para desenvolvedores

Oluseye Jeremiah
13 min