El disponer de una caché rápida no es suficiente si no se puede supervisar su comportamiento. Una instancia de Valkey puede procesar millones de operaciones por segundo mientras el ratio de aciertos disminuye, el consumo de memoria aumenta o comienzan a producirse expulsiones de claves sin que nadie lo detecte.
La combinación de Prometheus y Grafana permite recopilar métricas en tiempo real, almacenarlas históricamente y visualizarlas mediante paneles interactivos.
Con esta infraestructura es posible monitorizar aspectos críticos como:
- Operaciones por segundo.
- Ratio de aciertos y fallos de caché.
- Uso de memoria.
- Evicciones de claves.
- Clientes conectados.
- Latencia y rendimiento general.
- Disponibilidad del servicio.
La arquitectura de monitorización estará formada por tres componentes:
- Valkey: servidor de datos.
- Redis Exporter: exporta métricas de Valkey en formato Prometheus.
- Prometheus: recopila y almacena las métricas.
- Grafana: genera paneles y visualizaciones.
Requisitos previos
Antes de comenzar, asegúrate de disponer de:
- Una instancia funcional de Valkey.
- Un servidor Linux con acceso sudo.
- Conectividad a Internet.
- Puertos disponibles:
| Servicio | Puerto |
|---|---|
| Redis Exporter | 9121 |
| Prometheus | 9090 |
| Grafana | 3000 |
Puedes instalar todos los componentes en el mismo servidor o distribuirlos entre varios sistemas.
¿Cómo instalar Redis Exporter para Valkey?
Valkey no expone métricas Prometheus de forma nativa.
Para ello se utiliza Redis Exporter, una herramienta compatible con Valkey que consulta métricas mediante comandos internos y las transforma en métricas Prometheus.
¿Cómo descargar la última versión?
REVER=$(curl -fsSL https://api.github.com/repos/oliver006/redis_exporter/releases/latest | grep -oP '"tag_name":\s*"\K[^"]+')
cd /tmp
curl -fsSL \
"https://github.com/oliver006/redis_exporter/releases/download/${REVER}/redis_exporter-${REVER}.linux-amd64.tar.gz" \
-o redis_exporter.tar.gz
tar xzf redis_exporter.tar.gz
sudo install -m755 \
redis_exporter-${REVER}.linux-amd64/redis_exporter \
/usr/local/bin/redis_exporter
¿Cómo crear un usuario dedicado?
Por seguridad, es recomendable ejecutar el exporter con un usuario independiente.
sudo useradd \
--system \
--no-create-home \
--shell /usr/sbin/nologin \
exporter
¿Cómo configurar Redis Exporter como servicio systemd?
Crear el archivo:
sudo nano /etc/systemd/system/redis_exporter.service
Contenido:
[Unit]
Description=Valkey Metrics Exporter
After=network.target valkey.service
[Service]
User=exporter
ExecStart=/usr/local/bin/redis_exporter \
-redis.addr redis://127.0.0.1:6379
Restart=on-failure
[Install]
WantedBy=multi-user.target
Si Valkey utiliza contraseña:
ExecStart=/usr/local/bin/redis_exporter \
-redis.addr redis://127.0.0.1:6379 \
-redis.password TU_PASSWORD
¿Cómo iniciar Redis Exporter?
sudo systemctl daemon-reload
sudo systemctl enable --now redis_exporter
Comprobar estado:
sudo systemctl status redis_exporter
Verificar que responde:
curl http://127.0.0.1:9121/metrics
Entre las métricas aparecerán:
redis_up
redis_memory_used_bytes
redis_connected_clients
redis_commands_processed_total
La métrica:
redis_up 1
indica que el exporter puede comunicarse correctamente con Valkey.
¿Cómo instalar Prometheus?
Descargar Prometheus
PVER=$(curl -fsSL https://api.github.com/repos/prometheus/prometheus/releases/latest | grep -oP '"tag_name":\s*"v\K[^"]+')
cd /tmp
curl -fsSL \
"https://github.com/prometheus/prometheus/releases/download/v${PVER}/prometheus-${PVER}.linux-amd64.tar.gz" \
-o prometheus.tar.gz
tar xzf prometheus.tar.gz
cd prometheus-${PVER}.linux-amd64
Instalar binarios:
sudo install -m755 prometheus promtool /usr/local/bin/
Crear usuario:
sudo useradd \
--system \
--no-create-home \
--shell /usr/sbin/nologin \
prometheus
Crear directorios:
sudo mkdir -p /etc/prometheus
sudo mkdir -p /var/lib/prometheus
¿Cómo configurar Prometheus?
Crear:
sudo nano /etc/prometheus/prometheus.yml
Contenido:
global:
scrape_interval: 15s
evaluation_interval: 15s
rule_files:
- /etc/prometheus/valkey_rules.yml
scrape_configs:
- job_name: valkey
static_configs:
- targets:
- 127.0.0.1:9121
Servicio systemd para Prometheus
Crear:
sudo nano /etc/systemd/system/prometheus.service
Contenido:
[Unit]
Description=Prometheus
After=network.target
[Service]
User=prometheus
ExecStart=/usr/local/bin/prometheus \
--config.file=/etc/prometheus/prometheus.yml \
--storage.tsdb.path=/var/lib/prometheus \
--web.listen-address=0.0.0.0:9090
Restart=on-failure
[Install]
WantedBy=multi-user.target
Aplicar permisos:
sudo chown -R prometheus:prometheus \
/etc/prometheus \
/var/lib/prometheus
Iniciar servicio:
sudo systemctl daemon-reload
sudo systemctl enable --now prometheus
Verificar:
systemctl status prometheus
Acceder desde el navegador:
http://SERVIDOR:9090
Comprobar que el objetivo aparece como:
UP
en:
Status → Targets
Métricas fundamentales de Valkey
Aunque el exporter expone cientos de métricas, algunas son especialmente importantes.
Operaciones por segundo
rate(redis_commands_processed_total[5m])
Permite medir la carga real del servidor.
Ratio de aciertos de caché
rate(redis_keyspace_hits_total[5m])
/
(
rate(redis_keyspace_hits_total[5m])
+
rate(redis_keyspace_misses_total[5m])
)
Un valor elevado indica que la mayoría de consultas se resuelven directamente desde la memoria.
Uso de memoria
redis_memory_used_bytes
/
redis_memory_max_bytes
Permite conocer el porcentaje de memoria consumida respecto al límite configurado.
Evicciones
rate(redis_evicted_keys_total[5m])
Un incremento constante suele indicar que la memoria asignada es insuficiente.
Clientes conectados
redis_connected_clients
Un crecimiento inesperado puede señalar fugas de conexiones o problemas en las aplicaciones cliente.
Clientes bloqueados
redis_blocked_clients
Permite detectar operaciones bloqueantes o cuellos de botella.
¿Cómo instalar Grafana?
Añadir repositorio
sudo apt install -y \
apt-transport-https \
software-properties-common \
wget
sudo mkdir -p /etc/apt/keyrings
wget -q -O - https://apt.grafana.com/gpg.key \
| sudo gpg --dearmor \
-o /etc/apt/keyrings/grafana.gpg
echo "deb [signed-by=/etc/apt/keyrings/grafana.gpg] https://apt.grafana.com stable main" \
| sudo tee /etc/apt/sources.list.d/grafana.list
Instalar:
sudo apt update
sudo apt install -y grafana
¿Cómo configurar Prometheus como origen de datos?
Crear:
sudo nano /etc/grafana/provisioning/datasources/prometheus.yml
Contenido:
apiVersion: 1
datasources:
- name: Prometheus
type: prometheus
access: proxy
url: http://127.0.0.1:9090
isDefault: true
Iniciar Grafana:
sudo systemctl enable --now grafana-server
Verificar:
curl http://127.0.0.1:3000/api/health
Acceder:
http://SERVIDOR:3000
Credenciales iniciales:
Usuario: admin
Contraseña: admin
Grafana solicitará cambiar la contraseña en el primer inicio.
¿Cómo importar un dashboard de Valkey?
Grafana dispone de numerosos paneles preparados para Redis y Valkey.
Uno de los más utilizados es:
Dashboard ID: 763
Importarlo desde:
Dashboards → Import
Seleccionando Prometheus como fuente de datos.
El dashboard mostrará:
- Operaciones por segundo.
- Uso de memoria.
- Clientes conectados.
- Evicciones.
- Hit ratio.
- Uso de CPU.
- Persistencia.
- Estadísticas generales.
¿Cómo crear alertas en Prometheus?
Crear:
sudo nano /etc/prometheus/valkey_rules.yml
Contenido:
groups:
- name: valkey
rules:
- alert: ValkeyDown
expr: redis_up == 0
for: 1m
- alert: ValkeyHighMemory
expr: redis_memory_used_bytes / redis_memory_max_bytes > 0.90
for: 5m
- alert: ValkeyLowHitRatio
expr: (
rate(redis_keyspace_hits_total[5m])
/
(
rate(redis_keyspace_hits_total[5m])
+
rate(redis_keyspace_misses_total[5m])
)
) < 0.50
for: 10m
Validar reglas:
promtool check rules /etc/prometheus/valkey_rules.yml
Recargar Prometheus:
sudo systemctl reload prometheus
Recomendaciones de seguridad
- Mantener Valkey accesible únicamente desde redes privadas.
- Proteger Grafana mediante HTTPS.
- No exponer Prometheus ni Redis Exporter directamente a Internet.
- Utilizar autenticación en Valkey.
- Limitar el acceso mediante firewall.
- Configurar alertas de memoria y disponibilidad.
- Supervisar regularmente el ratio de aciertos y las evicciones.
Una infraestructura de monitorización correctamente configurada permite detectar problemas de rendimiento, saturación de memoria o degradación de la caché antes de que afecten a las aplicaciones, facilitando una gestión proactiva y una mayor estabilidad de los servicios que dependen de Valkey.