Recopilar logs de Docker de forma centralizada

Qué cubre este artículo

• Por qué el logging centralizado es importante.
• Cómo funcionan los logs de Docker de manera predeterminada.
• Cómo enviar logs a Loki, Fluentd o Vector.
• Cómo buscar logs en Grafana.
• Consejos para parsing, rotación y seguridad.

Introducción: centralizar los logs de Docker

Los contenedores generan muchos logs. De forma predeterminada, Docker los almacena en formato JSON localmente en el host. Para instalaciones pequeñas funciona, pero rápidamente se vuelve caótico cuando ejecutas varios servicios, necesitas analizar errores o rastrear incidentes. Una solución de logging centralizado agrega todos los logs en un lugar, permitiendo búsqueda, filtrado y alertas.

Este artículo muestra cómo enviar logs de Docker a sistemas centrales como Loki, Fluentd o Vector, y visualizarlos en Grafana.

Términos clave

• Logging Driver: controlador que almacena o reenvía logs de Docker.
• Log Aggregation: consolidación de logs desde múltiples fuentes.
• Loki: base de datos de logs de Grafana.
• Fluentd: recolector y reenviador de logs.
• Vector: recolector moderno de logs y métricas.
• Grafana: visualización y búsqueda.
• Parsing: descomposición de líneas de log en campos.
• Retention: período de retención.

Fundamentos de logging en Docker

Docker usa el controlador json-file por defecto:

docker logs containername

Esto almacena logs en archivos JSON dentro del directorio del contenedor. Para producción o instalaciones más grandes, frecuentemente es mejor usar un controlador de logging externo.

Loki con Docker

Grafana Loki es una base de datos de logs popular que se integra bien con Prometheus y Grafana.

Ejemplo con Compose

services:
  loki:
    image: grafana/loki:latest
    container_name: loki
    ports:
      - "3100:3100"
    volumes:
      - ./loki-config.yaml:/etc/loki/local-config.yaml
      - loki-data:/loki
    command: -config.file=/etc/loki/local-config.yaml
    restart: unless-stopped

  promtail:
    image: grafana/promtail:latest
    container_name: promtail
    volumes:
      - /var/log:/var/log:ro
      - /var/lib/docker/containers:/var/lib/docker/containers:ro
      - ./promtail-config.yaml:/etc/promtail/config.yml
    command: -config.file=/etc/promtail/config.yml
    restart: unless-stopped

volumes:
  loki-data:

Configuración de Promtail

server:
  http_listen_port: 9080
  grpc_listen_port: 0

positions:
  filename: /tmp/positions.yaml

clients:
  - url: http://loki:3100/loki/api/v1/push

scrape_configs:
  - job_name: docker
    static_configs:
      - targets:
          - localhost
        labels:
          job: docker
          __path__: /var/lib/docker/containers/*/*.log

Cambiar el logging driver a Loki

Docker puede enviar logs directamente a Loki. Para ello, instala el controlador loki:

docker plugin install grafana/loki-docker-driver:latest --alias loki --grant-all-permissions

Luego actívalo globalmente:

vim /etc/docker/daemon.json

{
  "log-driver": "loki",
  "log-opts": {
    "loki-url": "http://localhost:3100/loki/api/v1/push",
    "loki-batch-size": "400"
  }
}

Reinicia el daemon de Docker:

systemctl restart docker

Fluentd como recolector

Fluentd es una herramienta consolidada que recibe, filtra y reenvía logs.

services:
  fluentd:
    image: fluent/fluentd:v1.16-debian
    container_name: fluentd
    volumes:
      - ./fluent.conf:/fluentd/etc/fluent.conf
      - /var/lib/docker/containers:/var/lib/docker/containers:ro
    ports:
      - "24224:24224"
    restart: unless-stopped

fluent.conf:

<source>
  @type tail
  path /var/lib/docker/containers/*/*.log
  pos_file /var/log/fluent-docker.pos
  tag docker.*
  <parse>
    @type json
  </parse>
</source>

<match docker.**>
  @type loki
  url http://loki:3100
</match>

Vector como alternativa moderna

Vector es rápido y fácil de configurar:

services:
  vector:
    image: timberio/vector:0.35.X-debian
    container_name: vector
    volumes:
      - ./vector.toml:/etc/vector/vector.toml
      - /var/lib/docker/containers:/var/lib/docker/containers:ro
    restart: unless-stopped

vector.toml:

[sources.docker_logs]
type = "docker_logs"

[sinks.loki]
type = "loki"
inputs = ["docker_logs"]
endpoint = "http://loki:3100"
labels.job = "docker"

Buscar logs en Grafana

Una vez que añadas Loki como fuente de datos, puedes buscar en Grafana usando LogQL:

{job="docker"} |= "error"

Parsing y estructuración

Los logs sin procesar suelen ser desordenados. Promtail, Fluentd y Vector pueden analizar logs para extraer campos como timestamp, nivel o mensaje.

Ejemplo de pipeline_stages en Promtail:

pipeline_stages:
  - json:
      expressions:
        level: level
        message: msg
  - labels:
      level:

Rotación de logs y retención

• El driver json-file de Docker tiene rotación integrada.
• Loki requiere una retención configurada.
• Los logs deben archivarse o eliminarse regularmente.
• Ten en cuenta los requisitos de almacenamiento.

Seguridad

• Los logs pueden contener datos sensibles.
• Restringe el acceso al sistema de logging centralizado.
• Enmascara o anonimiza información de identificación personal.
• Almacena logs de forma cifrada.
• Protege los logs de auditoría por separado.

Errores comunes

• Falta de rotación de logs: el disco se llena.
• Rutas incorrectas: Promtail no encuentra los logs.
• Errores de parsing: los logs JSON no se interpretan correctamente.
• Costos elevados: la retención larga consume mucho almacenamiento.
• Demasiados logs: el filtrado y las etiquetas mejoran la legibilidad.
• Sin autenticación: Grafana y Loki accesibles públicamente.

Enlaces e información adicional

• BotServ.de Docker Monitoring
• BotServ.de Monitoring Fundamentos
• BotServ.de Docker Security
• BotServ.de Docker Backup

FAQ: recopilar logs de Docker de forma centralizada

¿Necesito Loki? No, Elastic, Fluentd, Vector o simples reenvíos syslog son alternativas.

¿Puedo recopilar logs sin un servicio externo? Sí, con herramientas locales como journald, rsyslog o tailing de archivos.

¿Cuánto almacenamiento necesitan los logs? Depende del número de contenedores, del nivel de log y de la retención. Algunos GB por semana se alcanzan rápidamente.

¿Debo usar Loki directamente como logging driver? Es posible, pero un recolector separado como Promtail o Vector es más flexible.

¿Puedo evaluar logs para Ollama? Sí, Ollama genera logs como cualquier otro contenedor Docker.

Fuentes y lecturas adicionales

• Grafana Loki: https://grafana.com/oss/loki/
• Fluentd: https://www.fluentd.org/
• Vector: https://vector.dev/
• Docker Logging: https://docs.docker.com/config/containers/logging/configure/

Resumen: centralizar logs de Docker

El logging centralizado es esencial para mantener el control de los contenedores Docker. Loki, Fluentd y Vector son herramientas probadas para recopilar, analizar y buscar logs en Grafana. La rotación de logs, etiquetas claras, una retención bien pensada y la protección de datos sensibles son fundamentales. Quien configure el logging de forma sistemática desde el principio ahorra tiempo en análisis de errores y dispone de mejores formas de rastrear incidentes de seguridad.