Cómo agregar métricas por dispositivo en Real-Time Analytics: paso a paso

João Barros 09 de November de 2026 4 min de lectura

La agregación por dispositivo en Real-Time Analytics permite resumir señales (CPU, temperatura, errores) por dispositivo en ventanas móviles, reduciendo ruido y soportando decisiones en tiempo real. Este tutorial muestra cómo configurar una canalización simple, agregar por device_id y emitir métricas agregadas regularmente — útil para paneles y alertas.

Requisitos previos

Cuenta con acceso a un servicio de ingestión de eventos en tiempo real (p. ej.: Event Hub, Kafka o Azure IoT Hub).
Un clúster o servicio de procesamiento que soporte consultas en streaming (p. ej.: Azure Stream Analytics, Kusto/ADX o Apache Flink).
Datos de telemetría con un identificador de dispositivo (device_id), timestamp y valor métrico (metric_value).
Conocimientos básicos de KQL o SQL de streaming; ejemplo en KQL/ADX incluido.

Paso 1: Modelar los eventos y el esquema

Es importante tener un esquema consistente. Cada evento debe incluir device_id, timestamp (UTC) y metric_value numérico. Tener también un event_type o sensor_type ayuda a agrupar.

{
  "device_id": "device-123",
  "timestamp": "2026-11-09T12:34:56Z",
  "metric_name": "temperature",
  "metric_value": 23.7
}

Paso 2: Ingesta y normalización

Ingesta de los eventos a un tópico/stream. Normalizar timestamps a UTC y validar tipos evita sorpresas en la agregación por ventanas. En Azure Event Hub o IoT Hub, configure un consumer que escriba en el store de streaming de su motor (p. ej.: Event Hub -> ADX ingestion).

Paso 3: Definir la ventana móvil y la granularidad de salida

Elija una ventana móvil (sliding window) que equilibre latencia y estabilidad. Ej.: 1 minuto de ventana con salto (hop) de 10 segundos — esto produce una métrica actualizada cada 10 s con datos de los últimos 60 s.

Paso 4: Escribir la consulta de agregación en KQL (ejemplo ADX)

Ejemplo usando KQL en Azure Data Explorer (ADX) para agregar por device_id y metric_name con media, recuento y percentil 95 en ventanas móviles. Ajuste el nombre de la tabla de ingestión.

Telemetry
| where timestamp between (ago(10m) .. now())
| where isnotempty(device_id) and isnotempty(metric_value)
| summarize
    avg_value = avg(metric_value),
    count_events = count(),
    p95 = percentile(metric_value, 95)
  by device_id, metric_name, window = slidingwindow(1m, 10s)
| project window_start = window.start, window_end = window.end, device_id, metric_name, avg_value, count_events, p95

Paso 5: Emitir métricas agregadas al downstream

Escriba el resultado a un sink que alimente paneles o alertas (p. ej.: Power BI, Azure Monitor Metrics, o un tópico Kafka). En ADX puede usar

// Ejemplo conceptual: exportar a Event Hub o función que escriba en Timescale/Influx
.create-or-alter function ExportAggregates() {
  Telemetry
  | where timestamp between (ago(10m) .. now())
  | summarize avg_value=avg(metric_value), count_events=count() by device_id, metric_name, window=slidingwindow(1m,10s)
  | project window_start=window.start, window_end=window.end, device_id, metric_name, avg_value, count_events
}

Paso 6: Tratar outliers y falta de datos

Filtre lecturas inválidas antes de la agregación (valores nulos, negativos cuando son imposibles). Para dispositivos con pocos eventos, combine agregaciones con un mínimo de recuento para evitar métricas ruidosas.

... | where metric_value >= 0
| summarize avg_value=avg(metric_value), count_events=count() by device_id, metric_name, window=slidingwindow(1m,10s)
| where count_events >= 3

Verificar el resultado

Confirme que las métricas agregadas aparecen en el sink con timestamps coherentes y la frecuencia esperada (p. ej.: cada 10 s). Verifique para algunos device_id manualmente: compare la media calculada por la consulta con la media de los eventos crudos en el intervalo. Monitorice la latencia de extremo a extremo y la tasa de eventos por ventana para garantizar que la ventana móvil dispone de suficientes datos.

Conclusión

Agregar métricas por dispositivo en Real-Time Analytics permite visualizar tendencias locales y reducir ruido, soportando alertas y paneles más fiables. Próximos pasos: experimentar con ventanas distintas, enriquecer con metadatos del dispositivo y exportar a Power BI o Azure Monitor. Consejo: empiece con ventanas más grandes e ir reduciéndolas hasta obtener el equilibrio entre latencia y estabilidad — ¿qué ventana va a probar primero?