---
title: "Cómo montar el stack TIG en Ubuntu 24.04 con InfluxDB 2"
description: "Instala Telegraf, InfluxDB 2 y Grafana en Ubuntu 24.04 desde sus repositorios oficiales, recoge métricas del sistema y visualízalas en Grafana con Flux."
category: "Stack de Observabilidad"
language: es
source: https://cubepath.com/es/docs/stack-de-observabilidad/stack-tig-telegraf-influxdb-grafana
updated: 2026-09-25
---

# Cómo montar el stack TIG en Ubuntu 24.04 con InfluxDB 2

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:

```bash
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`):

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

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

```bash
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:

```bash
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:

```bash
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:

```bash
sudo apt install influxdb2 influxdb2-cli
```

Arranca el servicio y actívalo al inicio:

```bash
sudo systemctl enable --now influxdb
```

Comprueba que responde en el puerto `8086`:

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

```output
{"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:

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

```output
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`:

```bash
influx bucket list --name telegraf
```

```output
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:

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

Y otro de solo lectura para Grafana:

```bash
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:

```bash
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:

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

Añade esta configuración:

```toml
[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:

```bash
sudo nano /etc/default/telegraf
```

```ini
INFLUX_TOKEN=your_telegraf_token
```

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

```bash
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:

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

```output
> 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:

```bash
sudo systemctl enable telegraf
sudo systemctl restart telegraf
```

Comprueba en el log que no hay errores de escritura:

```bash
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:

```bash
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()'
```

```output
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:

```bash
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:

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

Comprueba que responde en el puerto `3000`:

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

```output
{
  "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:

```bash
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.

> Importante: para un uso en producción, publica Grafana detrás de un proxy inverso con HTTPS (por ejemplo Nginx con Let's Encrypt) en lugar de exponer el puerto `3000` en HTTP.

## 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`:

```flux
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:

```flux
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:

```flux
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`.