Docker-Logs zentral sammeln

Was dieser Artikel über Docker-Logging behandelt

• Warum zentrales Logging sinnvoll ist.
• Wie Docker-Logs standardmässig funktionieren.
• Wie man Logs an Loki, Fluentd oder Vector weiterleitet.
• Wie man Logs in Grafana durchsucht.
• Tipps für Parsing, Rotation und Sicherheit.

Einleitung: Docker-Logs zentral sammeln

Container erzeugen viele Logs. Standardmässig speichert Docker sie im JSON-Format lokal auf dem Host. Das ist für kleine Setups ausreichend, wird aber schnell unübersichtlich, wenn mehrere Dienste laufen, Fehler analysiert oder Vorfälle rückverfolgt werden müssen. Eine zentrale Logging-Lösung aggregiert alle Logs an einem Ort, ermöglicht Suche, Filter und Alarme.

Dieser Artikel zeigt, wie man Docker-Logs an zentrale Systeme wie Loki, Fluentd oder Vector weiterleitet und in Grafana visualisiert.

Wichtige Begriffe

• Logging Driver: Treiber, der Docker-Logs speichert oder weiterleitet.
• Log Aggregation: Zusammenführen von Logs aus vielen Quellen.
• Loki: Log-Datenbank von Grafana.
• Fluentd: Log-Collector und -Forwarder.
• Vector: Moderner Log- und Metrics-Collector.
• Grafana: Visualisierung und Suche.
• Parsing: Zerlegen von Logzeilen in Felder.
• Retention: Aufbewahrungsdauer.

Docker-Logging-Grundlagen

Standardmässig nutzt Docker den json-file-Treiber:

docker logs containername

Dies speichert Logs in JSON-Dateien im Container-Verzeichnis. Für Produktion oder grössere Setups ist oft ein externer Logging-Driver besser.

Loki mit Docker

Grafana Loki ist eine beliebte Log-Datenbank, die sich gut mit Prometheus und Grafana kombinieren lässt.

Compose-Beispiel

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:

Promtail-Konfiguration

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

Logging Driver auf Loki umstellen

Docker kann Logs direkt an Loki senden. Dafür wird der loki Logging Driver installiert:

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

Dann global aktivieren:

vim /etc/docker/daemon.json

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

Docker-Daemon neu starten:

systemctl restart docker

Fluentd als Collector

Fluentd ist ein etabliertes Tool, das Logs sammelt, filtert und weiterleitet.

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 als moderne Alternative

Vector ist schnell und einfach konfigurierbar:

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"

Logs in Grafana durchsuchen

Nach dem Hinzufügen von Loki als Datenquelle kann in Grafana mit LogQL gesucht werden:

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

Parsing und Strukturierung

Rohlogs sind oft unübersichtlich. Promtail, Fluentd und Vector können Logs parsen, um Felder wie Zeitstempel, Level oder Nachricht zu extrahieren.

Beispiel Promtail pipeline_stages:

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

Log-Rotation und Retention

• Docker json-file hat eingebaute Rotation.
• Loki braucht eine konfigurierte Retention.
• Logs sollten regelmässig archiviert oder gelöscht werden.
• Storage-Anforderungen im Auge behalten.

Sicherheit

• Logs können sensible Daten enthalten.
• Zugriff auf zentrales Logging beschränken.
• PII maskieren oder anonymisieren.
• Logs verschlüsselt ablegen.
• Audit-Logs getrennt sichern.

Typische Stolpersteine

• Fehlende Log-Rotation: Festplatte läuft voll.
• Falsche Pfade: Promtail findet keine Logs.
• Parser Fehler: JSON-Logs werden nicht korrekt interpretiert.
• Hohe Kosten: Lange Retention braucht viel Speicher.
• Zu viele Logs: Filter und Labels verbessern Übersicht.
• Keine Authentifizierung: Grafana und Loki öffentlich erreichbar.

Weiterführende Links und Infos

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

FAQ: Docker-Logs zentral sammeln

Brauche ich Loki? Nein, Elastic, Fluentd, Vector oder einfache Syslog-Weiterleitungen sind Alternativen.

Kann ich Logs ohne externen Dienst sammeln? Ja, mit lokalen Tools wie journald, rsyslog oder Datei-Tailing.

Wie viel Speicher brauchen Logs? Abhängig von Anzahl der Container, Log-Level und Retention. Einige GB pro Woche sind schnell erreicht.

Sollte ich Loki direkt als Logging-Driver verwenden? Möglich, aber ein separater Collector wie Promtail oder Vector ist flexibler.

Kann ich Logs für Ollama auswerten? Ja, Ollama erzeugt Logs wie jeder andere Docker-Container.

Quellen und weiterführende Literatur

• 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/

Zusammenfassung: Docker-Logs zentral sammeln

Zentrales Logging ist essenziell, um Docker-Container im Überblick zu behalten. Loki, Fluentd und Vector sind bewährte Werkzeuge, um Logs zu sammeln, zu parsen und in Grafana zu durchsuchen. Wichtig sind Log-Rotation, klare Labels, eine durchdachte Retention und der Schutz sensibler Daten. Wer Logs früh systematisch aufsetzt, spart Zeit bei Fehleranalysen und hat bessere Möglichkeiten, Sicherheitsvorfälle nachzuvollziehen.