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) 

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 

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 

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 

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 

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

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 

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

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 

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; 

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