Cómo instalar Grafana en Ubuntu 24.04 y crear paneles

Grafana es una plataforma de visualización de código abierto que convierte métricas de fuentes como Prometheus, Loki, MySQL o PostgreSQL en paneles interactivos y alertas. En este tutorial instalarás Grafana OSS en Ubuntu 24.04 desde el repositorio oficial de Grafana Labs, lo publicarás detrás de Nginx con un certificado de Let's Encrypt, conectarás Prometheus como fuente de datos, importarás un panel de la comunidad y crearás el tuyo propio con variables y una regla de alerta.

Requisitos previos

Para seguir esta guía necesitas:

Un servidor con Ubuntu 24.04 LTS, por ejemplo un VPS de CubePath, con al menos 1 GB de RAM.
Un usuario no root con privilegios sudo.
UFW activo con el acceso SSH permitido.
Un dominio o subdominio, en esta guía your_domain, con un registro DNS A que apunte a la IP del servidor.
Prometheus con Node Exporter en marcha y accesible desde este servidor en http://localhost:9090. Si todavía no lo tienes, instálalo primero siguiendo la guía de instalación de Prometheus en Ubuntu 24.04.

Paso 1: Añadir el repositorio de Grafana e instalarlo

Grafana Labs mantiene un repositorio APT firmado con los paquetes de cada versión. Instala las herramientas necesarias y descarga la clave del repositorio en /etc/apt/keyrings:

sudo apt update
sudo apt install -y apt-transport-https wget gnupg
sudo mkdir -p /etc/apt/keyrings
sudo wget -O /etc/apt/keyrings/grafana.asc https://apt.grafana.com/gpg-full.key
sudo chmod 644 /etc/apt/keyrings/grafana.asc

Añade el repositorio estable, indicando con signed-by qué clave lo firma:

echo "deb [signed-by=/etc/apt/keyrings/grafana.asc] https://apt.grafana.com stable main" | sudo tee /etc/apt/sources.list.d/grafana.list

Actualiza el índice e instala Grafana OSS:

sudo apt update
sudo apt install grafana

El paquete crea el servicio grafana-server, pero no lo arranca. Habilítalo e inícialo:

sudo systemctl enable --now grafana-server

Comprueba que está activo y que responde en el puerto 3000:

sudo systemctl status grafana-server --no-pager
curl -s http://localhost:3000/api/health

● grafana-server.service - Grafana instance
     Loaded: loaded (/usr/lib/systemd/system/grafana-server.service; enabled; preset: enabled)
     Active: active (running) since Fri 2026-09-25 11:02:17 UTC; 12s ago

{
  "database": "ok",
  "version": "13.2.2"
}

Las futuras versiones de Grafana se instalarán con el resto de actualizaciones del sistema (sudo apt upgrade).

Paso 2: Configurar Grafana para funcionar detrás de un proxy

Por defecto Grafana escucha en todas las interfaces en el puerto 3000 y por HTTP. Como lo vas a publicar a través de Nginx con HTTPS, haz que solo escuche en local e indícale su URL pública, que usa para generar enlaces y redirecciones. Edita el archivo de configuración:

sudo nano /etc/grafana/grafana.ini

Busca la sección [server] y ajusta estas claves (en el archivo vienen comentadas con ;, quita el punto y coma):

[server]
http_addr = 127.0.0.1
http_port = 3000
domain = your_domain
root_url = https://your_domain/

En la sección [users], desactiva el registro libre de usuarios para que solo un administrador pueda crear cuentas:

[users]
allow_sign_up = false

Reinicia Grafana y comprueba que ahora solo escucha en 127.0.0.1:

sudo systemctl restart grafana-server
sudo ss -tlnp | grep 3000

LISTEN 0      4096       127.0.0.1:3000       0.0.0.0:*    users:(("grafana",pid=3312,fd=12))

Paso 3: Publicar Grafana con Nginx y HTTPS

Instala Nginx y Certbot con su plugin para Nginx:

sudo apt install -y nginx certbot python3-certbot-nginx

Crea el sitio para Grafana. El bloque location /api/live/ es necesario para las conexiones WebSocket que Grafana usa para actualizar paneles en directo:

sudo nano /etc/nginx/sites-available/grafana

map $http_upgrade $connection_upgrade {
    default upgrade;
    ''      close;
}

server {
    listen 80;
    listen [::]:80;
    server_name your_domain;

    location / {
        proxy_set_header Host $host;
        proxy_pass http://127.0.0.1:3000;
    }

    location /api/live/ {
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection $connection_upgrade;
        proxy_set_header Host $host;
        proxy_pass http://127.0.0.1:3000;
    }
}

Activa el sitio, comprueba la sintaxis y recarga Nginx:

sudo ln -s /etc/nginx/sites-available/grafana /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl reload nginx

nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Abre los puertos 80 y 443 en el firewall:

sudo ufw allow 'Nginx Full'

Obtén el certificado. Certbot modifica el sitio para servirlo por HTTPS y redirigir el tráfico HTTP:

sudo certbot --nginx -d your_domain

Cuando termine, comprueba que Grafana responde por HTTPS:

curl -sI https://your_domain/login | head -1

HTTP/2 200

Certbot instala un temporizador de systemd que renueva el certificado automáticamente. Puedes probar la renovación con sudo certbot renew --dry-run.

Paso 4: Iniciar sesión y cambiar la contraseña de administrador

Abre https://your_domain en el navegador. El usuario y la contraseña iniciales son admin y admin. Grafana te pedirá una contraseña nueva en el primer inicio de sesión: elige una contraseña fuerte, porque la interfaz ya es accesible desde Internet.

Para dar acceso a otras personas, crea cuentas desde Administration, Users and access, Users, New user, y asígnales el rol adecuado: Viewer para consultar paneles, Editor para crearlos y Admin solo para quien gestione la organización.

Paso 5: Añadir Prometheus como fuente de datos

Puedes añadir fuentes de datos desde la interfaz (Connections, Data sources, Add data source), pero es más reproducible declararlas en un archivo de provisioning: Grafana lo lee al arrancar y crea o actualiza la fuente de datos.

sudo nano /etc/grafana/provisioning/datasources/prometheus.yaml

apiVersion: 1

datasources:
  - name: Prometheus
    type: prometheus
    uid: prometheus
    access: proxy
    url: http://localhost:9090
    isDefault: true
    jsonData:
      timeInterval: 15s

access: proxy significa que es el servidor de Grafana, no el navegador, quien consulta Prometheus, así que Prometheus no necesita ser accesible desde fuera. timeInterval debe coincidir con el scrape_interval de Prometheus.

Si protegiste Prometheus con autenticación básica, añade las credenciales. secureJsonData se guarda cifrado en la base de datos de Grafana:

    basicAuth: true
    basicAuthUser: admin
    secureJsonData:
      basicAuthPassword: your_prometheus_password

Como este archivo puede contener una contraseña, restringe sus permisos y reinicia Grafana:

sudo chown root:grafana /etc/grafana/provisioning/datasources/prometheus.yaml
sudo chmod 640 /etc/grafana/provisioning/datasources/prometheus.yaml
sudo systemctl restart grafana-server

En la interfaz, ve a Connections, Data sources, abre Prometheus y pulsa Test al final de la página. Deberías ver el mensaje Successfully queried the Prometheus API.

Paso 6: Importar un panel de la comunidad

La comunidad publica miles de paneles listos para usar en grafana.com. Para métricas de Node Exporter, el más usado es Node Exporter Full, con el ID 1860.

Ve a Dashboards, New, Import.
Escribe 1860 en el campo del ID y pulsa Load.
En el desplegable de la fuente de datos, elige Prometheus y pulsa Import.

El panel muestra CPU, memoria, disco, red y carga del sistema. Usa el selector Instance de la parte superior para cambiar de servidor si monitorizas varios. Si ves No data, comprueba que el job de Node Exporter en Prometheus se llama node o ajusta el selector Job del panel.

Paso 7: Crear tu propio panel

Los paneles importados son un buen punto de partida, pero lo habitual es crear uno propio con lo que te importa. Vas a construir un panel con dos visualizaciones y una variable para elegir el servidor.

Crear la variable del servidor

Las variables convierten un panel en una plantilla: una misma consulta sirve para cualquier servidor.

Ve a Dashboards, New, New dashboard y, antes de añadir nada, abre Settings (el icono de engranaje) y la pestaña Variables.
Pulsa Add variable y configura:
- Variable type: Query
- Name: instance
- Data source: Prometheus
- Query type: Label values, Label: instance, Metric: node_uname_info
Pulsa Back to dashboard. Aparecerá un desplegable instance en la parte superior con tus servidores.

La consulta equivalente, si prefieres escribirla como Classic query, es:

label_values(node_uname_info, instance)

Añadir una serie temporal de uso de CPU

Pulsa Add, Visualization y elige Time series.
En el editor de consultas cambia a modo Code y escribe:

100 - (avg by (instance) (rate(node_cpu_seconds_total{mode="idle", instance="$instance"}[$__rate_interval])) * 100)

$instance es la variable que acabas de crear y $__rate_interval es una variable de Grafana que calcula una ventana adecuada para rate() según el intervalo de scrape y el rango de tiempo del panel.

En el panel de opciones de la derecha, pon como Title Uso de CPU, en Standard options elige Unit Percent (0-100) y fija Min en 0 y Max en 100.
En Thresholds, deja el verde como base y añade 70 en amarillo y 90 en rojo. En Graph styles, Show thresholds, elige As lines para verlos en la gráfica.
Pulsa Back to dashboard.

Añadir un indicador de uso de disco

Pulsa Add, Visualization y elige Gauge.
Escribe la consulta:

100 * (1 - node_filesystem_avail_bytes{instance="$instance", mountpoint="/"} / node_filesystem_size_bytes{instance="$instance", mountpoint="/"})

Ponle como título Disco raíz, unidad Percent (0-100), y umbrales en 80 (amarillo) y 90 (rojo).
Pulsa Back to dashboard, coloca los paneles arrastrándolos y pulsa Save dashboard. Dale un nombre, por ejemplo Servidores.

Cambia el valor del desplegable instance y verás cómo ambos paneles se actualizan para el servidor elegido.

Guardar el panel como JSON

Cada panel se puede exportar como JSON desde Export, Export as JSON. Guarda ese archivo en un repositorio Git: es la forma más sencilla de tener copia de seguridad de tus paneles y de reproducirlos en otra instancia de Grafana con Import.

Paso 8: Crear una alerta

Grafana puede evaluar consultas periódicamente y avisar cuando se cumple una condición. Primero define a quién avisar:

Ve a Alerting, Contact points y pulsa Add contact point.
Ponle un nombre, elige la integración (por ejemplo Email, Slack, Discord o Webhook) y rellena sus datos. El envío por email requiere configurar antes la sección [smtp] de grafana.ini.
Pulsa Test para comprobar que el aviso llega, y guarda.

Después crea la regla:

Ve a Alerting, Alert rules, New alert rule.
Ponle el nombre Disco casi lleno y usa la consulta:

100 * (1 - node_filesystem_avail_bytes{mountpoint="/"} / node_filesystem_size_bytes{mountpoint="/"})

En la condición, indica que se dispare cuando el valor esté por encima de 90.
Elige o crea una carpeta y un grupo de evaluación con un intervalo de 1m, y en Pending period pon 5m para no avisar por picos puntuales.
En la sección de notificaciones, selecciona el contact point que creaste y guarda la regla.

La regla genera una alerta por cada servidor que supere el umbral, porque la consulta devuelve una serie por instancia.

Solución de problemas

502 Bad Gateway al abrir el dominio. Nginx no llega a Grafana. Comprueba que el servicio está activo y escucha en 127.0.0.1:3000:

sudo systemctl status grafana-server --no-pager
sudo ss -tlnp | grep 3000

Grafana no arranca tras editar grafana.ini o un archivo de provisioning. El log indica la línea con el error:

sudo journalctl -u grafana-server -n 50 --no-pager

Los paneles muestran No data. Pulsa Edit en el panel y abre Query inspector: verás la consulta exacta enviada a Prometheus y su respuesta. Lo más habitual es que la etiqueta job o instance no coincida con la que tienen tus métricas. Comprueba en Prometheus que la métrica existe ejecutando la misma consulta sin filtros.

Has olvidado la contraseña de administrador. Puedes restablecerla desde el servidor con la CLI de Grafana:

sudo grafana cli --homepath /usr/share/grafana --config /etc/grafana/grafana.ini admin reset-admin-password your_new_password

Conclusión

Tienes Grafana instalado en Ubuntu 24.04 desde el repositorio oficial, servido por HTTPS a través de Nginx, con Prometheus como fuente de datos declarada por provisioning, un panel de la comunidad, un panel propio con variables y una regla de alerta. Como siguientes pasos puedes provisionar también tus paneles desde archivos en /etc/grafana/provisioning/dashboards, añadir Loki como fuente de datos para ver logs junto a las métricas, o cambiar la base de datos interna de SQLite a PostgreSQL o MySQL si vas a tener muchos usuarios.

On this page