---
title: "Cómo instalar VictoriaMetrics en Ubuntu 24.04"
description: "Instala VictoriaMetrics single-node en Ubuntu 24.04 con systemd, recoge métricas de node_exporter, consúltalas con PromQL y conéctalo a Grafana o Prometheus."
category: "Observabilidad Avanzada"
language: es
source: https://cubepath.com/es/docs/observabilidad-avanzada/instalacion-y-configuracion-de-victoriametrics
updated: 2026-09-25
---

# 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](https://github.com/VictoriaMetrics/VictoriaMetrics/releases) y ajusta la variable si hay una más reciente) junto con su archivo de sumas de comprobación:

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

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

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

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

```bash
victoria-metrics -version
```

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

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

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

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

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

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

Reinicia el servicio y comprueba que expone métricas:

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

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

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

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

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

Añade este contenido:

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

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

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

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

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

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

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

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

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

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

1. Ve a **Connections > Data sources > Add data source**.
2. Elige **Prometheus**.
3. En **Prometheus server URL** escribe `http://127.0.0.1:8428` si Grafana está en el mismo servidor.
4. 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):

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

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

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

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

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

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