Cómo llevar datos de sensores IoT a Grafana

Grafana ya está en la pantalla de muchas salas de ingeniería. Grafica CPU, memoria, latencia de peticiones y profundidad de cola, y los equipos confían en él. Así que cuando empiezan a aparecer datos de sensores, desde sondas de temperatura, medidores de agua o vibración de máquinas, el instinto natural es ponerlos en el mismo Grafana que todos ya vigilan. Pero Grafana no recolecta desde un dispositivo, no almacena una serie temporal de lecturas y no habla los protocolos que usa tu hardware. Dibuja lo que una fuente de datos le entrega, y nada más. Por eso la pregunta real no es “¿puede Grafana graficar datos IoT?”, sino “¿qué se interpone entre el dispositivo y Grafana, haciendo la ingesta, el almacenamiento y la API?”, y ese hueco es donde encaja TagoIO.

Qué necesita Grafana de ti en realidad

Grafana lee. Se conecta a una fuente de datos, ejecuta una consulta y renderiza paneles. Para la infraestructura, esa fuente de datos suele ser Prometheus o una base de datos SQL que algo más ya está llenando. Para los datos IoT tienes que aportar lo mismo: un endpoint que Grafana pueda consultar y que devuelva valores con marca de tiempo.

Grafana soporta esto mediante plugins de fuente de datos. La fuente de datos Infinity es la elección habitual para APIs REST arbitrarias. Puede traer JSON sobre HTTP, manejar tokens Bearer y claves de API, y parsear una respuesta en filas y series temporales usando JQ o UQL. También existe un plugin JSON API que hace un trabajo parecido. En cualquier caso, el contrato es el mismo: dale a Grafana una URL que devuelva JSON, dile cuáles campos son la marca de tiempo y el valor, y él grafica el resto.

Lo que ninguno de estos plugins hace es hablar con tus sensores. Dan por sentado que los datos ya existen en algún lugar con una puerta de entrada HTTP. Esa suposición es todo el trabajo, y es la parte que Grafana delega.

La parte previa a Grafana: ingesta y almacenamiento

Un sensor en campo no emite JSON limpio sobre HTTPS por su cuenta. Habla LoRaWAN a través de un network server, o NB-IoT, o MQTT en bruto, o publica un payload propietario que necesita decodificarse. Antes de que cualquiera de esos datos se convierta en un gráfico, tienen que pasar tres cosas:

• La lectura tiene que recibirse, lo que implica manejar el protocolo del dispositivo y la red por la que viaja.
• El payload en bruto tiene que parsearse en variables con nombre, con unidades y marcas de tiempo.
• Los valores parseados tienen que almacenarse como una serie temporal que puedas consultar después, no solo la última lectura.

Este es el trabajo que hace TagoIO. Los dispositivos se conectan por HTTP o MQTT, con MQTT disponible en el puerto 1883 o 8883 sobre SSL. TagoIO tiene integraciones de dispositivos para más de 500 modelos y redes, así que el manejo del protocolo queda resuelto antes de que escribas nada. Un payload parser convierte los bytes en bruto en variables como temperature o fuel_level. Esas variables aterrizan en el almacenamiento de series temporales, donde cada registro lleva un time, un value, un nombre de variable y a menudo una unit. La configuración exacta del conector y del parser vive en docs.tago.io, y los pasos varían según el dispositivo, así que sigue la documentación para tu hardware específico en lugar de una receta genérica.

El punto es que, para cuando Grafana pide los datos, los datos existen, están limpios y tienen una API por delante.

Exponer los datos de TagoIO para que Grafana pueda leerlos

TagoIO tiene una API REST completa, y leer datos de dispositivos desde ella es una petición GET. El endpoint es la URL de datos regional:

GET https://api.<region>.tago.io/data

La autenticación es un Device Token que se pasa en la cabecera Authorization. Según docs.tago.io, la petición para traer una sola variable se ve así:

https://api.<region>.tago.io/data?variable=temperature&qty=99

Puedes filtrar por ventana de tiempo con start_date y end_date, que aceptan cadenas ISO o expresiones relativas como 1 day. Puedes pedir solo la última lectura con query=last_item. Puedes solicitar varias variables a la vez usando sintaxis de array, variable[]=temperature&variable[]=pressure.

La respuesta es JSON con un array result, donde cada entrada lleva los campos que a Grafana le importan:

{
  "status": true,
  "result": [
    {
      "id": "547e353d7dbf3af122c0257d",
      "time": "2014-12-02T21:55:09.301Z",
      "unit": "%",
      "value": 32,
      "variable": "fuel_level"
    }
  ]
}

Esa forma se asigna limpiamente a una consulta de Infinity o JSON API. La raíz es result, time es tu columna de marca de tiempo, value es la columna numérica, y variable te permite dividir o filtrar las series. Apunta la fuente de datos de Grafana a la URL de datos de TagoIO, configura la cabecera Authorization con tu Device Token, establece la raíz en result y mapea las columnas. A partir de ahí, es un panel normal de Grafana.

Unas cuantas advertencias honestas que conviene revisar contra la documentación. TagoIO aplica límites de tasa, así que un dashboard que se refresca cada pocos segundos en muchos paneles puede alcanzarlos. El valor por defecto de qty es pequeño, así que configúralo de forma explícita cuando quieras un rango de tiempo real. Y los tokens tienen ámbito, así que piensa qué token debería tener una instancia compartida de Grafana antes de pegarlo en una fuente de datos.

Cuándo no necesitas Grafana encima de TagoIO

Vale la pena tomar este camino solo cuando justifica la segunda herramienta. TagoIO tiene sus propios dashboards y widgets. Si lo que necesitas son gráficos de líneas, medidores, mapas y tablas sobre datos de dispositivos, los dashboards integrados ya lo cubren, y agregar Grafana significa ejecutar y mantener otro sistema, gestionar otro conjunto de credenciales y sincronizar dos definiciones del mismo gráfico. Eso son más piezas móviles para un resultado que ya tienes.

Poner Grafana encima tiene sentido en casos concretos. Estás estandarizando en Grafana entre equipos y quieres que los datos IoT vivan junto a las métricas de infraestructura para que la gente mire en un solo lugar. Necesitas un panel, una regla de alerta o un plugin específico de Grafana que TagoIO no ofrece. Estás combinando lecturas IoT con fuentes no IoT en una sola vista de Grafana. En esos casos, la herramienta extra se paga sola. Si ninguno de ellos aplica, quédate en TagoIO y sáltate la integración.

Dónde encaja TagoIO

Grafana es la capa de visualización, y es bueno siendo la capa de visualización. El trabajo que no puede hacer es todo lo que ocurre antes de que una consulta devuelva JSON limpio: recibir del dispositivo, decodificar el payload y mantener una serie temporal consultable. TagoIO hace ese trabajo y luego expone el resultado a través de una API REST documentada, que es exactamente el tipo de fuente que los plugins de Grafana están hechos para leer. Mantienes Grafana como el cristal frontal y dejas que TagoIO sea la parte del stack que convierte el hardware en datos.

Próximos pasos

• Lee cómo traer datos de dispositivos por la API: Obtención de datos en docs.tago.io
• Revisa los tipos de token y su ámbito: Device Token en docs.tago.io
• Consulta los detalles de conexión MQTT si prefieres la ingesta por streaming: Resumen de MQTT en docs.tago.io
• Crea una cuenta y conecta un dispositivo: tago.io