DEV Community

Fátima Yupa
Fátima Yupa

Posted on

De un CSV de sensores a un modelo analítico con dbt y DuckDB

Un CSV de sensores trae lecturas, pero todavía no ofrece una tabla lista para analizar. En este proyecto preparo las fechas y temperaturas, reviso la calidad de los registros y calculo un resumen diario por sala y ubicación del sensor.

El modelo toma como referencia las columnas de IOT-temp.csv, el archivo del laboratorio. El repositorio público trae una muestra sintética para reproducir la demo; si tienes el CSV original, puedes sustituirla en tu copia local. dbt Core organiza las transformaciones SQL y DuckDB guarda las tablas. GitHub Actions ejecuta el flujo y publica un tablero en GitHub Pages, sin AWS.

Código: repositorio público · Demo: tablero

El recorrido de los datos

seeds/iot_temperature.csv (muestra sintética)
      ↓ dbt seed
tabla iot_temperature (copia de origen)
      ↓ modelo de preparación
stg_iot_readings (tipos y campos normalizados)
      ↓ modelo analítico
daily_temperature_summary (métricas por fecha, sala y ubicación)
Enter fullscreen mode Exit fullscreen mode

La semilla carga el CSV sin cambiar sus columnas. El modelo de preparación convierte fecha y temperatura y normaliza out_in. El modelo final calcula el número de lecturas y las temperaturas mínima, media y máxima de cada grupo. Un script exporta ese resultado a JSON para el tablero público.

1. Preparar el proyecto

Clona el repositorio. La estructura principal es esta; seeds/iot_temperature.csv ya contiene la muestra sintética:

iot-data-engineering-dbt-duckdb/
├── dbt_project.yml
├── profiles.yml
├── seeds/
│   └── iot_temperature.csv
├── models/
│   ├── staging/stg_iot_readings.sql
│   ├── marts/daily_temperature_summary.sql
│   └── schema.yml
├── scripts/export_site_data.py
├── site/index.html
└── .github/workflows/deploy.yml
Enter fullscreen mode Exit fullscreen mode

Clona el proyecto e instala sus dependencias:

git clone https://github.com/Sofxx7/iot-data-engineering-dbt-duckdb.git
cd iot-data-engineering-dbt-duckdb
py -m venv .venv
.venv\Scripts\Activate.ps1
python -m pip install -r requirements.txt
Enter fullscreen mode Exit fullscreen mode

El archivo dbt_project.yml declara el proyecto y fija los tipos de la semilla CSV:

name: iot_temperature
version: "1.0.0"
config-version: 2
profile: iot_temperature

model-paths: ["models"]
seed-paths: ["seeds"]
clean-targets: ["target", "dbt_packages"]

seeds:
  iot_temperature:
    +column_types:
      id: varchar
      room_id: varchar
      noted_date: varchar
      temp: integer
      out_in: varchar
Enter fullscreen mode Exit fullscreen mode

En profiles.yml, la conexión apunta a un archivo local. Este perfil no contiene credenciales:

iot_temperature:
  target: dev
  outputs:
    dev:
      type: duckdb
      path: iot_temperature.duckdb
      threads: 1
Enter fullscreen mode Exit fullscreen mode

2. Preparar las lecturas

El CSV almacena noted_date como texto con el patrón día-mes-año y hora. El modelo lo convierte a fecha y hora y deja temp como número. Si una conversión falla, try_strptime o try_cast devuelve NULL; los controles de calidad pueden detectar ese registro.

Guarda esto como models/staging/stg_iot_readings.sql:

select
    cast(id as varchar) as reading_id,
    nullif(trim(cast(room_id as varchar)), '') as room_id,
    try_strptime(
        trim(cast(noted_date as varchar)),
        '%d-%m-%Y %H:%M'
    ) as reading_at,
    try_cast(temp as integer) as temperature,
    upper(trim(cast(out_in as varchar))) as position
from {{ ref('iot_temperature') }}
Enter fullscreen mode Exit fullscreen mode

ref() le indica a dbt que este modelo depende de la semilla iot_temperature. Así se construye el orden de ejecución sin tener que escribir manualmente una secuencia de scripts.

3. Crear una tabla para el análisis

El segundo modelo transforma las observaciones en métricas por día, sala y posición del sensor. Guárdalo como models/marts/daily_temperature_summary.sql:

select
    cast(reading_at as date) as reading_date,
    room_id,
    position,
    count(*) as reading_count,
    min(temperature) as min_temperature,
    avg(temperature) as avg_temperature,
    max(temperature) as max_temperature
from {{ ref('stg_iot_readings') }}
where reading_at is not null
  and temperature is not null
  and room_id is not null
group by 1, 2, 3
Enter fullscreen mode Exit fullscreen mode

La tabla resultante evita repetir la conversión del CSV en cada consulta. La media se calcula con las lecturas disponibles; el flujo no inventa datos para los momentos sin medición.

4. Declarar controles de calidad

models/schema.yml declara controles para el identificador, los campos necesarios y los valores esperados de position:

version: 2

models:
  - name: stg_iot_readings
    columns:
      - name: reading_id
        data_tests:
          - not_null
          - unique
      - name: room_id
        data_tests:
          - not_null
      - name: reading_at
        data_tests:
          - not_null
      - name: temperature
        data_tests:
          - not_null
      - name: position
        data_tests:
          - accepted_values:
              arguments:
                values: ['IN', 'OUT']
Enter fullscreen mode Exit fullscreen mode

Si una prueba falla, conviene revisar las filas originales y el formato de la fuente antes de publicar el resumen. Por ejemplo, un identificador repetido puede indicar que el origen repitió una observación; eliminarlo sin investigar podría cambiar los conteos.

5. Ejecutar y publicar el resultado

Desde la carpeta del proyecto, ejecuta:

dbt seed --profiles-dir .
dbt run --profiles-dir .
dbt test --profiles-dir .
python scripts/export_site_data.py
Enter fullscreen mode Exit fullscreen mode

El primer comando carga la muestra; el segundo construye los modelos; el tercero ejecuta los controles declarados. DuckDB guarda las tablas en iot_temperature.duckdb y el script produce site/data.json. Para consultar directamente la tabla final, abre la base con DuckDB y ejecuta:

select
    reading_date,
    room_id,
    position,
    reading_count,
    round(avg_temperature, 2) as avg_temperature
from daily_temperature_summary
order by reading_date, room_id, position;
Enter fullscreen mode Exit fullscreen mode

Despliegue automático y resultado

Al enviar cambios a main, GitHub Actions instala las dependencias, ejecuta dbt seed y dbt run, genera site/data.json y publica el tablero en GitHub Pages. Los controles de dbt test quedan disponibles para ejecutarlos por separado. El registro del despliegue terminó correctamente y la demo pública muestra los resultados de la muestra sintética.

Con esa muestra, el flujo procesó 16 lecturas de dos días y calculó una temperatura media de 23,69 en las unidades del CSV. Son cifras de demostración, no resultados de los sensores originales.

Qué aporta esta solución

Cada paso tiene una función clara y dbt registra sus dependencias mediante ref(). Si cambia el formato de origen, reviso el modelo de preparación. Si cambia una métrica, modifico el resumen diario sin reescribir la carga completa.

El procesamiento es por lotes y se ejecuta durante el despliegue. La página sirve resultados ya calculados; no consulta una base DuckDB en vivo ni recibe telemetría en tiempo real. Las cifras visibles corresponden a la muestra sintética del repositorio, no a las lecturas originales del laboratorio.

Referencias

Top comments (0)