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.
Top comments (0)