Anleitungen

Log-Management für Home Server: Logs aus journald, rsyslog und Loki sammeln

Log-Management für Home Server: Logs aus journald, rsyslog und Loki sammeln

Manchmal fällt ein Dienst auf dem Home Server plötzlich aus, und ich weiß nicht, wo ich mit der Suche beginnen soll. Ich öffne das Terminal, tippe systemctl status und erinnere mich dann daran, dass das Log vielleicht in /var/log, in journalctl oder in einem bereits gelöschten Docker-Container liegt. Es fühlt sich an, als suche man nachts mit einer schwachen Taschenlampe nach dem Haustürschlüssel.

Hier kommt Log-Management ins Spiel. Es bedeutet nicht nur, Fehler aufzubewahren, sondern sie in einem System zu ordnen, das sich lesen, durchsuchen und im Problemfall zuverlässig nutzen lässt. Dieser Artikel beschreibt meinen Weg mit Logs auf dem Home Server: vom einfachen journald über rsyslog bis zu Loki und Grafana.

Warum Logs wichtiger sind, als sie wirken

Logs sind die digitale Spur jeder Entscheidung eines Systems. Eine Anwendung sagt: "Ich habe diese Anfrage erhalten", der Kernel meldet ungewöhnliche Hardware, und die Firewall notiert ein abgelehntes Paket. Ohne Logs sehen wir nur das Endsymptom: einen ausgefallenen Dienst, einen 500-Fehler oder eine langsame Verbindung. Mit Logs können wir die Ursache-Wirkungs-Kette bis zur Wurzel verfolgen.

Ich vergleiche Logs gern mit Krankenakten. Ein Arzt kann einen Husten nicht allein durch Anschauen diagnostizieren; er braucht Vorgeschichte, Untersuchungen und Entwicklungen über die Zeit. Logs liefern diese Geschichte für unsere Systeme. Je ordentlicher sie sind, desto schneller finden wir den Fehler.

Auf einem Home Server mit vielen Diensten können Logs überall verteilt sein: Textdateien in /var/log, systemd-Ausgaben in journald, Anwendungslogs in Containern oder Ausgaben eigener Skripte. Ohne Strategie kann die Suche nach einem einzigen Vorfall Stunden dauern.

journald: Das erste Log von systemd

Auf modernen Linux-Distributionen wie Debian, Ubuntu oder Fedora verwaltet systemd bereits viele Prozesse. Jede von systemd gestartete Unit—Service, Timer oder Socket—schreibt ihre Standardausgabe nach journald. Das ist das erste zentrale Log, das fast immer verfügbar ist.

Diese Befehle nutze ich am häufigsten:

# Lihat log suatu service secara real-time
journalctl -u nginx.service -f

# Lihat log dari boot terakhir
journalctl -b

# Lihat log dalam rentang waktu tertentu
journalctl --since "1 hour ago"

# Cari log yang mengandung kata tertentu
journalctl -u myapp.service | grep "error"

Eine Stärke von journald ist das eingebaute strukturierte Logging. Jede Nachricht enthält Metadaten wie Zeitstempel mit Mikrosekunden, systemd-Unit, PID und zusätzliche Anwendungsfelder. Damit sind Suchen vielseitiger als mit grep in gewöhnlichen Textdateien.

Doch journald hat auch Grenzen. Standardmäßig liegen Logs binär in /var/log/journal. Das ist effizient, lässt sich aber nicht mit cat oder tail öffnen. Außerdem bleiben die Logs auf einem Rechner. Bei mehreren Servern muss man sich einzeln anmelden, um Fehler zu suchen.

Für einen Home Server mit nur einem Rechner ist journald bereits zuverlässig. Ich begrenze meist die Aufbewahrung, damit die Festplatte nicht voll wird:

# Edit konfigurasi journald
sudo nano /etc/systemd/journald.conf

# Tambahkan atau ubah baris berikut
[System]
Storage=persistent
MaxFileSec=1week
SystemMaxUse=500M
SystemMaxFiles=5

Damit bleiben Logs auf der Platte, belegen aber höchstens 500 MB. Sie werden wöchentlich rotiert, sodass /var/log nicht unbemerkt anwächst.

rsyslog: Der zuverlässige Klassiker

Vor journald war rsyslog der König der Linux-Logs. Es wird weiterhin häufig eingesetzt, weil es flexibel ist und auf Textdateien basiert. Viele ältere Anwendungen und Netzwerkgeräte—Router, Switches und Access Points—senden Syslog-Nachrichten noch an UDP-Port 514.

Auf meinem Home Server lasse ich rsyslog meist laufen, um Logs dieser Geräte aufzufangen. Eine einfache Konfiguration für das lokale Netzwerk sieht so aus:

# File: /etc/rsyslog.conf atau /etc/rsyslog.d/10-server.conf
module(load="imudp")
input(type="imudp" port="514")

$template RemoteLogs,"/var/log/remote/%fromhost-ip%/%programname%.log"
if $fromhost-ip != '127.0.0.1' then ?RemoteLogs
& stop

Mit dieser Konfiguration erhält jedes Gerät, das Syslog sendet, ein eigenes Verzeichnis unter /var/log/remote/ mit Dateien nach Programmname. Das ist hilfreich, wenn ich Router- oder Access-Point-Logs sehen möchte, ohne das Web-Adminpanel zu öffnen.

Der Vorteil von Textdateien ist ihre Universalität. Sie lassen sich mit tail, grep, awk oder Werkzeugen wie lnav öffnen. Eine spezielle Datenbank ist nicht nötig. Im großen Maßstab wird die Suche jedoch schwierig: Man stelle sich eine Fehlerzeile unter Millionen von Zeilen in Dutzenden Dateien vor.

Loki: Zentrale Logs für den modernen Home Server

Als die Zahl meiner Dienste wuchs, brauchte ich einen bequemeren Ort für die Logsuche. Die Lösung war Loki, das Log-Aggregationssystem von Grafana Labs. Loki ist leichtgewichtig, ressourcensparend und passt gut zu einem Home Server.

Anders als Elastic Stack, das Logs als vollständige JSON-Dokumente speichert, indiziert Loki nur Labels. Die Log-Inhalte bleiben in einem objektähnlichen Speicherformat. Das benötigt deutlich weniger RAM und CPU, was wichtig ist, wenn der Home Server wie meiner nur ein alter Laptop ist.

Die einfachste Einrichtung kann Docker Compose verwenden:

# File: docker-compose.yml
services:
  loki:
    image: grafana/loki:latest
    ports:
      - "3100:3100"
    volumes:
      - ./loki-config.yml:/etc/loki/local-config.yaml
      - loki-data:/loki
    command: -config.file=/etc/loki/local-config.yaml

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

  grafana:
    image: grafana/grafana:latest
    ports:
      - "3000:3000"
    volumes:
      - grafana-data:/var/lib/grafana

volumes:
  loki-data:
  grafana-data:

Promtail ist der Agent, der Logs aus Dateien liest und an Loki sendet. Wir sagen Promtail einfach, welche Dateien gelesen und welche Labels vergeben werden sollen. In Grafana lassen sich die Logs dann nach Labels wie job, container oder host filtern.

Hier ist eine Promtail-Konfiguration für Docker und Syslog:

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: system
    static_configs:
      - targets:
          - localhost
        labels:
          job: syslog
          __path__: /var/log/syslog

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

In Grafana ähnelt die Abfragesprache Prometheus, nur für Logs. Um etwa Docker-Container-Logs mit error zu finden:

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

Oder für Einträge eines systemd-Dienstes, der in eine Datei weitergeleitet wurde:

{job="syslog"} |= "nginx" |= "500"

Die Syntax ist intuitiv. Filter lassen sich verketten, reguläre Ausdrücke verwenden und Felder mit dem Parser pattern oder regexp extrahieren. Das ist viel angenehmer, als Dutzende Terminal-Tabs zu öffnen.

Eine einfache Architektur zum Nachbauen

Wer gerade beginnt, muss nicht alles sofort installieren. Meine Entwicklung sah so aus:

  • Stufe 1: Ein Rechner: Auf journalctl und /var/log setzen. Das genügt zum Lernen und für einfache Fehlersuche.
  • Stufe 2: Mehrere Dienste: rsyslog aktivieren, um Logs von Netzwerkgeräten und Anwendungen mit klassischem Syslog zu sammeln.
  • Stufe 3: Viele Container oder VMs: Loki + Promtail + Grafana installieren, damit jedes Log über ein Dashboard durchsuchbar ist.

Entscheidend ist nicht die Raffinesse der Werkzeuge, sondern wie konsequent Logs gesammelt werden. Jede neue Anwendung sollte vom ersten Tag an eine Logging-Strategie haben. Warte nicht auf den ersten Vorfall, um über Logs nachzudenken.

Für eigene Anwendungen nutze ich ein einheitliches Logformat. Ein einfaches Python-Beispiel:

import logging
import sys

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s %(levelname)s %(name)s: %(message)s",
    handlers=[
        logging.StreamHandler(sys.stdout),
        logging.FileHandler("/var/log/myapp/app.log")
    ]
)

logger = logging.getLogger("myapp")
logger.info("Server started on port 3001")

Ausgaben nach stdout fängt journald auf, wenn die Anwendung als systemd-Service läuft. Ausgaben in eine Datei liest Promtail und sendet sie an Loki. So werden die Logs ohne viel Aufwand redundant.

Best Practices für den direkten Einsatz

Nach einiger Zeit mit Logs habe ich mehrere Gewohnheiten gelernt, die ich empfehle:

  • UTC oder eine einheitliche Zeitzone verwenden. Haben mehrere Server unterschiedliche Zeitzonen, wird die Reihenfolge von Ereignissen schwer nachvollziehbar. Besser UTC nutzen oder wenigstens den Offset notieren.
  • Keine sensiblen Daten loggen. Passwörter, Token und persönliche Informationen dürfen nicht in Logs erscheinen. Logs werden oft geöffnet und lange aufbewahrt.
  • Logrotation einrichten. Für Textdateien logrotate und für journald sowie Loki Aufbewahrungsregeln nutzen. Eine durch Logs volle Platte ist leicht vermeidbar.
  • Aussagekräftige Labels vergeben. In Loki sind Labels der Suchschlüssel. Sinnvoll sind etwa environment=production, service=api oder host=server-lima.
  • Logs zusammen mit Metriken beobachten. Loki nicht nur installieren und nie öffnen. Ein einfaches Grafana-Dashboard für Fehler pro Stunde oder auffällige Antwortzeiten hilft sofort.

Eine logrotate-Konfiguration für eine eigene Anwendung kann so aussehen:

# File: /etc/logrotate.d/myapp
/var/log/myapp/*.log {
    daily
    missingok
    rotate 14
    compress
    delaycompress
    notifempty
    create 0644 www-data www-data
}

Tägliche Rotation mit 14 Sicherungen bewahrt Logs zwei Wochen auf. Das reicht für einen Home Server und schont zugleich den Speicher.

Fazit

Log-Management auf dem Home Server bedeutet nicht, die modernsten Werkzeuge zu installieren. Es geht um Sichtbarkeit. Wenn etwas schiefläuft, müssen wir nicht panisch nach Spuren suchen, weil alles bereits geordnet ist. Vom stets verfügbaren journald über zuverlässiges rsyslog für klassische Geräte bis zu Loki für komfortable Suche hat jedes Werkzeug seine Rolle.

Fang klein an. Stelle sicher, dass jeder Dienst lesbare Logs erzeugt. Richte Rotation ein, damit die Platte nicht voll wird. Wenn schnellere Suche nötig ist, kommt Loki dazu. Vor allem sollte man nicht erst im Problemfall entdecken, dass die benötigten Logs nie gespeichert wurden.

Wenn du eigene Erfahrungen mit Log-Management auf dem Home Server hast, schreibe sie in die Kommentare. Mich interessiert, wie du Logs organisierst und welche Werkzeuge du am häufigsten nutzt. Teile den Artikel gern, wenn er dir geholfen hat.