El stack TIG combina tres herramientas: Telegraf recoge métricas del sistema y de servicios, InfluxDB las almacena como series temporales y Grafana las muestra en paneles. A diferencia de Prometheus, que consulta a los exportadores, aquí es Telegraf quien envía los datos a InfluxDB. En este tutorial instalarás las tres piezas en un mismo servidor Ubuntu 24.04, enviarás las métricas de CPU, memoria, disco y red a InfluxDB 2 y crearás un panel en Grafana.

Requisitos previos

Para seguir esta guía necesitas:

  • Un servidor con Ubuntu 24.04 LTS, por ejemplo un VPS de CubePath, con al menos 2 GB de RAM y 20 GB libres en disco. El espacio necesario crece con el número de hosts y el periodo de retención.
  • Un usuario no root con privilegios sudo.
  • UFW activo con SSH permitido. InfluxDB y Telegraf solo se usarán en local; únicamente abrirás el puerto de Grafana.

En esta guía se usa InfluxDB 2, que sigue siendo la versión con soporte de Flux y la integración más directa con Grafana. Todos los componentes escuchan en el mismo servidor.

Paso 1: Añadir el repositorio de InfluxData

Telegraf e InfluxDB se distribuyen desde el mismo repositorio de InfluxData. Descarga su clave de firma:

cd /tmp
curl -fsSL -O https://repos.influxdata.com/influxdata-archive.key

Muestra la huella de la clave y compárala con la que publica InfluxData en la guía de instalación de su documentación (docs.influxdata.com):

gpg --show-keys --with-fingerprint influxdata-archive.key

Si coincide, conviértela al formato binario de apt y guárdala en /etc/apt/keyrings:

sudo install -m 0755 -d /etc/apt/keyrings
gpg --dearmor < influxdata-archive.key | sudo tee /etc/apt/keyrings/influxdata-archive.gpg > /dev/null

Añade el repositorio firmado con esa clave:

echo "deb [signed-by=/etc/apt/keyrings/influxdata-archive.gpg] https://repos.influxdata.com/debian stable main" | sudo tee /etc/apt/sources.list.d/influxdata.list

Actualiza el índice de paquetes y comprueba que apt ve el repositorio:

sudo apt update
apt-cache policy influxdb2 telegraf

Ambos paquetes deben aparecer con una versión candidata procedente de repos.influxdata.com.

Paso 2: Instalar y configurar InfluxDB 2

Instala el servidor y la herramienta de línea de comandos influx, que se distribuye en un paquete aparte:

sudo apt install influxdb2 influxdb2-cli

Arranca el servicio y actívalo al inicio:

sudo systemctl enable --now influxdb

Comprueba que responde en el puerto 8086:

curl -s http://127.0.0.1:8086/health

{"name":"influxdb", "message":"ready for queries and writes", "status":"pass", "checks":[], "version": "v2.x.x", "commit": "..."}

Ahora crea el usuario inicial, la organización y el bucket donde Telegraf escribirá las métricas. Sustituye your_strong_password por una contraseña robusta (mínimo 8 caracteres). La retención de 30d hace que InfluxDB borre automáticamente los datos de más de 30 días:

influx setup \
  --username admin \
  --password 'your_strong_password' \
  --org cubepath \
  --bucket telegraf \
  --retention 30d \
  --force

User	Organization	Bucket
admin	cubepath	telegraf

Este comando también guarda un perfil de CLI con un token de administrador en ~/.influxdbv2/configs, de modo que los siguientes comandos influx se autentican solos. Protege ese archivo como protegerías la contraseña.

Paso 3: Crear tokens para Telegraf y Grafana

Es mejor que cada componente use un token con los permisos mínimos: Telegraf solo necesita escribir en el bucket y Grafana solo leerlo.

Obtén el identificador del bucket telegraf:

influx bucket list --name telegraf

ID			Name		Retention	Shard group duration	Organization ID		Schema Type
0a1b2c3d4e5f6789	telegraf	720h0m0s	24h0m0s			1234567890abcdef	implicit

Crea un token de solo escritura para Telegraf, sustituyendo your_bucket_id por el ID anterior:

influx auth create --org cubepath --description "telegraf write" --write-bucket your_bucket_id

Y otro de solo lectura para Grafana:

influx auth create --org cubepath --description "grafana read" --read-bucket your_bucket_id

Cada comando muestra el token en la columna Token. Cópialos, los usarás en los pasos siguientes. Puedes volver a listarlos con influx auth list.

Paso 4: Instalar y configurar Telegraf

Instala Telegraf desde el mismo repositorio:

sudo apt install telegraf

El archivo /etc/telegraf/telegraf.conf del paquete incluye cientos de plugins comentados y una salida para InfluxDB 1.x que no sirve para InfluxDB 2. Guárdalo como referencia y crea uno limpio:

sudo mv /etc/telegraf/telegraf.conf /etc/telegraf/telegraf.conf.orig
sudo nano /etc/telegraf/telegraf.conf

Añade esta configuración:

[agent]
  interval = "10s"
  round_interval = true
  flush_interval = "10s"
  omit_hostname = false

[[outputs.influxdb_v2]]
  urls = ["http://127.0.0.1:8086"]
  token = "${INFLUX_TOKEN}"
  organization = "cubepath"
  bucket = "telegraf"

[[inputs.cpu]]
  percpu = true
  totalcpu = true
  collect_cpu_time = false
  report_active = false

[[inputs.mem]]

[[inputs.swap]]

[[inputs.system]]

[[inputs.processes]]

[[inputs.disk]]
  ignore_fs = ["tmpfs", "devtmpfs", "devfs", "overlay", "squashfs"]

[[inputs.diskio]]

[[inputs.net]]

El token no se escribe en el archivo: Telegraf sustituye ${INFLUX_TOKEN} por la variable de entorno del mismo nombre. El servicio de systemd de Telegraf lee las variables de /etc/default/telegraf, así que guarda ahí el token de escritura que creaste en el paso 3:

sudo nano /etc/default/telegraf

INFLUX_TOKEN=your_telegraf_token

Restringe los permisos del archivo, ya que contiene un secreto:

sudo chmod 600 /etc/default/telegraf

Antes de arrancar el servicio, prueba la recogida de métricas. La opción --test ejecuta las entradas una vez, imprime el resultado y no envía nada a InfluxDB:

sudo telegraf --config /etc/telegraf/telegraf.conf --test --input-filter cpu:mem

> cpu,cpu=cpu-total,host=your_hostname usage_idle=97.4,usage_system=1.2,usage_user=1.1,... 1790330400000000000
> mem,host=your_hostname available=1654321152i,total=2064384000i,used_percent=19.8,... 1790330400000000000

El paquete arranca Telegraf al instalarse con la configuración original, así que actívalo al inicio y reinícialo para que cargue la nueva:

sudo systemctl enable telegraf
sudo systemctl restart telegraf

Comprueba en el log que no hay errores de escritura:

sudo journalctl -u telegraf -n 20 --no-pager

Deberías ver las líneas de arranque con los plugins cargados (Loaded inputs: cpu disk diskio mem net processes swap system) y ningún mensaje E! sobre influxdb_v2.

Paso 5: Verificar los datos en InfluxDB

Espera unos 30 segundos y consulta los últimos valores de CPU con Flux, el lenguaje de consulta de InfluxDB 2:

influx query 'from(bucket: "telegraf")
  |> range(start: -5m)
  |> filter(fn: (r) => r._measurement == "cpu" and r.cpu == "cpu-total" and r._field == "usage_idle")
  |> last()'

Result: _result
Table: keys: [_start, _stop, _field, _measurement, cpu, host]
...  _value:float  ...
...  97.52         ...

Si la consulta devuelve una tabla con valores, el flujo Telegraf a InfluxDB funciona.

Paso 6: Instalar Grafana

Grafana se instala desde su repositorio oficial. Descarga la clave y añade el repositorio:

curl -fsSL https://apt.grafana.com/gpg.key | gpg --dearmor | sudo tee /etc/apt/keyrings/grafana.gpg > /dev/null
echo "deb [signed-by=/etc/apt/keyrings/grafana.gpg] https://apt.grafana.com stable main" | sudo tee /etc/apt/sources.list.d/grafana.list

Instala Grafana y arranca el servicio:

sudo apt update
sudo apt install grafana
sudo systemctl enable --now grafana-server

Comprueba que responde en el puerto 3000:

curl -s http://127.0.0.1:3000/api/health

{
  "database": "ok",
  "version": "12.x.x",
  ...
}

Abre el puerto de Grafana en el firewall. Si solo vas a acceder desde una IP fija, limita la regla a esa dirección:

sudo ufw allow from your_ip to any port 3000 proto tcp

No abras el puerto 8086: InfluxDB solo recibe datos de Telegraf y consultas de Grafana, ambos en el mismo servidor.

Entra en http://your_server_ip:3000 con el usuario admin y la contraseña admin. Grafana te obligará a cambiarla en el primer acceso.

Paso 7: Añadir InfluxDB como fuente de datos

En Grafana, ve a Connections > Data sources > Add data source y elige InfluxDB. Rellena estos campos:

  • Query language: Flux.
  • URL: http://127.0.0.1:8086.
  • Organization: cubepath.
  • Token: el token de solo lectura creado en el paso 3.
  • Default Bucket: telegraf.

Pulsa Save & test. Grafana debe mostrar un mensaje de éxito indicando que ha encontrado buckets. Si da error de autorización, revisa que el token es el de lectura y que no tiene espacios al principio o al final.

Paso 8: Crear un panel de CPU

Ve a Dashboards > New > New dashboard > Add visualization y selecciona la fuente de datos InfluxDB. En el editor de consultas, pega esta consulta, que calcula el porcentaje de CPU en uso a partir de usage_idle:

from(bucket: "telegraf")
  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)
  |> filter(fn: (r) => r._measurement == "cpu" and r.cpu == "cpu-total" and r._field == "usage_idle")
  |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)
  |> map(fn: (r) => ({r with _value: 100.0 - r._value}))
  |> yield(name: "cpu_used")

Las variables v.timeRangeStart, v.timeRangeStop y v.windowPeriod las rellena Grafana según el intervalo de tiempo seleccionado en el panel, de modo que la consulta se adapta al hacer zoom.

En las opciones de la derecha, pon como Title CPU en uso, en Standard options > Unit elige Percent (0-100) y guarda el panel. Añade otros paneles con el mismo patrón, por ejemplo memoria:

from(bucket: "telegraf")
  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)
  |> filter(fn: (r) => r._measurement == "mem" and r._field == "used_percent")
  |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)

Y espacio en disco usado por punto de montaje:

from(bucket: "telegraf")
  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)
  |> filter(fn: (r) => r._measurement == "disk" and r._field == "used_percent")
  |> aggregateWindow(every: v.windowPeriod, fn: last, createEmpty: false)

Guarda el dashboard. Tras unos minutos verás las gráficas llenarse con los datos que envía Telegraf cada 10 segundos.

Monitorizar otros servidores

Para enviar métricas de más servidores al mismo InfluxDB, instala Telegraf en cada uno con el mismo repositorio (pasos 1 y 4) y apunta urls a la IP privada del servidor de InfluxDB. En ese caso:

  • Haz que InfluxDB escuche también en la red privada y abre el puerto 8086 en UFW solo para las IP de esos servidores: sudo ufw allow from other_server_ip to any port 8086 proto tcp.
  • Si el tráfico cruza Internet, activa TLS en InfluxDB o usa una red privada o VPN entre servidores, ya que el token viaja en cada petición.

La etiqueta host, que Telegraf añade automáticamente, te permite filtrar cada servidor en Grafana.

Solución de problemas

E! [outputs.influxdb_v2] ... 401 Unauthorized: el token no es válido o no tiene permiso de escritura en el bucket. Comprueba el contenido de /etc/default/telegraf y reinicia Telegraf con sudo systemctl restart telegraf.

E! [outputs.influxdb_v2] ... 404 Not Found: bucket "telegraf" not found: el nombre del bucket o de la organización en telegraf.conf no coincide con el creado en influx setup. Revísalos con influx bucket list.

influx: command not found: falta el paquete influxdb2-cli. Instálalo con sudo apt install influxdb2-cli.

El panel de Grafana dice "No data": ejecuta la misma consulta con influx query desde el servidor. Si ahí hay datos, revisa que el intervalo de tiempo del panel incluye los últimos minutos y que la fuente de datos usa Flux y no InfluxQL.

Conclusión

Has montado el stack TIG en Ubuntu 24.04: Telegraf recoge las métricas del sistema cada 10 segundos, InfluxDB 2 las guarda 30 días con tokens de mínimo privilegio y Grafana las muestra en un dashboard propio. La misma base sirve para cualquier otra fuente que Telegraf soporte.

Como siguientes pasos puedes:

  • Añadir plugins de entrada de Telegraf para tus servicios, como inputs.nginx, inputs.mysql o inputs.docker.
  • Configurar alertas en Grafana (Alerting > Alert rules) sobre las mismas consultas Flux.
  • Publicar Grafana con HTTPS detrás de Nginx y cerrar el puerto 3000.