---
title: "Cómo instalar Graylog en Ubuntu 24.04 con Data Node"
description: "Instala Graylog en Ubuntu 24.04 con MongoDB y Data Node, recibe logs por syslog y GELF, enriquécelos con pipelines y crea alertas por correo."
category: "Gestión de Logs"
language: es
source: https://cubepath.com/es/docs/gestión-de-logs/instalacion-y-configuracion-de-graylog
updated: 2026-09-25
---

# Cómo instalar Graylog en Ubuntu 24.04 con Data Node

Graylog es una plataforma de gestión centralizada de logs: recibe registros de servidores y aplicaciones, los indexa y permite buscarlos, filtrarlos y generar alertas desde una interfaz web. En este tutorial instalarás Graylog en un único servidor Ubuntu 24.04 con MongoDB para la configuración y Graylog Data Node, la opción recomendada por Graylog para gestionar el almacenamiento de búsqueda basado en OpenSearch. Al terminar recibirás logs por syslog y GELF, los enriquecerás con una regla de pipeline y tendrás una alerta por correo.

## Requisitos previos

- Un servidor con Ubuntu 24.04 LTS, por ejemplo un VPS de CubePath, con al menos 4 vCPU, 8 GB de RAM y 50 GB de disco SSD. Data Node y Graylog Server usan Java y reservan varios GB de memoria cada uno.
- Un usuario no root con privilegios `sudo`.
- UFW activo, con SSH permitido.
- Uno o más servidores Linux con `rsyslog` desde los que enviar logs.
- Opcional: una cuenta SMTP para las alertas por correo.

En esta guía se usa Graylog 6.1 con MongoDB 7.0. Si hay una versión más reciente de Graylog, cambia el número de versión en el paso 3 después de comprobar en su documentación qué versiones de MongoDB admite.

## Paso 1: Preparar el sistema

Graylog usa marcas de tiempo en todos los mensajes, así que el reloj del servidor debe estar sincronizado. Ubuntu 24.04 lo hace con `systemd-timesyncd`; compruébalo:

```bash
timedatectl
```

```output
               Local time: Fri 2026-09-25 10:15:02 UTC
...
System clock synchronized: yes
              NTP service: active
```

Instala las herramientas que usarás durante la guía:

```bash
sudo apt update
sudo apt install -y curl gnupg pwgen
```

OpenSearch, que Data Node ejecuta internamente, necesita un valor alto de `vm.max_map_count`. Configúralo de forma persistente:

```bash
echo 'vm.max_map_count = 262144' | sudo tee /etc/sysctl.d/99-graylog-datanode.conf
sudo sysctl --system
```

Comprueba el valor:

```bash
sysctl vm.max_map_count
```

```output
vm.max_map_count = 262144
```

## Paso 2: Instalar MongoDB

Graylog guarda en MongoDB su configuración: usuarios, inputs, streams, dashboards y alertas. Añade el repositorio oficial de MongoDB 7.0 con su clave:

```bash
curl -fsSL https://www.mongodb.org/static/pgp/server-7.0.asc | sudo gpg --dearmor -o /etc/apt/keyrings/mongodb-server-7.0.gpg
echo "deb [ arch=amd64,arm64 signed-by=/etc/apt/keyrings/mongodb-server-7.0.gpg ] https://repo.mongodb.org/apt/ubuntu noble/mongodb-org/7.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-7.0.list
```

Instala MongoDB y bloquea el paquete para que una actualización del sistema no lo cambie de versión mayor sin que lo decidas tú:

```bash
sudo apt update
sudo apt install -y mongodb-org
sudo apt-mark hold mongodb-org
```

Arranca el servicio y comprueba que responde:

```bash
sudo systemctl enable --now mongod
mongosh --quiet --eval "db.adminCommand('ping')"
```

```output
{ ok: 1 }
```

MongoDB escucha solo en `127.0.0.1` por defecto, que es lo que necesitas cuando todo está en el mismo servidor.

## Paso 3: Instalar Graylog Server y Data Node

Graylog distribuye un paquete que configura su repositorio APT. Descárgalo e instálalo:

```bash
curl -fLO https://packages.graylog2.org/repo/packages/graylog-6.1-repository_latest.deb
sudo dpkg -i graylog-6.1-repository_latest.deb
sudo apt update
```

Instala el servidor y el Data Node:

```bash
sudo apt install -y graylog-datanode graylog-server
```

Ambos servicios deben compartir el mismo `password_secret`, una clave que Graylog usa para cifrar datos sensibles. Genera una de 96 caracteres y guárdala en una variable de la sesión:

```bash
SECRET=$(pwgen -N 1 -s 96)
```

## Paso 4: Configurar y arrancar Data Node

Escribe el secreto en la configuración de Data Node:

```bash
sudo sed -i "s|^password_secret =.*|password_secret = ${SECRET}|" /etc/graylog/datanode/datanode.conf
```

Abre el fichero para revisar la memoria de OpenSearch:

```bash
sudo nano /etc/graylog/datanode/datanode.conf
```

Comprueba o añade estas líneas. Con 8 GB de RAM, 2 GB de heap para OpenSearch es un punto de partida razonable:

```ini
mongodb_uri = mongodb://localhost/graylog
opensearch_heap = 2g
```

Arranca Data Node:

```bash
sudo systemctl enable --now graylog-datanode
sudo systemctl status graylog-datanode --no-pager
```

```output
● graylog-datanode.service - Graylog data node
     Loaded: loaded (/usr/lib/systemd/system/graylog-datanode.service; enabled; preset: enabled)
     Active: active (running) since ...
```

Data Node queda a la espera: no arranca OpenSearch hasta que Graylog Server le proporcione certificados en el paso 6.

## Paso 5: Configurar Graylog Server

Escribe el mismo secreto en la configuración del servidor:

```bash
sudo sed -i "s|^password_secret =.*|password_secret = ${SECRET}|" /etc/graylog/server/server.conf
```

Graylog guarda la contraseña del usuario `admin` como hash SHA-256. Este comando te la pide sin mostrarla en pantalla ni guardarla en el historial:

```bash
read -rsp "Contraseña de admin: " PW; echo
HASH=$(printf '%s' "$PW" | sha256sum | cut -d' ' -f1); unset PW
sudo sed -i "s|^root_password_sha2 =.*|root_password_sha2 = ${HASH}|" /etc/graylog/server/server.conf
```

Abre ahora el fichero de configuración:

```bash
sudo nano /etc/graylog/server/server.conf
```

Localiza y ajusta estas opciones. `http_bind_address` hace que la interfaz web escuche en todas las interfaces, y `root_timezone` define la zona horaria del usuario `admin`:

```ini
http_bind_address = 0.0.0.0:9000
root_timezone = Europe/Madrid
```

Deja comentada la línea `elasticsearch_hosts`: si está vacía, Graylog usa el Data Node.

Si quieres enviar alertas por correo, añade al final del fichero los datos de tu servidor SMTP, sustituyendo los valores de ejemplo:

```ini
transport_email_enabled = true
transport_email_hostname = smtp.your_domain
transport_email_port = 587
transport_email_use_auth = true
transport_email_auth_username = graylog@your_domain
transport_email_auth_password = your_smtp_password
transport_email_use_tls = true
transport_email_use_ssl = false
transport_email_from_email = graylog@your_domain
transport_email_web_interface_url = http://your_server_ip:9000
```

Ajusta la memoria de Graylog Server. El paquete la fija en 1 GB; súbela a 2 GB:

```bash
sudo sed -i 's/-Xms1g/-Xms2g/; s/-Xmx1g/-Xmx2g/' /etc/default/graylog-server
grep JAVA_OPTS /etc/default/graylog-server
```

```output
GRAYLOG_SERVER_JAVA_OPTS="-Xms2g -Xmx2g -server -XX:+UseG1GC -XX:-OmitStackTraceInFastThrow"
```

Arranca el servidor:

```bash
sudo systemctl enable --now graylog-server
```

## Paso 6: Completar la configuración inicial

En el primer arranque Graylog abre una interfaz de configuración previa (preflight) con una contraseña temporal que escribe en su log. Busca la línea:

```bash
sudo grep "Initial configuration is accessible" /var/log/graylog-server/server.log
```

```output
Initial configuration is accessible at 0.0.0.0:9000, with username 'admin' and password 'aBcDeFgHiJ'.
```

Permite el acceso a la interfaz web solo desde tu IP, sustituyendo `your_admin_ip`:

```bash
sudo ufw allow from your_admin_ip to any port 9000 proto tcp
```

Abre `http://your_server_ip:9000` en el navegador y entra con el usuario `admin` y la contraseña temporal. El asistente te guía por tres acciones:

1. **Create CA**: crea una autoridad de certificación propia con **Create CA**.
2. **Renewal policy**: acepta la política de renovación automática de certificados que propone.
3. **Provision certificates**: comprueba que tu Data Node aparece en la lista y pulsa **Provision certificate and continue**. Cuando el Data Node figure como conectado, pulsa **Resume startup**.

Graylog termina de arrancar y muestra la pantalla de login normal. Entra con `admin` y la contraseña que definiste en el paso 5.

Verifica el estado del clúster en **System > Overview**: no debe haber avisos sobre el almacenamiento de índices, y en **System > Data Nodes** el nodo debe aparecer como `AVAILABLE`.

## Paso 7: Crear los inputs de syslog y GELF

Un input es un puerto en el que Graylog escucha mensajes. Graylog se ejecuta con un usuario sin privilegios, así que no puede usar el puerto 514; usa 1514.

En **System > Inputs**, selecciona **Syslog UDP** en el desplegable y pulsa **Launch new input**. Rellena:

- **Global**: activado.
- **Title**: `Syslog UDP`.
- **Bind address**: `0.0.0.0`.
- **Port**: `1514`.

Guarda y repite el proceso con el tipo **GELF UDP**, título `GELF UDP` y puerto `12201`. GELF es el formato JSON de Graylog y lo admiten directamente librerías de logging de muchos lenguajes y el driver de logs de Docker.

Comprueba que los dos puertos están escuchando:

```bash
sudo ss -ulnp | grep -E ':(1514|12201)'
```

```output
UNCONN 0  0  *:1514   *:*  users:(("java",pid=4321,fd=210))
UNCONN 0  0  *:12201  *:*  users:(("java",pid=4321,fd=215))
```

Abre los puertos para la red desde la que enviarán logs tus servidores, por ejemplo tu red privada `10.0.0.0/24`:

```bash
sudo ufw allow from 10.0.0.0/24 to any port 1514 proto udp
sudo ufw allow from 10.0.0.0/24 to any port 12201 proto udp
```

Envía un mensaje GELF de prueba desde el propio servidor:

```bash
echo -n '{"version":"1.1","host":"prueba","short_message":"Mensaje GELF de prueba","level":6}' | nc -u -w1 127.0.0.1 12201
```

En **Search**, con el rango de tiempo en los últimos 5 minutos, debe aparecer `Mensaje GELF de prueba` con `source: prueba`.

## Paso 8: Enviar logs desde otros servidores con rsyslog

En cada servidor que quieras centralizar, crea un fichero de reenvío para `rsyslog`:

```bash
sudo nano /etc/rsyslog.d/60-graylog.conf
```

Añade esta línea, sustituyendo `graylog_server_ip` por la IP del servidor Graylog. La `@` indica UDP y la plantilla `RSYSLOG_SyslogProtocol23Format` envía los mensajes en formato RFC 5424, que Graylog interpreta mejor que el formato clásico:

```text
*.* @graylog_server_ip:1514;RSYSLOG_SyslogProtocol23Format
```

Comprueba la sintaxis y reinicia `rsyslog`:

```bash
sudo rsyslogd -N1
sudo systemctl restart rsyslog
```

Genera un mensaje de prueba en el cliente:

```bash
logger -t prueba-graylog "Hola desde $(hostname)"
```

En Graylog, busca `application_name:prueba-graylog`. El mensaje debe aparecer con el nombre del servidor cliente en `source`.

## Paso 9: Enriquecer mensajes con una regla de pipeline

Las pipelines procesan cada mensaje después de recibirlo: pueden añadir campos, renombrarlos o descartar mensajes. Vas a marcar los intentos de login SSH fallidos para poder buscarlos y alertar sobre ellos.

En **System > Pipelines**, abre **Manage rules**, pulsa **Create Rule** y usa el editor de código con esta regla:

```text
rule "marcar logins ssh fallidos"
when
  has_field("application_name") &&
  to_string($message.application_name) == "sshd" &&
  contains(to_string($message.message), "Failed password")
then
  set_field("event_type", "ssh_failed_login");
end
```

Después, en **Manage pipelines**, pulsa **Add new pipeline**, llámala `Seguridad`, conéctala al stream **Default Stream** con **Edit connections** y añade la regla en la etapa 0.

Para probarla, intenta entrar por SSH con una contraseña incorrecta en uno de los servidores cliente y busca en Graylog:

```text
event_type:ssh_failed_login
```

Si prefieres separar estos mensajes, crea en **Streams** un stream `Seguridad SSH` con una regla sobre el campo `event_type` de tipo **match exactly** y valor `ssh_failed_login`. Así podrás darle permisos o retención distintos.

## Paso 10: Crear una alerta

Las alertas de Graylog son **event definitions** que ejecutan una búsqueda periódicamente. En **Alerts > Event Definitions**, pulsa **Create event definition**:

1. **Details**: título `Fuerza bruta SSH` y prioridad alta.
2. **Condition**: tipo **Filter & Aggregation**, consulta `event_type:ssh_failed_login`, búsqueda en los últimos 5 minutos y ejecución cada minuto. Elige **Aggregation of results reaches a threshold** con la función `count()`, condición `>` y umbral `10`.
3. **Notifications**: pulsa **Add notification**, crea una de tipo **Email Notification** con tu dirección como destinatario y usa **Execute Test Notification** para comprobar que el correo llega.

Guarda la definición. Cuando haya más de 10 intentos fallidos en 5 minutos, Graylog creará un evento visible en **Alerts** y enviará el correo.

## Paso 11: Controlar la retención

Por defecto Graylog conserva los índices según la política del **Default index set**. Revísala en **System > Indices**, edita el index set y ajusta cuántos días o índices se conservan según el espacio de tu disco. Vigila el uso de disco del Data Node:

```bash
df -h /var/lib/graylog-datanode
```

## Solución de problemas

**Graylog no arranca o la web no responde.** Revisa el log del servidor, donde suelen aparecer errores de conexión con MongoDB o de memoria:

```bash
sudo tail -n 100 /var/log/graylog-server/server.log
sudo journalctl -u graylog-datanode -n 50 --no-pager
```

**No hay línea `Initial configuration is accessible` en el log.** La configuración previa solo aparece en el primer arranque. Si ya la completaste, entra directamente con `admin` y tu contraseña.

**Los mensajes de rsyslog no llegan.** Comprueba en **System > Inputs** que el input está en estado `RUNNING` y que su contador de mensajes aumenta. Si no aumenta, revisa la regla de UFW para UDP 1514 y ejecuta `sudo tcpdump -ni any udp port 1514` en el servidor Graylog mientras envías un `logger` desde el cliente.

**Los mensajes aparecen con la hora equivocada.** El reloj de algún cliente no está sincronizado o su zona horaria es incorrecta. Revisa `timedatectl` en ese servidor.

## Conclusión

Tienes Graylog funcionando en Ubuntu 24.04 con MongoDB y Data Node, recibiendo logs por syslog y GELF, enriqueciéndolos con una regla de pipeline y avisándote por correo ante ataques de fuerza bruta SSH. Como siguientes pasos, publica la interfaz web detrás de Nginx con HTTPS, envía los logs de tus aplicaciones en formato GELF y crea dashboards en **Dashboards** a partir de tus búsquedas más habituales.