DEV Community

Cover image for Pipeline de datos del dólar en Perú con dbt, DuckDB, GitHub Actions y Streamlit (gratis y sin AWS)
JhonyVargas
JhonyVargas

Posted on

Pipeline de datos del dólar en Perú con dbt, DuckDB, GitHub Actions y Streamlit (gratis y sin AWS)

¿A cuánto está el dólar hoy? En Perú casi todo el mundo se lo pregunta en algún momento: quien importa, quien ahorra en dólares o quien paga un curso en línea. En este artículo cuento cómo construí una solución de ingeniería de datos de punta a punta. Descarga cada día el tipo de cambio oficial del Banco Central de Reserva del Perú (BCRP), lo transforma con dbt sobre DuckDB y lo publica en un dashboard público. Todo es automático, con herramientas gratuitas y sin AWS.

📊 Dashboard en vivo: https://tipo-cambio-peru.streamlit.app
💻 Repositorio: https://github.com/JhonyVargas/pipeline-tipo-cambio-peru
🎥 Video (4 min): https://youtu.be/nXBJtwl8tdw

Dashboard del tipo de cambio USD/PEN


🎯 El problema

El BCRP publica el tipo de cambio interbancario en su API de series estadísticas, pero los datos no vienen listos para analizar. Esta es una respuesta real de la API:

"periods": [
  { "name": "10.Nov.26", "values": ["3.41371428571429", "3.41621428571429"] },
  { "name": "11.Nov.26", "values": ["3.40914285714286", "3.41085714285714"] }
]
Enter fullscreen mode Exit fullscreen mode
  • Las fechas son texto con meses en español abreviados (10.Nov.26).
  • Los valores son texto con 14 decimales.
  • Los días sin cotización aparecen como n.d. (no disponible).

El objetivo era una solución que:

  1. Extraiga los datos automáticamente cada día hábil.
  2. Los limpie y transforme con pruebas de calidad.
  3. Los publique en un dashboard abierto a cualquiera.
  4. Cueste S/ 0 y no use AWS.

🏗️ Arquitectura

┌──────────┐   ┌──────────┐   ┌──────────┐   ┌───────────────┐   ┌─────────┐   ┌───────────┐
│ API BCRP │ → │ Python   │ → │ DuckDB   │ → │ dbt           │ → │ Parquet │ → │ Streamlit │
│ (fuente) │   │ Extract  │   │ raw      │   │ staging/marts │   │ /data   │   │ Dashboard │
└──────────┘   └──────────┘   └──────────┘   └───────────────┘   └─────────┘   └───────────┘
                    ▲
                    └──── GitHub Actions (lunes a viernes, 09:00 hora de Lima)
Enter fullscreen mode Exit fullscreen mode

Arquitectura del pipeline

Capa Herramienta Por qué la elegí
Extracción y carga Python Bastan urllib y duckdb, sin librerías pesadas
Almacenamiento DuckDB Data warehouse analítico en un solo archivo, sin servidor
Transformación dbt + dbt-duckdb SQL versionado, modelos por capas y tests de calidad
Orquestación GitHub Actions Ejecuciones programadas gratis en repositorios públicos
Visualización Streamlit + Plotly Dashboard 100 % Python con hosting gratuito

Es un enfoque ELT, no ETL: primero se cargan los datos crudos en el warehouse y la transformación ocurre dentro de él, con dbt. Así, si cambia una regla de limpieza, basta con volver a ejecutar dbt sobre los datos crudos.


1️⃣ Extraer y cargar con Python

El script pipeline/extract.py pide dos series al BCRP: PD04637PD (compra) y PD04638PD (venta), desde 2015 hasta hoy.

SERIES = "PD04637PD-PD04638PD"  # compra - venta
URL = "https://estadisticas.bcrp.gob.pe/estadisticas/series/api/{series}/json/{ini}/{fin}"

def extraer() -> list[dict]:
    url = URL.format(series=SERIES, ini=FECHA_INICIO, fin=date.today().isoformat())
    req = urllib.request.Request(url, headers={"User-Agent": "data-pipeline-tc/1.0"})
    with urllib.request.urlopen(req, timeout=60) as resp:
        payload = json.loads(resp.read().decode("utf-8-sig"))

    return [
        {"periodo": p["name"], "compra": p["values"][0], "venta": p["values"][1]}
        for p in payload["periods"]
    ]
Enter fullscreen mode Exit fullscreen mode

Los datos se cargan tal cual llegan en una tabla raw, todo como VARCHAR. Este paso no limpia nada a propósito; eso le toca a dbt.

con = duckdb.connect("warehouse/tipo_cambio.duckdb")
con.execute("CREATE SCHEMA IF NOT EXISTS raw")
con.execute("""
    CREATE OR REPLACE TABLE raw.tipo_cambio_bcrp (
        periodo    VARCHAR,   -- formato BCRP: '02.Ene.20'
        compra     VARCHAR,   -- texto, puede venir 'n.d.'
        venta      VARCHAR,
        cargado_en TIMESTAMP
    )
""")
con.executemany("INSERT INTO raw.tipo_cambio_bcrp VALUES (?, ?, ?, ?)", filas)
Enter fullscreen mode Exit fullscreen mode

Cada ejecución recarga la tabla completa con CREATE OR REPLACE. Son unos 3 100 registros, así que es muy rápido, y siempre da el mismo resultado, se ejecute las veces que se ejecute.


2️⃣ Transformar con dbt

Esta es la estructura del proyecto dbt:

dbt_tipo_cambio/
├── dbt_project.yml
├── profiles.yml
├── models/
│   ├── staging/
│   │   ├── _sources.yml
│   │   └── stg_tipo_cambio.sql
│   ├── marts/
│   │   ├── fct_tipo_cambio_diario.sql
│   │   ├── fct_tipo_cambio_mensual.sql
│   │   └── fct_tipo_cambio_anual.sql
│   └── schema.yml
└── tests/
    ├── assert_tipo_cambio_en_rango.sql
    └── assert_venta_mayor_o_igual_compra.sql
Enter fullscreen mode Exit fullscreen mode

La conexión a DuckDB es mínima gracias al adaptador dbt-duckdb:

# profiles.yml
tipo_cambio:
  target: dev
  outputs:
    dev:
      type: duckdb
      path: "{{ env_var('DUCKDB_PATH', 'warehouse/tipo_cambio.duckdb') }}"
      threads: 2
Enter fullscreen mode Exit fullscreen mode

Hay dos capas: staging, que se crea como vista, y marts, que se crea como tabla.

# dbt_project.yml
models:
  tipo_cambio:
    staging:
      +schema: staging
      +materialized: view
    marts:
      +schema: marts
      +materialized: table
Enter fullscreen mode Exit fullscreen mode

Staging: de texto a datos limpios

stg_tipo_cambio separa la fecha '02.Ene.20' en día, mes y año y la convierte a DATE. try_cast convierte 'n.d.' en NULL, y esos días se descartan. Esta es una versión resumida:

with partes as (
    select
        cast(split_part(periodo, '.', 1) as integer)       as dia,
        lower(split_part(periodo, '.', 2))                  as mes_txt,
        2000 + cast(split_part(periodo, '.', 3) as integer) as anio,
        try_cast(compra as double)                          as tc_compra,
        try_cast(venta  as double)                          as tc_venta
    from {{ source('bcrp', 'tipo_cambio_bcrp') }}
)

select
    make_date(anio,
        case mes_txt
            when 'ene' then 1 when 'feb' then 2 when 'mar' then 3
            when 'abr' then 4 when 'may' then 5 when 'jun' then 6
            when 'jul' then 7 when 'ago' then 8 when 'set' then 9
            when 'sep' then 9 when 'oct' then 10 when 'nov' then 11
            when 'dic' then 12
        end,
        dia)                 as fecha,
    round(tc_compra, 4)      as tc_compra,
    round(tc_venta, 4)       as tc_venta
from partes
where tc_compra is not null
  and tc_venta  is not null
Enter fullscreen mode Exit fullscreen mode

Marts: métricas para el análisis

fct_tipo_cambio_diario usa funciones de ventana para calcular la variación diaria y las medias móviles:

select
    fecha,
    tc_compra,
    tc_venta,
    round(tc_venta - tc_compra, 4)                                   as spread,
    round((tc_venta / lag(tc_venta) over (order by fecha) - 1) * 100, 4) as var_diaria_pct,
    round(avg(tc_venta) over (
        order by fecha rows between 6 preceding and current row), 4)  as media_movil_7d,
    round(avg(tc_venta) over (
        order by fecha rows between 29 preceding and current row), 4) as media_movil_30d
from {{ ref('stg_tipo_cambio') }}
Enter fullscreen mode Exit fullscreen mode

fct_tipo_cambio_mensual arma las velas mensuales: apertura, máximo, mínimo y cierre. DuckDB tiene dos funciones muy útiles para esto: arg_min y arg_max. Por ejemplo, arg_min(tc_venta, fecha) devuelve el tc_venta del día con la fecha más temprana.

select
    date_trunc('month', fecha)::date      as periodo,
    arg_min(tc_venta, fecha)              as apertura,
    arg_max(tc_venta, fecha)              as cierre,
    max(tc_venta)                         as maximo,
    min(tc_venta)                         as minimo,
    round(stddev_samp(var_diaria_pct), 4) as volatilidad_pct
from {{ ref('fct_tipo_cambio_diario') }}
group by 1
Enter fullscreen mode Exit fullscreen mode

Tests de calidad: 13 en total

En schema.yml hay 11 tests genéricos (unique y not_null) sobre las claves de cada modelo y de la fuente. Además hay dos tests propios en SQL. El primero es un rango razonable: si el dólar sale por debajo de S/ 2.5 o por encima de S/ 5.0, casi seguro es un error de la fuente.

-- tests/assert_tipo_cambio_en_rango.sql
select * from {{ ref('fct_tipo_cambio_diario') }}
where tc_venta not between 2.5 and 5.0
   or tc_compra not between 2.5 and 5.0
Enter fullscreen mode Exit fullscreen mode

El segundo es una regla de negocio: el precio de venta no debería ser menor que el de compra.

-- tests/assert_venta_mayor_o_igual_compra.sql
{{ config(severity='warn') }}

select * from {{ ref('fct_tipo_cambio_diario') }}
where tc_venta < tc_compra
Enter fullscreen mode Exit fullscreen mode

Este test está configurado como advertencia y no como error. Al revisar los datos encontré que el propio BCRP tiene 5 días históricos en los que la venta es menor que la compra, con diferencias menores a un céntimo. Como error, ese test detendría el pipeline todos los días por un problema histórico que no puedo corregir. Como advertencia, la anomalía queda registrada y los datos se siguen actualizando.

Esta es la salida real de dbt build en GitHub Actions:

Found 4 models, 13 data tests, 1 source, 470 macros
...
Completed with 1 warning:
Done. PASS=16 WARN=1 ERROR=0 SKIP=0 NO-OP=0 REUSED=0 TOTAL=17
Enter fullscreen mode Exit fullscreen mode

3️⃣ Exportar a Parquet

El archivo de DuckDB se regenera en cada ejecución y no se sube al repositorio. Lo que sí se sube son 3 archivos Parquet que suman unos 185 KB, uno por cada mart, más un metadata.json con la fecha de actualización.

for tabla in ["fct_tipo_cambio_diario", "fct_tipo_cambio_mensual", "fct_tipo_cambio_anual"]:
    con.execute(f"COPY (SELECT * FROM main_marts.{tabla}) TO 'data/{tabla}.parquet' (FORMAT PARQUET)")
Enter fullscreen mode Exit fullscreen mode

Gracias a esto, el dashboard no necesita una base de datos, un servidor ni credenciales: lee archivos que ya están en el repositorio.


4️⃣ Orquestar con GitHub Actions

Un pequeño orquestador, pipeline/run_all.py, ejecuta los tres pasos en orden. Si alguno falla, se detiene. Es el mismo comando en local y en la nube:

paso("1. Extract + Load (API BCRP -> DuckDB)", [py, "pipeline/extract.py"])
paso("2. Transform + Test (dbt build)",        dbt + ["build"] + flags)
paso("3. Export (marts -> Parquet)",           [py, "pipeline/export.py"])
Enter fullscreen mode Exit fullscreen mode

Y este es el workflow que lo ejecuta todos los días (versión resumida):

name: Pipeline ELT - Tipo de cambio

on:
  schedule:
    - cron: "0 14 * * 1-5"   # lunes a viernes, 09:00 hora de Lima (14:00 UTC)
  workflow_dispatch:          # botón para ejecutarlo manualmente

permissions:
  contents: write             # necesario para hacer commit de los datos

jobs:
  elt:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v7
      - uses: actions/setup-python@v7
        with:
          python-version: "3.12"
          cache: pip
      - run: pip install -r requirements-pipeline.txt
      - run: python pipeline/run_all.py
      - name: Publicar datos actualizados (commit automático)
        run: |
          git config user.name  "github-actions[bot]"
          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
          git add data/
          if git diff --staged --quiet; then
            echo "Sin cambios en los datos."
          else
            git commit -m "data: actualización automática $(date -u +'%Y-%m-%d %H:%M') UTC [skip ci]"
            git push
          fi
Enter fullscreen mode Exit fullscreen mode

La ejecución completa tarda menos de un minuto. Además, guarda la documentación generada por dbt como artefacto de la ejecución.


5️⃣ Dashboard con Streamlit

El dashboard lee los Parquet con DuckDB y los guarda en caché durante una hora:

@st.cache_data(ttl=3600)
def cargar():
    con = duckdb.connect()
    q = lambda t: con.execute(f"SELECT * FROM read_parquet('{(DATA / t).as_posix()}.parquet')").df()
    diario, mensual, anual = q("fct_tipo_cambio_diario"), q("fct_tipo_cambio_mensual"), q("fct_tipo_cambio_anual")
    meta = json.loads((DATA / "metadata.json").read_text(encoding="utf-8"))
    return diario, mensual, anual, meta
Enter fullscreen mode Exit fullscreen mode

Esto es lo que incluye:

  • Indicadores: compra y venta del último día, promedio del mes, variación del año y rango de las últimas 52 semanas.
  • Evolución: la serie histórica con filtros de 1 mes a todo el histórico, y medias móviles.
  • Análisis mensual: velas mensuales (naranja si el dólar subió, azul si bajó) y la variación de cada mes.
  • Volatilidad: por año, con la distribución de las variaciones diarias.
  • Datos: la tabla completa, descargable en CSV.
  • Conversor de dólares a soles y de soles a dólares con el tipo de cambio del día.

Velas mensuales del tipo de cambio


6️⃣ Publicar en Streamlit Community Cloud

  1. Entra en share.streamlit.io con tu cuenta de GitHub.
  2. Create app → elige el repositorio, la rama main y el archivo app/streamlit_app.py.
  3. Elige una URL personalizada, por ejemplo tipo-cambio-peru.
  4. En Advanced settings, elige Python 3.12.
  5. Pulsa Deploy.

⚠️ Un detalle que me pasó: la versión de Python que venía por defecto era 3.14, pero las versiones que fijé de duckdb (1.3.2) y pandas (2.2.3) no tienen paquetes precompilados para 3.14, así que la instalación habría fallado. Usar la misma versión de Python que en GitHub Actions evita sorpresas.

Así queda cerrado el ciclo de despliegue automático:

GitHub Actions (cron) → descarga y transforma → commit de /data → Streamlit Cloud detecta el commit → dashboard actualizado
Enter fullscreen mode Exit fullscreen mode

Nadie tiene que tocar nada. El dashboard se actualiza solo cada día hábil.


📈 Resultados

  • 3 097 registros descargados de la API del BCRP.
  • 2 956 días hábiles válidos, de enero de 2015 a hoy, resumidos en 143 meses y 12 años.
  • 13 tests de calidad en cada ejecución.
  • Pipeline completo en menos de 1 minuto.
  • Costo de infraestructura: S/ 0.

💡 Lo que aprendí

  1. Cargar los datos crudos tal cual (ELT) permite volver a procesarlo todo cuando cambia una regla, sin tener que pedir los datos otra vez a la fuente.
  2. No todo test debe detener el pipeline. Si la fuente tiene anomalías históricas que no puedes corregir, una advertencia documentada es más honesta y más útil que un error permanente.
  3. DuckDB alcanza para mucho. Para miles o incluso millones de filas, un warehouse en un solo archivo evita tener que administrar servidores.
  4. El cron de GitHub Actions no es puntual. Programé las 14:00 UTC y en la práctica las ejecuciones empezaron entre las 20:40 y las 21:10 UTC. Para datos diarios no importa, pero hay que saberlo.
  5. Fija las versiones de Python y de las librerías, y usa las mismas en todos los entornos.

▶️ Pruébalo tú

git clone https://github.com/JhonyVargas/pipeline-tipo-cambio-peru.git
cd pipeline-tipo-cambio-peru
pip install -r requirements-pipeline.txt -r requirements.txt
python pipeline/run_all.py            # ejecuta todo el pipeline
streamlit run app/streamlit_app.py    # abre el dashboard
Enter fullscreen mode Exit fullscreen mode

🎥 Video


🔗 Enlaces

GitHub logo JhonyVargas / pipeline-tipo-cambio-peru

Pipeline ELT del tipo de cambio USD/PEN con Python, DuckDB, dbt, GitHub Actions y Streamlit

💱 Pipeline de Tipo de Cambio USD/PEN

Solución de ingeniería de datos que extrae automáticamente el tipo de cambio interbancario publicado por el Banco Central de Reserva del Perú (BCRP), lo transforma con dbt sobre DuckDB y lo publica en un dashboard interactivo en Streamlit Community Cloud.

Pipeline

🔗 Dashboard en vivo: https://tipo-cambio-peru.streamlit.app


🏗️ Arquitectura

┌────────────┐    ┌──────────┐    ┌──────────┐    ┌──────────────┐    ┌─────────┐    ┌────────────┐
│ API BCRP   │ →  │ Python   │ →  │ DuckDB   │ →  │ dbt          │ →  │ Parquet │ →  │ Streamlit  │
│ (fuente)   │    │ Extract  │    │ raw      │    │ staging/marts│    │ /data   │    │ Dashboard  │
└────────────┘    └──────────┘    └──────────┘    └──────────────┘    └─────────┘    └────────────┘
                         ▲
                         └──── GitHub Actions (cron lunes a viernes 09:00 Lima)
Capa Herramienta Descripción
Extract + Load Python Descarga la serie del BCRP y la guarda cruda en raw.tipo_cambio_bcrp
Almacenamiento DuckDB Data warehouse analítico embebido (un solo archivo)
Transform dbt Modelos staging →
…

Si te sirvió, deja un ❤️ o cuéntame en los comentarios qué le agregarías al pipeline.

Jhony Vargas Luque, estudiante del curso de Inteligencia de Negocios.

Top comments (0)