---
title: "Cómo instalar Netdata en Ubuntu 24.04 para monitorización"
description: "Instala Netdata en Ubuntu 24.04, accede a su panel de forma segura por túnel SSH, crea alertas propias de RAM y disco y recibe los avisos en Slack o Discord."
category: "Stack de Observabilidad"
language: es
source: https://cubepath.com/es/docs/stack-de-observabilidad/instalacion-de-netdata-para-monitoreo-en-tiempo-real
updated: 2026-09-25
---

# Cómo instalar Netdata en Ubuntu 24.04 para monitorización

Netdata es un agente de monitorización que recoge miles de métricas por segundo (CPU, memoria, disco, red, procesos, contenedores y servicios como Nginx o MySQL) sin apenas configuración y las muestra en un panel web en tiempo real. En este tutorial instalarás Netdata en Ubuntu 24.04 desde sus paquetes oficiales, restringirás el panel para que solo sea accesible por un túnel SSH, crearás alertas propias y enviarás las notificaciones a Slack o Discord.

## Requisitos previos

Para seguir esta guía necesitas:

- Un servidor con Ubuntu 24.04 LTS, por ejemplo un VPS de CubePath. Netdata usa en torno a 100-200 MB de RAM y un pequeño porcentaje de una CPU.
- Un usuario no root con privilegios `sudo`.
- Acceso SSH al servidor desde tu equipo (lo usarás para abrir el túnel al panel).
- Opcional: un webhook de Slack o Discord para las notificaciones.

## Paso 1: Instalar Netdata

Netdata mantiene un script de instalación, `kickstart.sh`, que en Ubuntu detecta la versión, añade el repositorio oficial `repo.netdata.cloud` e instala los paquetes nativos `.deb`. Es el método que recomienda el proyecto, ya que la versión incluida en los repositorios de Ubuntu queda muy atrasada.

Descarga el script en lugar de ejecutarlo directamente desde la red:

```bash
wget -O /tmp/netdata-kickstart.sh https://get.netdata.cloud/kickstart.sh
```

Revisa su contenido antes de ejecutarlo:

```bash
less /tmp/netdata-kickstart.sh
```

Ejecuta la instalación desde el canal estable. La opción `--disable-telemetry` desactiva el envío de estadísticas anónimas de uso al proyecto:

```bash
sh /tmp/netdata-kickstart.sh --stable-channel --disable-telemetry
```

El script te pedirá la contraseña de `sudo` y confirmación antes de instalar. Al terminar, Netdata queda instalado como servicio de systemd y con las actualizaciones automáticas activadas.

Comprueba el estado del servicio:

```bash
sudo systemctl status netdata
```

```output
● netdata.service - Netdata, X-Ray Vision for your infrastructure!
     Loaded: loaded (/usr/lib/systemd/system/netdata.service; enabled; preset: enabled)
     Active: active (running) since Fri 2026-09-25 10:12:03 UTC; 1min ago
```

Verifica que la API responde en el puerto 19999:

```bash
curl -s http://127.0.0.1:19999/api/v1/info | grep '"version"'
```

La salida muestra la versión instalada del agente, por ejemplo `"version": "v2.x.x"`.

## Paso 2: Restringir el panel a localhost

Por defecto Netdata escucha en todas las interfaces en el puerto `19999` y el panel no tiene autenticación. Cualquiera que llegue a ese puerto vería las métricas y la lista de procesos del servidor. La opción más sencilla y segura es que escuche solo en `127.0.0.1` y acceder a él mediante un túnel SSH.

Netdata incluye el script `edit-config`, que copia el archivo de configuración de ejemplo a `/etc/netdata` si todavía no existe y lo abre en tu editor:

```bash
cd /etc/netdata
sudo ./edit-config netdata.conf
```

Busca la sección `[web]` y deja la opción `bind to` así (descoméntala si hace falta):

```ini
[web]
    bind to = 127.0.0.1
```

Guarda el archivo y reinicia el servicio:

```bash
sudo systemctl restart netdata
```

Comprueba que ahora solo escucha en la interfaz local:

```bash
sudo ss -tlnp | grep 19999
```

```output
LISTEN 0      4096       127.0.0.1:19999      0.0.0.0:*    users:(("netdata",pid=4321,fd=7))
```

Si tienes UFW activo, no es necesario abrir el puerto `19999`.

## Paso 3: Acceder al panel por túnel SSH

Desde tu equipo local (no desde el servidor), abre un túnel que redirija el puerto `19999` local al `19999` del servidor. Sustituye `your_user` y `your_server_ip` por tus datos:

```bash
ssh -N -L 19999:127.0.0.1:19999 your_user@your_server_ip
```

Mientras el comando siga en ejecución, abre `http://localhost:19999` en el navegador. La interfaz puede ofrecerte iniciar sesión en Netdata Cloud; para un único servidor puedes continuar sin cuenta y usar el panel local.

En el panel verás, entre otras, estas secciones:

- **System Overview**: CPU, carga, memoria, swap, disco y red del sistema.
- **Applications**: consumo de recursos agrupado por aplicación (`apps.plugin`).
- **Disks** y **Networking**: I/O por dispositivo y tráfico por interfaz.
- **Systemd Services** y contenedores, si los hay.

Netdata detecta automáticamente muchos servicios locales (Nginx con `stub_status`, MySQL, PostgreSQL, Redis, Docker) y crea sus gráficas sin configuración. Los recolectores de cada servicio se ajustan con `sudo ./edit-config go.d/<servicio>.conf` desde `/etc/netdata`.

Para cerrar el túnel, pulsa `Ctrl+C` en la terminal.

## Paso 4: Revisar las alertas incluidas

Netdata trae cientos de alertas predefinidas (disco casi lleno, RAM agotada, pérdida de paquetes, reinicios de servicios, etc.). Puedes consultar las que están activas en este momento desde la API:

```bash
curl -s "http://127.0.0.1:19999/api/v1/alarms?active" | grep -E '"(name|status)"'
```

Si el servidor está sano, la lista estará vacía o solo mostrará alertas en estado `WARNING` de poca importancia. En el panel, las alertas aparecen en la pestaña **Alerts**.

Las definiciones de fábrica están en `/usr/lib/netdata/conf.d/health.d/`. No las edites ahí: si quieres modificar una, cópiala a `/etc/netdata/health.d/` con `edit-config`, por ejemplo:

```bash
cd /etc/netdata
sudo ./edit-config health.d/disks.conf
```

## Paso 5: Crear una alerta propia

Para ilustrar la sintaxis, crea una alerta que avise cuando la RAM usada supere el 80 % durante un minuto y la marque como crítica por encima del 90 %:

```bash
sudo nano /etc/netdata/health.d/custom-ram.conf
```

```text
 alarm: custom_ram_usage
    on: system.ram
lookup: average -1m percentage of used
 units: %
 every: 1m
  warn: $this > 80
  crit: $this > 90
  info: Porcentaje de RAM usada en el último minuto
    to: sysadmin
```

Cada línea tiene un propósito concreto:

- `on`: la gráfica sobre la que se evalúa la alerta (`system.ram`).
- `lookup`: calcula la media del último minuto de la dimensión `used`, expresada como porcentaje del total de dimensiones.
- `every`: cada cuánto se evalúa.
- `warn` y `crit`: umbrales de aviso y crítico. `$this` es el valor calculado por `lookup`.
- `to`: el rol de destinatarios, que se resuelve en el archivo de notificaciones del paso siguiente.

Recarga solo la configuración de alertas, sin reiniciar el agente:

```bash
sudo netdatacli reload-health
```

Comprueba que la alerta se ha cargado:

```bash
curl -s "http://127.0.0.1:19999/api/v1/alarms?all" | grep custom_ram_usage
```

```output
		"system.ram.custom_ram_usage": {
		"name":"custom_ram_usage",
```

Si no aparece, revisa los errores de sintaxis en el log del agente con `sudo journalctl -u netdata -n 50 --no-pager`.

## Paso 6: Enviar notificaciones a Slack o Discord

Las notificaciones del agente se configuran en `health_alarm_notify.conf`. Ábrelo con `edit-config`:

```bash
cd /etc/netdata
sudo ./edit-config health_alarm_notify.conf
```

El archivo es largo. Busca la sección del canal que quieras usar y rellena estas variables. Para Discord:

```bash
SEND_DISCORD="YES"
DISCORD_WEBHOOK_URL="https://discord.com/api/webhooks/your_webhook_id/your_webhook_token"
DEFAULT_RECIPIENT_DISCORD="alertas"
```

Para Slack:

```bash
SEND_SLACK="YES"
SLACK_WEBHOOK_URL="https://hooks.slack.com/services/your/webhook/url"
DEFAULT_RECIPIENT_SLACK="#alertas"
```

El destinatario es el nombre del canal que aparecerá en el mensaje; el canal real lo determina el webhook.

Envía notificaciones de prueba ejecutando el script de avisos como el usuario `netdata`:

```bash
sudo -u netdata /usr/libexec/netdata/plugins.d/alarm-notify.sh test
```

El script envía tres mensajes de prueba (WARNING, CRITICAL y CLEAR) a cada canal activo y, tras cada uno, indica `# OK` si el envío ha funcionado o el error devuelto por el servicio.

Comprueba que los mensajes han llegado al canal. Los cambios en este archivo se aplican en la siguiente alerta, sin necesidad de reiniciar el servicio.

## Paso 7: Conectar el nodo a Netdata Cloud (opcional)

Netdata Cloud permite ver varios servidores en un único panel, gestionar las alertas de forma centralizada y acceder al panel sin túnel SSH. Las métricas siguen guardándose en cada servidor; Cloud solo consulta a los agentes.

Para conectar el nodo:

1. Crea una cuenta en `app.netdata.cloud` y un Space.
2. Pulsa **Add Nodes** y elige **Linux**.
3. Copia el comando que te muestra, que incluye tu `claim-token` y la sala (`claim-rooms`), y ejecútalo en el servidor.

Tras unos segundos el nodo aparecerá como **Live** en la interfaz de Cloud. No hace falta abrir ningún puerto: el agente abre una conexión saliente cifrada hacia Netdata Cloud.

## Actualizar y desinstalar

El instalador deja configuradas las actualizaciones automáticas diarias. También puedes actualizar a mano con el resto del sistema, ya que Netdata procede de un repositorio de apt:

```bash
sudo apt update && sudo apt upgrade
```

Si en algún momento quieres eliminarlo por completo, el mismo script de instalación incluye una opción de desinstalación. Descárgalo de nuevo si ya no está en `/tmp`:

```bash
wget -O /tmp/netdata-kickstart.sh https://get.netdata.cloud/kickstart.sh
sh /tmp/netdata-kickstart.sh --uninstall
```

## Solución de problemas

**`channel 2: open failed: connect failed: Connection refused` al abrir el túnel**: Netdata no está escuchando en `127.0.0.1:19999`. Comprueba `sudo systemctl status netdata` y el valor de `bind to` en `/etc/netdata/netdata.conf`.

**Una alerta propia no aparece**: suele ser un error de sintaxis o un nombre de gráfica incorrecto en `on`. Comprueba el identificador exacto de la gráfica en el panel (el menú de cada gráfica lo muestra) y revisa `sudo journalctl -u netdata -n 50 --no-pager` tras `netdatacli reload-health`.

**No llegan las notificaciones**: ejecuta de nuevo la prueba del paso 6 y lee el error que devuelve el script. Las causas más habituales son un webhook mal copiado o que `SEND_DISCORD` / `SEND_SLACK` no estén en `"YES"`.

**Uso de disco creciente en `/var/cache/netdata`**: es la base de datos de métricas (dbengine), que tiene un tamaño máximo y rota los datos antiguos por sí sola. Es normal que crezca hasta ese límite y se estabilice.

## Conclusión

Has instalado Netdata en Ubuntu 24.04 desde sus paquetes oficiales, has limitado el panel a localhost con acceso por túnel SSH, has creado una alerta propia y has conectado las notificaciones a Slack o Discord. Con esto tienes visibilidad por segundo de lo que ocurre en el servidor y avisos cuando algo se sale de lo normal.

Como siguientes pasos puedes:

- Activar el módulo `stub_status` de Nginx o crear un usuario de solo lectura en tu base de datos para que Netdata recoja sus métricas.
- Instalar Netdata en el resto de servidores y conectarlos a un mismo Space de Netdata Cloud.
- Añadir Uptime Kuma para vigilar la disponibilidad de tus servicios desde fuera del servidor.