---
title: "Cómo instalar Fluent Bit en Ubuntu 24.04 para enviar logs"
description: "Instala Fluent Bit en Ubuntu 24.04 desde su repositorio oficial, configúralo en YAML para analizar los logs de Nginx y journald y envíalos a Grafana Loki."
category: "Ingeniería de Datos"
language: es
source: https://cubepath.com/es/docs/ingeniería-de-datos/fluent-bit-procesador-de-logs-ligero
updated: 2026-09-25
---

# Cómo instalar Fluent Bit en Ubuntu 24.04 para enviar logs

Fluent Bit es un procesador y reenviador de logs escrito en C, pensado para ejecutarse en cada servidor o nodo con un consumo mínimo de memoria y CPU. Lee logs de archivos, journald o la red, los analiza y filtra, y los envía a destinos como Grafana Loki, Elasticsearch o S3. En este tutorial instalarás Fluent Bit en Ubuntu 24.04 desde su repositorio oficial, lo configurarás con el formato YAML para leer los logs de Nginx y de journald, descartarás el ruido y enviarás el resultado a Loki.

## Requisitos previos

Para seguir esta guía necesitas:

- Un servidor con Ubuntu 24.04 LTS, por ejemplo un VPS de CubePath.
- Un usuario no root con privilegios `sudo`.
- Nginx instalado y sirviendo tráfico, que se usa como fuente de logs del ejemplo. Si no lo tienes, instálalo con `sudo apt install nginx`.
- Opcional para el paso 6: un servidor Grafana Loki accesible desde este servidor. Hasta ese paso, los eventos se envían a la salida estándar.

## Paso 1: Añadir el repositorio de Fluent Bit

Los paquetes de Ubuntu no incluyen versiones recientes de Fluent Bit, así que usarás el repositorio oficial del proyecto. Descarga su clave de firma en formato binario a `/etc/apt/keyrings`:

```bash
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://packages.fluentbit.io/fluentbit.key | sudo gpg --dearmor -o /etc/apt/keyrings/fluentbit.gpg
```

Añade el repositorio para Ubuntu 24.04 (noble), limitado a esa clave:

```bash
echo "deb [signed-by=/etc/apt/keyrings/fluentbit.gpg] https://packages.fluentbit.io/ubuntu/noble noble main" | sudo tee /etc/apt/sources.list.d/fluent-bit.list
```

Instala el paquete:

```bash
sudo apt update
sudo apt install -y fluent-bit
```

El binario se instala en `/opt/fluent-bit/bin/fluent-bit`, fuera del `PATH`. Comprueba la versión:

```bash
/opt/fluent-bit/bin/fluent-bit --version
```

```output
Fluent Bit v5.1.2
```

## Paso 2: Pasar el servicio al formato YAML

El paquete instala la unidad `fluent-bit.service`, que arranca con `/etc/fluent-bit/fluent-bit.conf` en el formato clásico. Ese formato quedará obsoleto a finales de 2026, y YAML admite todo lo que admite el clásico y más, así que usarás un archivo `fluent-bit.yaml`. Fluent Bit elige el formato por la extensión del archivo.

Crea un override de systemd que cambie el archivo de configuración sin modificar la unidad del paquete:

```bash
sudo systemctl edit fluent-bit
```

En el editor, escribe lo siguiente entre las líneas de comentario que indican dónde hacerlo. La línea `ExecStart=` vacía es necesaria para anular el comando original antes de definir el nuevo:

```ini
[Service]
ExecStart=
ExecStart=/opt/fluent-bit/bin/fluent-bit -c /etc/fluent-bit/fluent-bit.yaml
```

Guarda y cierra. Crea también el directorio donde Fluent Bit guardará la posición de lectura de cada fuente:

```bash
sudo mkdir -p /var/lib/fluent-bit
```

La unidad no define `User=`, así que Fluent Bit se ejecuta como root y puede leer cualquier log del sistema sin cambiar permisos.

## Paso 3: Leer y analizar los logs de Nginx

Una configuración YAML de Fluent Bit tiene tres secciones principales: `service` (opciones globales), `parsers` (cómo convertir texto en campos) y `pipeline`, con sus `inputs`, `filters` y `outputs`. Cada evento lleva una etiqueta (`tag`) que asigna la entrada, y filtros y salidas deciden con `match` a qué etiquetas se aplican.

Crea el archivo:

```bash
sudo nano /etc/fluent-bit/fluent-bit.yaml
```

```yaml
service:
  flush: 1
  log_level: info
  http_server: on
  http_listen: 127.0.0.1
  http_port: 2020

parsers:
  - name: nginx_combined
    format: regex
    regex: '^(?<remote>[^ ]*) - (?<user>[^ ]*) \[(?<time>[^\]]*)\] "(?<method>\S+)(?: +(?<path>[^\"]*?)(?: +\S*)?)?" (?<code>[^ ]*) (?<size>[^ ]*)(?: "(?<referer>[^\"]*)" "(?<agent>[^\"]*)")?$'
    time_key: time
    time_format: '%d/%b/%Y:%H:%M:%S %z'
    types: code:integer size:integer

pipeline:
  inputs:
    - name: tail
      tag: nginx.access
      path: /var/log/nginx/access.log
      parser: nginx_combined
      db: /var/lib/fluent-bit/nginx-access.db
      mem_buf_limit: 10MB
      skip_long_lines: on

  outputs:
    - name: stdout
      match: '*'
      format: json_lines
```

Qué hace cada parte:

- `http_server` activa el servidor de monitorización de Fluent Bit en `127.0.0.1:2020`, solo accesible localmente.
- El parser `nginx_combined` separa el formato de log por defecto de Nginx en campos, usa la hora de la petición como marca de tiempo del evento y convierte `code` y `size` en números.
- La entrada `tail` sigue `access.log`. El archivo `db` guarda la posición de lectura, para que tras un reinicio no se repitan ni se pierdan líneas, y `mem_buf_limit` pausa la lectura si el destino no da abasto en lugar de consumir memoria sin límite.
- La salida `stdout` imprime los eventos, que systemd guarda en el journal. Sirve para comprobar el resultado antes de configurar un destino real.

Valida la configuración con `--dry-run`, que la carga y comprueba sin arrancar el pipeline:

```bash
sudo /opt/fluent-bit/bin/fluent-bit -c /etc/fluent-bit/fluent-bit.yaml --dry-run
```

```output
configuration test is successful
```

Reinicia el servicio para aplicar el override y la nueva configuración:

```bash
sudo systemctl restart fluent-bit
sudo systemctl status fluent-bit --no-pager
```

```output
● fluent-bit.service - Fluent Bit
     Loaded: loaded (/usr/lib/systemd/system/fluent-bit.service; enabled; preset: enabled)
    Drop-In: /etc/systemd/system/fluent-bit.service.d
             └─override.conf
     Active: active (running) since ...
   Main PID: 4121 (fluent-bit)
      CGroup: /system.slice/fluent-bit.service
             └─4121 /opt/fluent-bit/bin/fluent-bit -c /etc/fluent-bit/fluent-bit.yaml
```

La línea `CGroup` confirma que el servicio usa el archivo YAML.

## Paso 4: Comprobar los eventos

Genera un par de peticiones a Nginx:

```bash
curl -s -o /dev/null http://localhost/
curl -s -o /dev/null http://localhost/no-existe
```

Consulta los últimos eventos en el journal:

```bash
sudo journalctl -u fluent-bit -n 2 --no-pager -o cat
```

```output
{"date":1790331123.0,"remote":"127.0.0.1","user":"-","method":"GET","path":"/","code":200,"size":615,"referer":"-","agent":"curl/8.5.0"}
{"date":1790331124.0,"remote":"127.0.0.1","user":"-","method":"GET","path":"/no-existe","code":404,"size":162,"referer":"-","agent":"curl/8.5.0"}
```

Cada línea de texto se ha convertido en un registro con campos. Si en lugar de eso ves un único campo `log` con la línea completa, el parser no ha encajado: revisa que Nginx usa el formato `combined`.

También puedes consultar las métricas internas de Fluent Bit en el servidor HTTP local:

```bash
curl -s http://127.0.0.1:2020/api/v1/metrics | python3 -m json.tool
```

La salida muestra, por cada entrada y salida, los registros y bytes procesados, los reintentos y los errores.

## Paso 5: Filtrar el ruido y añadir journald

Añade la sección `filters` dentro de `pipeline` para descartar health checks y peticiones de `favicon.ico`, y una segunda entrada que lea los logs de los servicios de systemd desde journald. Edita el archivo:

```bash
sudo nano /etc/fluent-bit/fluent-bit.yaml
```

Sustituye la sección `pipeline` completa por esta:

```yaml
pipeline:
  inputs:
    - name: tail
      tag: nginx.access
      path: /var/log/nginx/access.log
      parser: nginx_combined
      db: /var/lib/fluent-bit/nginx-access.db
      mem_buf_limit: 10MB
      skip_long_lines: on

    - name: systemd
      tag: journal.*
      read_from_tail: on
      strip_underscores: on
      db: /var/lib/fluent-bit/journal.db

  filters:
    - name: grep
      match: nginx.access
      exclude: path ^/(health|healthz|favicon\.ico)$

  outputs:
    - name: stdout
      match: '*'
      format: json_lines
```

Detalles de estos cambios:

- El filtro `grep` elimina los registros cuyo campo `path` coincide con la expresión regular. Con `regex` en lugar de `exclude` harías lo contrario: conservar solo los que coinciden.
- La entrada `systemd` lee el journal. Con `tag: journal.*`, Fluent Bit sustituye el asterisco por el nombre de la unidad (por ejemplo `journal.ssh.service`), lo que permite enrutar por servicio. `read_from_tail` evita reenviar todo el historial en el primer arranque, y `strip_underscores` convierte campos como `_SYSTEMD_UNIT` en `SYSTEMD_UNIT`.

Valida y reinicia:

```bash
sudo /opt/fluent-bit/bin/fluent-bit -c /etc/fluent-bit/fluent-bit.yaml --dry-run
sudo systemctl restart fluent-bit
```

Para comprobar el filtro, haz una petición a `http://localhost/health` y otra a `http://localhost/`: en el journal de `fluent-bit` solo debe aparecer la segunda. Para ver la entrada de journald, reinicia cualquier servicio (por ejemplo `sudo systemctl restart cron`) y verás sus mensajes con el campo `SYSTEMD_UNIT`.

## Paso 6: Enviar los logs a Grafana Loki

Con los eventos correctos, sustituye la salida `stdout` por Loki. Cambia `your_loki_host` por la dirección de tu servidor Loki y `your_hostname` por el nombre de este servidor:

```yaml
  outputs:
    - name: loki
      match: 'nginx.*'
      host: your_loki_host
      port: 3100
      labels: job=nginx, host=your_hostname
      line_format: json

    - name: loki
      match: 'journal.*'
      host: your_loki_host
      port: 3100
      labels: job=journal, host=your_hostname
      label_keys: $SYSTEMD_UNIT
      line_format: json
```

`labels` fija etiquetas constantes y `label_keys` convierte un campo del registro en etiqueta, aquí la unidad de systemd. Usa como etiquetas solo campos con pocos valores distintos: `path` o `remote` tienen miles y degradan el rendimiento de Loki, así que se quedan dentro de la línea JSON.

Comprueba que Loki responde desde este servidor antes de aplicar el cambio:

```bash
curl http://your_loki_host:3100/ready
```

```output
ready
```

Valida, reinicia y revisa que no haya errores de envío:

```bash
sudo /opt/fluent-bit/bin/fluent-bit -c /etc/fluent-bit/fluent-bit.yaml --dry-run
sudo systemctl restart fluent-bit
sudo journalctl -u fluent-bit -n 20 --no-pager
```

En Grafana, las consultas `{job="nginx"}` y `{job="journal", SYSTEMD_UNIT="ssh.service"}` deberían devolver datos en unos segundos.

> Consejo: si Loki está en otra red, envía los logs por la red privada o pon Loki tras un proxy con TLS y autenticación. La salida `loki` admite `tls: on`, `http_user` y `http_passwd` para ese caso.

## Solución de problemas

**El servicio sigue usando `fluent-bit.conf`.** Comprueba el override con `systemctl cat fluent-bit`. Deben aparecer las dos líneas `ExecStart` del paso 2; si no, repite `sudo systemctl edit fluent-bit` y reinicia.

**Los registros llegan con un único campo `log`.** El parser no coincide con el formato de las líneas. Compara una línea real de `/var/log/nginx/access.log` con la expresión regular; si has cambiado `log_format` en Nginx, adapta el parser.

**Las líneas se repiten o se pierden tras un reinicio.** Falta la opción `db` en la entrada o `/var/lib/fluent-bit` no existe. Sin ese archivo, `tail` no recuerda por dónde iba.

**Errores `failed to flush chunk` o `no upstream connections available`.** Fluent Bit no puede conectar con el destino. Revisa la dirección y el puerto, el firewall entre los dos servidores y la respuesta de `curl http://your_loki_host:3100/ready`. Fluent Bit reintenta los envíos fallidos automáticamente.

## Conclusión

Tienes Fluent Bit en Ubuntu 24.04 configurado en YAML, leyendo los logs de acceso de Nginx y de journald, convirtiéndolos en registros estructurados, filtrando el ruido y enviándolos a Grafana Loki. Como siguientes pasos puedes activar el almacenamiento en disco (`storage.path` en `service` y `storage.type: filesystem` en las entradas) para no perder datos durante cortes largos, añadir más archivos de log con comodines en `path` o desplegar Fluent Bit como DaemonSet en Kubernetes con el chart de Helm oficial.