Cómo instalar VictoriaMetrics en Ubuntu 24.04

VictoriaMetrics es una base de datos de series temporales compatible con Prometheus: entiende PromQL, acepta el protocolo remote_write y puede hacer scraping de exporters por sí misma. Usa bastante menos memoria y disco que Prometheus para el mismo volumen de datos, y en su versión single-node es un único binario. En este tutorial instalarás VictoriaMetrics en Ubuntu 24.04 como servicio systemd, harás que recoja las métricas del propio servidor con node_exporter, las consultarás con PromQL y verás cómo conectarlo a Grafana y a un Prometheus existente.

Requisitos previos

Para seguir esta guía necesitas:

Un servidor con Ubuntu 24.04 LTS de 64 bits (x86_64), por ejemplo un VPS de CubePath.
Un usuario no root con privilegios sudo.
Al menos 1 GB de RAM y un disco SSD. El espacio necesario depende del número de series y de la retención; unos pocos servidores con node_exporter ocupan del orden de cientos de MB al mes.

VictoriaMetrics escuchará solo en 127.0.0.1:8428 y accederás a su interfaz web mediante un túnel SSH, así que no hace falta abrir puertos.

Paso 1: Descargar e instalar VictoriaMetrics

Descarga la última versión single-node desde GitHub (1.152.0 al escribir esta guía; consulta la página de versiones y ajusta la variable si hay una más reciente) junto con su archivo de sumas de comprobación:

VM_VERSION=v1.152.0
cd /tmp
wget "https://github.com/VictoriaMetrics/VictoriaMetrics/releases/download/${VM_VERSION}/victoria-metrics-linux-amd64-${VM_VERSION}.tar.gz"
wget "https://github.com/VictoriaMetrics/VictoriaMetrics/releases/download/${VM_VERSION}/victoria-metrics-linux-amd64-${VM_VERSION}_checksums.txt"

Verifica la descarga. --ignore-missing omite la línea del binario, que aún no has extraído:

sha256sum -c --ignore-missing "victoria-metrics-linux-amd64-${VM_VERSION}_checksums.txt"

victoria-metrics-linux-amd64-v1.152.0.tar.gz: OK

El archivo contiene un único binario, victoria-metrics-prod. Extráelo e instálalo con un nombre más corto:

tar xzf "victoria-metrics-linux-amd64-${VM_VERSION}.tar.gz"
sudo install -m 0755 victoria-metrics-prod /usr/local/bin/victoria-metrics

Comprueba la versión:

victoria-metrics -version

victoria-metrics-20260911-150101-tags-v1.152.0-0-g...

Paso 2: Crear el usuario y los directorios

VictoriaMetrics no necesita privilegios. Crea un usuario de sistema, el directorio de datos y el de configuración:

sudo useradd --system --no-create-home --shell /usr/sbin/nologin victoriametrics
sudo install -d -o victoriametrics -g victoriametrics -m 0750 /var/lib/victoriametrics
sudo install -d -m 0755 /etc/victoriametrics

Paso 3: Instalar node_exporter

Para tener métricas que almacenar, instala node_exporter, que expone el uso de CPU, memoria, disco y red del servidor. Ubuntu lo incluye en sus repositorios:

sudo apt update
sudo apt install prometheus-node-exporter

Por defecto escucha en todas las interfaces, en el puerto 9100. Como solo lo va a consultar VictoriaMetrics desde el mismo servidor, limítalo a 127.0.0.1. Abre su archivo de opciones:

sudo nano /etc/default/prometheus-node-exporter

Localiza la línea ARGS="" y déjala así:

ARGS="--web.listen-address=127.0.0.1:9100"

Reinicia el servicio y comprueba que expone métricas:

sudo systemctl restart prometheus-node-exporter
curl -s http://127.0.0.1:9100/metrics | grep -m1 node_load1

# HELP node_load1 1m load average.

Paso 4: Configurar el scraping

VictoriaMetrics single-node puede leer un archivo de configuración con el mismo formato que la sección scrape_configs de Prometheus. Créalo:

sudo nano /etc/victoriametrics/scrape.yml

Añade dos trabajos: uno para node_exporter y otro para las métricas internas de la propia VictoriaMetrics:

global:
  scrape_interval: 15s

scrape_configs:
  - job_name: node
    static_configs:
      - targets: ["127.0.0.1:9100"]

  - job_name: victoriametrics
    static_configs:
      - targets: ["127.0.0.1:8428"]

Paso 5: Crear el servicio systemd

Crea la unidad del servicio:

sudo nano /etc/systemd/system/victoriametrics.service

Añade este contenido:

[Unit]
Description=VictoriaMetrics single-node
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
User=victoriametrics
Group=victoriametrics
ExecStart=/usr/local/bin/victoria-metrics \
    -storageDataPath=/var/lib/victoriametrics \
    -retentionPeriod=90d \
    -httpListenAddr=127.0.0.1:8428 \
    -promscrape.config=/etc/victoriametrics/scrape.yml
Restart=on-failure
RestartSec=5
LimitNOFILE=65536
NoNewPrivileges=true
ProtectSystem=strict
ReadWritePaths=/var/lib/victoriametrics
ProtectHome=true
PrivateTmp=true

[Install]
WantedBy=multi-user.target

Los parámetros principales son:

Parámetro	Función
`-storageDataPath`	Directorio donde se guardan los datos
`-retentionPeriod`	Tiempo que se conservan los datos. Admite sufijos `d`, `w` e `y`; un número sin sufijo son meses. Por defecto es 1 mes
`-httpListenAddr`	Dirección y puerto de la API HTTP y la interfaz web
`-promscrape.config`	Archivo con los objetivos de scraping

Recarga systemd e inicia el servicio:

sudo systemctl daemon-reload
sudo systemctl enable --now victoriametrics

Comprueba que está activo y que responde al endpoint de salud:

sudo systemctl status victoriametrics
curl -s http://127.0.0.1:8428/health

OK

Paso 6: Comprobar los objetivos y consultar con PromQL

El endpoint /targets muestra el estado de cada objetivo de scraping. Espera unos 15 segundos tras el arranque y consúltalo:

curl -s http://127.0.0.1:8428/targets

job="node" (1/1 up)
	state=up, endpoint=http://127.0.0.1:9100/metrics, labels={instance="127.0.0.1:9100",job="node"}, ...
job="victoriametrics" (1/1 up)
	state=up, endpoint=http://127.0.0.1:8428/metrics, labels={instance="127.0.0.1:8428",job="victoriametrics"}, ...

La API de consultas es la misma que la de Prometheus. Consulta el porcentaje de CPU en uso durante los últimos 5 minutos:

curl -s http://127.0.0.1:8428/api/v1/query \
  --data-urlencode 'query=100 * (1 - avg(rate(node_cpu_seconds_total{mode="idle"}[5m])))'

{"status":"success","isPartial":false,"data":{"resultType":"vector","result":[{"metric":{},"value":[1758790000,"3.41"]}]},...}

Las consultas con rate() necesitan al menos dos muestras, así que puede que tengas que esperar un minuto para ver un resultado.

VictoriaMetrics incluye una interfaz web, vmui, para explorar métricas y probar consultas. Crea un túnel SSH desde tu equipo sustituyendo your_user y your_server_ip:

ssh -L 8428:127.0.0.1:8428 your_user@your_server_ip

Con el túnel abierto, visita http://localhost:8428/vmui/ en tu navegador.

Paso 7: Conectar Grafana

Grafana se conecta a VictoriaMetrics como si fuera Prometheus, así que los dashboards existentes para Prometheus funcionan sin cambios. En Grafana:

Ve a Connections > Data sources > Add data source.
Elige Prometheus.
En Prometheus server URL escribe http://127.0.0.1:8428 si Grafana está en el mismo servidor.
Pulsa Save & test.

Para probarlo, importa el dashboard Node Exporter Full (ID 1860 en grafana.com) desde Dashboards > New > Import y selecciona el origen de datos que acabas de crear.

Si Grafana está en otra máquina, cambia -httpListenAddr a la IP privada del servidor, protege el acceso con los parámetros -httpAuth.username y -httpAuth.password, y permite el puerto solo desde la IP de Grafana, por ejemplo sudo ufw allow from 10.0.0.5 to any port 8428 proto tcp.

Paso 8: Recibir datos de un Prometheus existente

Si ya tienes Prometheus en marcha, puedes mantenerlo para el scraping y usar VictoriaMetrics como almacenamiento a largo plazo. Añade esta sección al prometheus.yml del servidor Prometheus, sustituyendo your_vm_host por la dirección de VictoriaMetrics (que debe ser accesible desde ese servidor, como se explica en el paso anterior):

remote_write:
  - url: http://your_vm_host:8428/api/v1/write

Reinicia Prometheus y, pasados unos segundos, comprueba desde el servidor de VictoriaMetrics que llegan series con la etiqueta de tus trabajos de Prometheus:

curl -s http://127.0.0.1:8428/api/v1/label/job/values

{"status":"success","data":["node","prometheus","victoriametrics"]}

Paso 9: Cambiar la retención y vigilar el disco

Para cambiar el tiempo que se conservan los datos, edita el valor de -retentionPeriod en /etc/systemd/system/victoriametrics.service, por ejemplo a 1y, y aplica el cambio:

sudo systemctl daemon-reload
sudo systemctl restart victoriametrics

Los datos que queden fuera del nuevo periodo se eliminan de forma gradual en segundo plano. Para ver cuánto ocupa la base de datos:

sudo du -sh /var/lib/victoriametrics

El endpoint /api/v1/status/tsdb muestra qué métricas y etiquetas generan más series, lo que es útil para detectar etiquetas con demasiados valores distintos, la causa más habitual de crecimiento descontrolado.

Solución de problemas

El servicio no arranca. Revisa el log:

sudo journalctl -u victoriametrics -n 50 --no-pager

Un error al leer scrape.yml indica un problema de sangría o sintaxis en el YAML. Un error de permisos sobre /var/lib/victoriametrics se corrige con sudo chown -R victoriametrics:victoriametrics /var/lib/victoriametrics.

Un objetivo aparece como down en /targets. La línea del objetivo incluye el error. Comprueba desde el servidor que el exporter responde con curl http://127.0.0.1:9100/metrics y que la dirección de scrape.yml coincide con la dirección de escucha del exporter.

Prometheus no puede enviar datos. Revisa los logs de Prometheus buscando remote_write. Los errores de conexión suelen deberse a que VictoriaMetrics solo escucha en 127.0.0.1 o a que el cortafuegos bloquea el puerto 8428.

Conclusión

Tienes VictoriaMetrics funcionando como servicio en Ubuntu 24.04, recogiendo métricas del servidor con node_exporter, con 90 días de retención y listo para Grafana o como almacenamiento remoto de Prometheus. Como siguientes pasos, puedes añadir más servidores al scrape.yml, instalar vmalert para evaluar reglas de alerta en formato Prometheus, o programar copias de seguridad con vmbackup. Si el volumen de datos crece mucho, la versión cluster separa ingesta, almacenamiento y consultas en componentes escalables.

On this page