---
title: "Cómo instalar Nagios Core 4.5 en Ubuntu 24.04 con NRPE"
description: "Compila Nagios Core 4.5 desde el código fuente en Ubuntu 24.04, añade los plugins de monitorización y la interfaz web, y vigila un servidor remoto con NRPE."
category: "Stack de Observabilidad"
language: es
source: https://cubepath.com/es/docs/stack-de-observabilidad/instalacion-de-nagios-core-en-linux
updated: 2026-09-25
---

# Cómo instalar Nagios Core 4.5 en Ubuntu 24.04 con NRPE

Nagios Core es un motor de monitorización de código abierto que ejecuta comprobaciones contra hosts y servicios y te avisa cuando algo cambia de estado. Todo lo que monitoriza se declara en archivos de objetos de texto plano, lo que lo hace predecible y fácil de mantener bajo control de versiones. En este tutorial compilarás Nagios Core 4.5 desde el código fuente en Ubuntu 24.04, servirás su interfaz web con Apache, añadirás los plugins de monitorización estándar y vigilarás un segundo servidor Linux mediante NRPE (Nagios Remote Plugin Executor).

## Requisitos previos

Para seguir esta guía necesitas:

- Un servidor con Ubuntu 24.04 LTS para Nagios, por ejemplo un VPS de CubePath, con al menos 1 GB de RAM.
- Un segundo servidor Linux con Ubuntu 24.04 que quieras monitorizar. En esta guía lo llamamos **host remoto** y usamos `remote_host_ip` para su dirección.
- Un usuario no root con privilegios `sudo` en ambos servidores.
- UFW activado en ambos servidores con SSH permitido.

A lo largo de la guía, sustituye `your_server_ip` por la IP pública del servidor Nagios.

## Paso 1: Instalar las dependencias de compilación

Ubuntu 24.04 no empaqueta la versión 4.5 actual de Nagios Core, así que la compilarás desde el código oficial. Instala el compilador, Apache, PHP (lo usa la interfaz web) y las bibliotecas que necesita Nagios:

```bash
sudo apt update
sudo apt install -y autoconf gcc libc6 make wget unzip apache2 php libapache2-mod-php libgd-dev openssl libssl-dev mailutils
```

El paquete `mailutils` proporciona el comando `mail` que usan las notificaciones por defecto. Instalarlo antes de compilar permite que el script `configure` lo detecte.

## Paso 2: Descargar y compilar Nagios Core

Descarga el archivo de código de la versión etiquetada en GitHub. Consulta la [página de versiones de Nagios Core](https://github.com/NagiosEnterprises/nagioscore/releases) y ajusta la versión si hay una 4.5.x más reciente:

```bash
cd /tmp
NAGIOS_VER=4.5.9
wget -O nagioscore.tar.gz "https://github.com/NagiosEnterprises/nagioscore/archive/nagios-${NAGIOS_VER}.tar.gz"
tar xzf nagioscore.tar.gz
cd "nagioscore-nagios-${NAGIOS_VER}"
```

Ejecuta el script de configuración. La opción `--with-httpd-conf` indica al instalador dónde colocar la configuración de Apache para la interfaz web:

```bash
sudo ./configure --with-httpd-conf=/etc/apache2/sites-enabled
```

El script termina con un resumen. Comprueba que ha detectado el usuario del servidor web y el programa de correo:

```output
*** Configuration summary for nagios 4.5.9 ***:
...
             Web Interface Options:
             ------------------------
                    HTML URL:  http://localhost/nagios/
                     CGI URL:  http://localhost/nagios/cgi-bin/
```

Compila los binarios:

```bash
sudo make all
```

Crea el usuario y el grupo `nagios`, y añade el usuario de Apache al grupo `nagios` para que la interfaz web pueda enviar órdenes (reconocimientos, paradas programadas) al demonio:

```bash
sudo make install-groups-users
sudo usermod -a -G nagios www-data
```

Instala los binarios, la unidad de systemd, la tubería de órdenes, la configuración de ejemplo y la configuración de Apache:

```bash
sudo make install
sudo make install-daemoninit
sudo make install-commandmode
sudo make install-config
sudo make install-webconf
```

Todo queda en `/usr/local/nagios`: los binarios en `bin/`, la configuración en `etc/` y los CGI en `sbin/`.

## Paso 3: Configurar Apache y la cuenta de administración

La interfaz web de Nagios usa scripts CGI y autenticación HTTP básica. Activa los módulos de Apache que necesita:

```bash
sudo a2enmod rewrite cgi
```

Crea la cuenta `nagiosadmin`. La configuración de ejemplo concede acceso completo exactamente a ese nombre de usuario, así que mantenlo. El comando te pedirá una contraseña; elige una robusta:

```bash
sudo htpasswd -c /usr/local/nagios/etc/htpasswd.users nagiosadmin
```

Permite HTTP en el cortafuegos y reinicia Apache:

```bash
sudo ufw allow Apache
sudo systemctl restart apache2
```

> Advertencia: La autenticación básica sobre HTTP sin cifrar envía la contraseña en claro. Antes de usarlo en producción, apunta un dominio al servidor y añade un certificado TLS, por ejemplo con Certbot y su plugin de Apache.

## Paso 4: Instalar los plugins de monitorización

Nagios Core solo planifica las comprobaciones; las comprobaciones en sí son programas independientes llamados plugins. Ubuntu empaqueta la colección de plugins mantenida como `monitoring-plugins`, y `nagios-nrpe-plugin` proporciona `check_nrpe`, que usarás en el paso 7:

```bash
sudo apt install -y monitoring-plugins
sudo apt install -y --no-install-recommends nagios-nrpe-plugin
```

Estos plugins se instalan en `/usr/lib/nagios/plugins`. Nagios se refiere al directorio de plugins mediante la macro `$USER1$`, definida en `resource.cfg`. Ábrelo:

```bash
sudo nano /usr/local/nagios/etc/resource.cfg
```

Cambia la línea de `$USER1$` para que apunte a los plugins empaquetados:

```ini
$USER1$=/usr/lib/nagios/plugins
```

Ejecuta un plugin a mano para confirmar que funciona:

```bash
/usr/lib/nagios/plugins/check_disk -w 20% -c 10% -p /
```

```output
DISK OK - free space: / 21034 MiB (78% inode=91%);| /=5812MiB;22531;25347;0;28164
```

## Paso 5: Iniciar Nagios y acceder a la interfaz

Antes de arrancar el demonio, valida la configuración. Nagios se niega a arrancar si hay errores, y este comando te dice exactamente qué archivo y qué línea fallan:

```bash
sudo /usr/local/nagios/bin/nagios -v /usr/local/nagios/etc/nagios.cfg
```

```output
Total Warnings: 0
Total Errors:   0

Things look okay - No serious problems were detected during the pre-flight check
```

Activa e inicia el servicio:

```bash
sudo systemctl enable --now nagios
sudo systemctl status nagios
```

```output
● nagios.service - Nagios Core 4.5.9
     Loaded: loaded (/usr/lib/systemd/system/nagios.service; enabled; preset: enabled)
     Active: active (running)
```

Abre `http://your_server_ip/nagios` en el navegador e inicia sesión como `nagiosadmin`. En **Current Status > Services** verás el host `localhost` con las comprobaciones de ejemplo (partición raíz, carga actual, usuarios, SSH, HTTP y otras) pasando a verde en unos minutos.

## Paso 6: Configurar NRPE en el host remoto

Plugins como `check_disk` o `check_load` tienen que ejecutarse en la máquina que miden. NRPE es un pequeño demonio que ejecuta esas comprobaciones locales en el host remoto cuando el servidor Nagios se lo pide por el puerto TCP 5666.

Ejecuta los siguientes comandos **en el host remoto**. Instala el servidor NRPE y los plugins:

```bash
sudo apt update
sudo apt install -y nagios-nrpe-server monitoring-plugins
```

NRPE solo responde a las direcciones incluidas en `allowed_hosts`. Abre su configuración:

```bash
sudo nano /etc/nagios/nrpe.cfg
```

Busca la línea `allowed_hosts` y añade la IP del servidor Nagios:

```ini
allowed_hosts=127.0.0.1,::1,your_server_ip
```

El archivo por defecto ya define `check_users`, `check_load`, `check_zombie_procs` y `check_total_procs`. Añade tus propias órdenes en un archivo aparte para que las actualizaciones del paquete no las sobrescriban:

```bash
sudo nano /etc/nagios/nrpe.d/custom.cfg
```

```ini
command[check_root_disk]=/usr/lib/nagios/plugins/check_disk -w 20% -c 10% -p /
command[check_mem_swap]=/usr/lib/nagios/plugins/check_swap -w 50% -c 20%
```

Reinicia NRPE y permite el puerto 5666 solo desde el servidor Nagios:

```bash
sudo systemctl restart nagios-nrpe-server
sudo ufw allow from your_server_ip to any port 5666 proto tcp
```

De vuelta **en el servidor Nagios**, confirma que llega al demonio y puede ejecutar una orden remota:

```bash
/usr/lib/nagios/plugins/check_nrpe -H remote_host_ip
/usr/lib/nagios/plugins/check_nrpe -H remote_host_ip -c check_root_disk
```

```output
NRPE v4.1.0
DISK OK - free space: / 36120 MiB (82% inode=95%);| /=7702MiB;35107;39495;0;43884
```

Si obtienes `CHECK_NRPE: Error - Could not connect`, consulta la sección de solución de problemas.

## Paso 7: Añadir el host remoto a Nagios

La configuración de ejemplo incluye una directiva `cfg_dir` comentada para archivos por servidor. Abre la configuración principal en el servidor Nagios:

```bash
sudo nano /usr/local/nagios/etc/nagios.cfg
```

Descomenta esta línea:

```ini
cfg_dir=/usr/local/nagios/etc/servers
```

Crea el directorio:

```bash
sudo mkdir -p /usr/local/nagios/etc/servers
```

Nagios necesita una definición de orden que llame a `check_nrpe`. Abre el archivo de órdenes:

```bash
sudo nano /usr/local/nagios/etc/objects/commands.cfg
```

Añade este bloque al final:

```text
define command {
    command_name    check_nrpe
    command_line    $USER1$/check_nrpe -H $HOSTADDRESS$ -c $ARG1$
}
```

Ahora describe el host remoto y sus servicios en su propio archivo:

```bash
sudo nano /usr/local/nagios/etc/servers/web01.cfg
```

```text
define host {
    use                     linux-server
    host_name               web01
    alias                   Servidor web 01
    address                 remote_host_ip
}

define service {
    use                     generic-service
    host_name               web01
    service_description     SSH
    check_command           check_ssh
}

define service {
    use                     generic-service
    host_name               web01
    service_description     Current Load
    check_command           check_nrpe!check_load
}

define service {
    use                     generic-service
    host_name               web01
    service_description     Root Partition
    check_command           check_nrpe!check_root_disk
}

define service {
    use                     generic-service
    host_name               web01
    service_description     Swap Usage
    check_command           check_nrpe!check_mem_swap
}
```

Las plantillas `linux-server` y `generic-service` vienen de `templates.cfg` y definen los intervalos de comprobación, los reintentos y el grupo de contactos `admins`. `check_ssh` se ejecuta desde el propio servidor Nagios, mientras que los otros tres servicios se ejecutan en el host remoto a través de NRPE.

Valida la configuración y reinicia Nagios:

```bash
sudo /usr/local/nagios/bin/nagios -v /usr/local/nagios/etc/nagios.cfg
sudo systemctl restart nagios
```

Recarga la interfaz web. El host `web01` aparece en **Hosts** y sus cuatro servicios pasan de PENDING a OK tras el primer ciclo de comprobaciones. Para acelerarlo, abre un servicio y pulsa **Re-schedule the next check of this service**.

## Paso 8: Configurar las notificaciones por correo

Las notificaciones se envían a los contactos del grupo `admins`, que por defecto solo contiene `nagiosadmin`. Asigna una dirección real a ese contacto:

```bash
sudo nano /usr/local/nagios/etc/objects/contacts.cfg
```

```text
define contact {
    contact_name            nagiosadmin
    use                     generic-contact
    alias                   Nagios Admin
    email                   you@your_domain
}
```

Las órdenes por defecto `notify-host-by-email` y `notify-service-by-email` pasan la alerta a `mail`, que la entrega al agente de transferencia de correo (MTA) local. Por tanto necesitas un MTA funcionando. Muchas plataformas cloud restringen el puerto 25 de salida, así que la opción fiable es configurar Postfix como relay a través de un proveedor SMTP autenticado en el puerto 587.

Cuando el envío de correo funcione, manda una prueba desde el servidor:

```bash
echo "Prueba de correo de Nagios" | mail -s "Prueba Nagios" you@your_domain
```

Valida y reinicia Nagios después de editar el contacto:

```bash
sudo /usr/local/nagios/bin/nagios -v /usr/local/nagios/etc/nagios.cfg
sudo systemctl restart nagios
```

Para probar todo el recorrido de una alerta, detén NRPE en el host remoto durante unos minutos (`sudo systemctl stop nagios-nrpe-server`). Tras los reintentos configurados en `generic-service`, los servicios pasan a CRITICAL y recibes un correo. Vuelve a arrancar NRPE para recibir la notificación de recuperación.

## Solución de problemas

**La interfaz web devuelve "Forbidden" o pide la contraseña en bucle.** Comprueba que existe `/usr/local/nagios/etc/htpasswd.users` y que el usuario es exactamente `nagiosadmin`, el nombre autorizado en `cgi.cfg`. Revisa `sudo tail /var/log/apache2/error.log` para ver el motivo exacto.

**"Error: Could not stat() command file".** La interfaz web no puede escribir en la tubería de órdenes. Confirma que `www-data` pertenece al grupo `nagios` con `id www-data` y reinicia Apache.

**`CHECK_NRPE: Error - Could not connect to remote_host_ip: Connection reset by peer`.** Falta la IP del servidor Nagios en `allowed_hosts` del host remoto, o no reiniciaste NRPE después de editarlo. Compruébalo con `sudo journalctl -u nagios-nrpe-server`.

**`CHECK_NRPE: Socket timeout`.** El puerto 5666 está bloqueado. Revisa `sudo ufw status` en el host remoto y cualquier cortafuegos externo entre ambos servidores.

**`NRPE: Command 'check_root_disk' not defined`.** El nombre de la orden en el servicio no coincide con el de `/etc/nagios/nrpe.d/custom.cfg`, o NRPE no se reinició.

## Conclusión

Ahora tienes Nagios Core 4.5 funcionando en Ubuntu 24.04 con los plugins de monitorización, una interfaz web protegida con contraseña y un servidor remoto monitorizado mediante NRPE. Cada servidor nuevo sigue el mismo patrón: instalar `nagios-nrpe-server`, permitir la IP de Nagios y añadir un archivo en `/usr/local/nagios/etc/servers/`.

Como siguientes pasos, protege la interfaz web con un certificado TLS, agrupa los servidores con definiciones `hostgroup` para asignar servicios a muchos hosts a la vez y ajusta `check_interval` y `max_check_attempts` en `templates.cfg` para controlar la rapidez con que saltan las alertas.