Saltar al contenido principal

Implementar una capa semántica con dbt: Guía práctica

Aprende a construir una capa semántica con dbt, ¡convirtiendo datos brutos en métricas coherentes para herramientas de análisis y BI!
Actualizado 23 ene 2025  · 18 min de lectura

Muchas empresas modernas confían en las capas semánticas para salvar la distancia entre los datos brutos almacenados en almacenes de datos como Snowflake y las percepciones en cuadros de mando o informes. 

Una capa semántica es una abstracción que define métricas, medidas y dimensiones coherentes para el análisis y la elaboración de informes.

En este tutorial, exploraremos cómo implementar una capa semántica utilizando dbt (data build tool), un popular marco de transformación y modelado de datos. Esta guía incluye ejemplos prácticos y reflexiones que te ayudarán a dominar el concepto.

¿Qué es una capa semántica y por qué es importante?

Una capa semántica traduce los datos brutos en métricas y dimensiones coherentes y reutilizables, simplificando el análisis de los datos. Es una herramienta para mantener la uniformidad entre equipos y herramientas.

Ventajas de una capa semántica

  • Definiciones de datos coherentes: Garantiza que las métricas empresariales como ingresos, tasa de rotación, crecimiento interanual, valor medio de los pedidos, etc., se definan de manera uniforme. Esto elimina la confusión causada por diferentes equipos que utilizan definiciones incoherentes y ayuda a mantener la confianza en los datos en toda la organización.
  • Mayor colaboración: Facilita una mejor comunicación y alineación entre los equipos técnicos y no técnicos. Al proporcionar una capa de datos unificada, los equipos técnicos pueden centrarse en la precisión de los datos, mientras que los equipos empresariales aprovechan métricas claras y accesibles para tomar decisiones estratégicas.
  • Aceleración del tiempo de conocimiento: Reduce la ambigüedad, permitiendo una toma de decisiones más rápida. Con una capa semántica, las partes interesadas pueden acceder rápidamente a métricas fiables y analizarlas, minimizando el tiempo dedicado a conciliar datos o resolver discrepancias.

Por qué dbt es ideal para construir una capa semántica

Veamos qué hace que dbt sea la herramienta perfecta para que los ingenieros de datos y analítica construyan una capa semántica.

Una captura de pantalla que muestra la arquitectura del modelado con dbt

Diagrama conceptual de la Capa Semántica dbt, courtesía de dbt Labs

Modelado modular de datos

dbt te permite descomponer transformaciones de datos complejas en modelos modulares reutilizables. Estos modelos se pueden estratificar jerárquicamente, de forma que los modelos de datos fundamentales alimenten a los analíticos de nivel superior. 

Este enfoque hace que el pipeline sea mantenible y permite a los equipos colaborar más eficazmente aislando los cambios en modelos específicos sin que afecten a todo el sistema.

Para saber más sobre los conceptos básicos de dbt y las mejores prácticas para el modelado de datos, consulta el Tutorial de dbt de: 7 Conceptos imprescindibles para los ingenieros de datos. Ofrece ideas que complementan las estrategias aquí expuestas.

Definiciones de métricas centralizadas

Con dbt, la lógica empresarial y las métricas se definen en un único lugar, lo que garantiza la coherencia entre varias herramientas de análisis. Con la función de métricas de dbt, puedes definir una vez los KPI, como ingresos, tasas de conversión o rotación, y utilizarlos en cuadros de mando, informes y análisis sin necesidad de redefinirlos. Esto reduce las discrepancias y garantiza la integridad de los datos.

Control de versiones y documentación

La integración de dbtcon Git facilita un sólido control de versiones, permitiéndote seguir y auditar los cambios a lo largo del tiempo. Junto con su documentación autogenerada, dbt crea una referencia viva y accesible para todas las transformaciones de datosns y métricas. Esto aporta transparencia y permite que los nuevos miembros del equipo se incorporen rápidamente explorando la canalización de datos documentada.

Integración con herramientas BI

dbt funciona con plataformas de BI como Looker, Tableau y Mode, lo que permite integrar la capa semántica en las herramientas de visualización. Mediante las exposiciones dbt, puedes vincular directamente los modelos dbt a los cuadros de mando BI, garantizando que cualquier actualización en los modelos de datos se refleje en los análisis sin intervención manual.

Conviértete en Ingeniero de Datos

Conviértete en un ingeniero de datos mediante el aprendizaje avanzado de Python
Empieza a aprender gratis

Configurar tu proyecto dbt

Normalmente, dbt se asienta sobre almacenes de datos en la nubecomo Snowflake o Google BigQuery. Sin embargo, para simplificar las cosas en este tutorial, nos conectaremos localmente a una base de datos DuckDB .

1. Requisitos previos

  • Instala Python en tu máquina si aún no lo tienes instalado.

2. Instalar las herramientas necesarias

Utiliza pip para instalar la CLI dbt:

pip install dbt-core

Instala DuckDB mediante pip:

pip install duckdb

Instala el adaptador DuckDB mediante pip:

pip install dbt-duckdb

3. Inicializar el proyecto dbt

Crea un nuevo proyecto dbt:

dbt init project_name

Este comando creará un proyecto en tu directorio actual, que tendrá el siguiente aspecto:

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

4. Configurar la conexión a DuckDB

Edita el archivo profiles.yml, que normalmente se encuentra en la carpeta ~/.dbt/. Si no existe, crea uno:

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

El profiles.yml contiene el puntero a la ubicación del archivo de la base de datos .duckdb, que deberás indicar en el path

Puedes crear una nueva base de datos o descargarte una pequeña de muestra desde aquí. En la siguiente sección, utilizaré el archivo duckdb-demo.duckdb de la misma fuente .

Para crear un nuevo archivo de base de datos duckDB, simplemente ejecuta lo siguiente:

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

5. Probar la conexión

Ahora, podemos probar ejecutando dbt debug para comprobar si todo funciona. Asegúrate de que estás en la carpeta del proyecto antes de ejecutar el comando:

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

Si todo está configurado correctamente, obtendrás algo como esto a cambio (todas las rutas están redactadas por motivos de privacidad):

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]

Crear una capa semántica con dbt

¡Enhorabuena por haber llegado tan lejos! Has configurado con éxito tu primer proyecto dbt.

Veamos ahora cómo crear una capa semántica sobre una base de datos. Para ello, puedesimportar tus propios datos desde CSV a DuckDB o descargarte un pequeño archivo de base de datos de muestra (5 MB) desde aquí.

A continuación, podemos escribir un sencillo script en Python para explorar lo que contiene este archivo de base de datos:

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()

Salida (truncada por brevedad):

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)
...
…

Esta base de datos tiene 17 tablas. Sin embargo, para este tutorial sólo vamos a utilizar la tabla bank_failures. Esta tabla contiene los datos financieros históricos de los bancos en quiebra en EEUU.

1. Definición de los modelos SQL

Los modelos SQL son la base de cualquier proyecto dbt. Representan las transformaciones estructuradas de los datos brutos en un formato más analítico. 

Para este tutorial, definiremos dos archivos SQL en la carpeta models/

Crea un nuevo archivo en la carpeta models de tu proyecto llamado base_bank_failures.sql:

SELECT *
FROM bank_failures

Este archivo extrae directamente los datos brutos de la tabla bank_failures. Actúa como modelo base, al que pueden hacer referencia los modelos posteriores.

Después, crea otro archivo llamado clean_bank_failures.sql:

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

Este archivo se basa en el modelo base_bank_failures (utilizando la función ref() ) para agregar y limpiar los datos, preparándolos para el análisis. Resume los fracasos totales y los activos por estado.

2. Crear un archivo metrics.yml

El archivo metrics.yml define métricas centralizadas y reutilizables que garantizan la coherencia entre análisis y cuadros de mando.

En nuestro caso, describirá métricas como total_assets y avg_assets_per_failure, haciéndolas disponibles para su uso en herramientas de BI y otras 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. Crear un archivo exposures.yml

El archivo exposures.yml vincula tus modelos dbt a herramientas externas como Tableau o Looker. Documenta estas conexiones, garantizando la trazabilidad y la coherencia.

Este archivo especifica que el modelo clean_bank_failures se utiliza en un cuadro de mandos de Tableau, proporcionando detalles sobre el propietario y la dependencia:

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')

Construir y probar la capa semántica

Para validar y construir con éxito tu proyecto dbt, aquí tienes algunos comandos útiles que puedes utilizar:

1. Construye los modelos: Ejecuta el comando dbt build para materializar todos los modelos, aplicar pruebas y ejecutar semillas e instantáneas. Este comando combina las funcionalidades de dbt run y dbt test:

dbt build

2. Prueba los modelos: Si sólo quieres validar tus datos con pruebas después de construirlos, utiliza el comando dbt test. Esto garantiza que todas las pruebas de calidad de los datos (por ejemplo, las comprobaciones de unicidad y no nulo) se apliquen a tus modelos.

dbt test

3. Ejecuta modelos o pruebas específicos: Para ejecutar sólo modelos o pruebas concretos, proporciona sus nombres como argumentos. Por ejemplo, para ejecutar un único modelo:

dbt run --select clean_bank_failures

Para comprobar una columna concreta:

dbt test --select clean_bank_failures.State

Integrar la capa semántica con las herramientas de BI

Para conectar dbt a herramientas de BI como Looker o Tableau, sigue estos pasos para exponer la capa semántica de forma eficaz y asegurarte de que las herramientas de BI pueden hacer referencia directa a los modelos y métricas de dbt:

1. Habilitar exposiciones en dbt

En tu proyecto dbt, crea un archivo exposures.yml en la carpeta models, con el siguiente aspecto:

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. Preparar tu conexión a la base de datos

  • Asegúrate de que los modelos de datos transformados están disponibles en tu base de datos (por ejemplo, Snowflake, BigQuery, DuckDB).
  • Ejecuta dbt build para materializar los modelos dbt en la base de datos.

3. Conectar Tableau a modelos dbt

  • Abre Tableau Desktop y crea una nueva conexión con tu base de datos.
  • Selecciona el esquema donde se almacenan los modelos dbt.
  • Arrastra y suelta los modelos dbt (por ejemplo, clean_bank_failures) en el espacio de trabajo de Tableau.

4. Definir métricas en Tableau

  • En Tableau, utiliza las métricas definidas por dbt, como total_assets o avg_assets_per_failure, directamente en tus visualizaciones para garantizar la coherencia.
  • Crea campos calculados si es necesario para mejorar las visualizaciones.

5. Conectar Looker a modelos dbt

  • En Looker, ve al panel de administración y establece una conexión con tu base de datos.
  • Crea una vista LookML para cada modelo dbt importando el esquema y los campos.
  • Utiliza las métricas total_assets o avg_assets_per_failure definidas en dbt para construir Exploraciones y cuadros de mando Looker coherentes.

Buenas prácticas para implantar una capa semántica con dbt

Ahora que tienes una visión general de los pasos necesarios para construir una capa semántica con dbt, repasemos algunas buenas prácticas. 

Centralizar la lógica empresarial

Define todas las reglas empresariales en dbt para garantizar la coherencia y la mantenibilidad. Al centralizar la lógica empresarial, eliminas las definiciones redundantes entre herramientas, creando una única fuente de verdad que todas las partes interesadas pueden actualizar y comprender fácilmente. 

Modularizar los modelos

Divide las transformaciones en componentes lógicos y reutilizables. Por ejemplo, crea modelos base para los datos brutos, modelos intermedios para los datos depurados y transformados, y modelos finales para los datos listos para el análisis. 

Esta estructura modular simplifica la resolución de problemas, fomenta la reutilización del código y permite la colaboración entre los miembros del equipo, que pueden trabajar en componentes individuales sin interrumpir todo el canal.

Documéntalo todo

Aprovecha la documentación automatizada de dbt para mantener tu capa semántica bien organizada y transparente. 

Utiliza descripciones en los archivos YAML para dar explicaciones claras sobre los modelos, las métricas y las columnas. 

Actualiza regularmente la documentación para reflejar los cambios y utiliza los gráficos de linaje autogenerados por dbt para visualizar las relaciones entre modelos. Esto garantiza que la capa semántica siga siendo accesible y fácil de navegar para todos los usuarios.

Herramientas como el paquete dbt-utils pueden agilizar significativamente tus flujos de trabajo dbt, proporcionando macros y utilidades preconstruidas que simplifican el desarrollo de modelos y garantizan una documentación exhaustiva.

Conclusión

La implementación de una capa semántica con dbt es un potente enfoque para salvar la distancia entre los datos brutos y las perspectivas procesables. El modelado modular de datos de dbt, las definiciones centralizadas de métricas, el sólido control de versiones y la integración con herramientas de BI pueden ayudarte a garantizar datos coherentes, fiables y accesibles para el análisis y la elaboración de informes.

Este tutorial te ha guiado a través de la configuración de un proyecto dbt, la creación de modelos SQL, la definición de métricas reutilizables y la integración de la capa semántica con herramientas de visualización como Tableau y Looker.

Para saber más sobre el dbt, ¡consulta el excelente curso Introducción al dbt!

Conviértete en Ingeniero de Datos

Demuestra tus habilidades como ingeniero de datos preparado para el trabajo.

Moez Ali's photo
Author
Moez Ali
LinkedIn
Twitter

Científico de Datos, Fundador y Creador de PyCaret

Temas

¡Aprende más sobre ingeniería de datos con estos 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 detallesRight Arrow
Comienza el curso
Ver másRight Arrow
Relacionado

blog

¿Qué son los modelos semánticos de Power BI?

Conozca los modelos semánticos en Power BI, sus componentes, modos y mejores prácticas para crearlos y gestionarlos.
Joleen Bothma's photo

Joleen Bothma

7 min

blog

Contratos de datos desmitificados: Todo lo que necesitas saber

Lograr la escalabilidad en los sistemas de datos distribuidos y reducir los errores.
Mike Shakhomirov's photo

Mike Shakhomirov

24 min

blog

¿Qué es la gestión de datos? Guía práctica con ejemplos

Aprende los conceptos y teorías fundamentales de la gestión de datos, junto con algunos ejemplos prácticos. Utiliza estas habilidades en tu trabajo diario de ciencia de datos para generar datos limpios y útiles para tus modelos.
Tim Lu's photo

Tim Lu

12 min

tutorial

Tutorial de Chroma DB: guía paso a paso

Con Chroma DB, puedes gestionar fácilmente documentos de texto, convertir texto en incrustaciones y hacer búsquedas por similitud.
Abid Ali Awan's photo

Abid Ali Awan

10 min

tutorial

Tutorial de Power BI DAX para principiantes

Aprende qué es DAX y descubre la sintaxis y las funciones DAX fundamentales que necesitarás para llevar tus conocimientos de Power BI al siguiente nivel.
Joleen Bothma's photo

Joleen Bothma

9 min

tutorial

Introducción a los disparadores SQL: Guía para desarrolladores

Aprende a utilizar los disparadores SQL para automatizar tareas, mantener la integridad de los datos y mejorar el rendimiento de la base de datos. Prueba ejemplos prácticos como los comandos CREATE, ALTER y DROP en MySQL y Oracle.
Oluseye Jeremiah's photo

Oluseye Jeremiah

13 min

Ver másVer más