Mit jour­nalctl lassen sich unter Linux Sys­tem­pro­to­kol­le effizient verwalten und ana­ly­sie­ren. Das Tool bietet Funk­tio­nen zur Über­wa­chung von Sys­tem­ak­ti­vi­tä­ten, Feh­ler­su­che sowie Echt­zeit­pro­to­koll­ver­fol­gung und gibt einen de­tail­lier­ten Einblick in die Pro­to­koll­da­ten. Es ist somit un­ver­zicht­bar, um Sys­tem­pro­ble­me effektiv zu dia­gnos­ti­zie­ren.

Was ist jour­nalctl?

jour­nalctl ist ein leis­tungs­fä­hi­ges Dienst­pro­gramm zum Abfragen und Anzeigen von Er­eig­nis­pro­to­kol­len bzw. Logfiles unter Linux. Es ist ein zentraler Be­stand­teil der System- und Dienst­ver­wal­tungs-Suite systemd, die in vielen modernen Linux-Dis­tri­bu­tio­nen wie Ubuntu, Fedora und Arch Linux stan­dard­mä­ßig zum Einsatz kommt. Der Name setzt sich aus „journal“ (Protokoll) und „ctl“ (Control) zusammen, was die Funktion als Kontroll- und Ana­ly­se­tool un­ter­streicht.

Das Tool er­mög­licht den Zugriff auf das Sys­tem­pro­to­koll, das von systemd-journald verwaltet wird. Dieses Protokoll ist eine zentrale Sammlung von Meldungen und Er­eig­nis­sen während des Sys­tem­be­triebs. Im Gegensatz zu her­kömm­li­chen text­ba­sier­ten Logs bietet jour­nalctl eine struk­tu­rier­te Mög­lich­keit, Pro­to­koll­da­ten in Echtzeit zu durch­su­chen, zu filtern und an­zu­zei­gen. Das hilft dir dabei, Probleme schnell zu dia­gnos­ti­zie­ren und den Sys­tem­sta­tus im Auge zu behalten.

Dazu speichert jour­nalctl die Pro­to­koll­da­tei­en im Bi­när­for­mat, da diese kompakter und ef­fi­zi­en­ter als Text­da­tei­en sind. Bei großen Da­ten­men­gen erlaubt dies eine we­sent­lich schnel­le­re Suche nach be­stimm­ten Er­eig­nis­sen. Zudem bieten binäre Pro­to­koll­da­tei­en durch ihre Struktur einen besseren Schutz vor Ma­ni­pu­la­tio­nen im Vergleich zu einfachen Text-Logs.

Spei­cher­platz für Pro­to­koll­da­tei­en anpassen

Mit jour­nalctl kannst du den Fest­plat­ten-Spei­cher­platz für Pro­to­kol­le begrenzen und kon­fi­gu­rie­ren. Das erfolgt über die Ein­stel­lun­gen des systemd-journald-Dienstes in der Datei /etc/systemd/journald.conf. Dort findest du folgende Einträge:

  • SystemMaxUse: Begrenzt den Spei­cher­platz für Pro­to­kol­le im Sys­tem­ver­zeich­nis.
  • RuntimeMaxUse: Begrenzt den Spei­cher­platz im tem­po­rä­ren Ver­zeich­nis.

Um die Be­gren­zung ein­zu­stel­len, füge folgende Zeilen hinzu oder passe sie an:

[Journal]
SystemMaxUse=50M
RuntimeMaxUse=50M
bash

Die Bei­spiel­wer­te (50M) kannst du frei wählen. Nutze Einheiten wie K (Kilobytes), M (Megabytes), G (Gigabytes) oder T (Terabytes). Nach der Be­ar­bei­tung muss systemd-journald neu gestartet werden:

sudo systemctl restart systemd-journald
bash

Nun ist der Spei­cher­platz begrenzt. Achte darauf, dass das Limit groß genug für wichtige Daten ist, aber nicht zu viel Platz be­an­sprucht. Beachte: Ältere Pro­to­kol­le werden au­to­ma­tisch gelöscht, sobald das Limit erreicht ist.

Ermitteln der Fest­plat­ten­be­le­gung

Bevor du Än­de­run­gen vornimmst, prüfe mit dem Flag --disk-usage, wie viel Platz das Journal aktuell belegt:

journalctl --disk-usage
Journals take up 8.0M on disk.
bash

Alte Pro­to­koll­ein­trä­ge löschen

Sollte das Journal zu groß werden, kannst du alte Einträge manuell entfernen. Dafür gibt es zwei Wege:

Mit --vacuum-size ver­klei­nerst du das Journal auf eine bestimmte Größe. Dabei werden so lange alte Einträge gelöscht, bis der ge­wünsch­te Spei­cher­platz erreicht ist.

sudo journalctl --vacuum-size=1G
bash

Al­ter­na­tiv nutzt du eine Zeit­an­ga­be mit --vacuum-time. Alle Einträge, die älter als der an­ge­ge­be­ne Zeitraum sind, werden entfernt. Um z. B. nur die Logs des letzten Jahres zu behalten, gibst du Folgendes ein:

sudo journalctl --vacuum-time=1years
bash

Was kann jour­nalctl?

Eine der Stärken von jour­nalctl ist das Filtern von Log-Einträgen nach ver­schie­de­nen Kriterien. So findest du gezielt relevante Infos und iden­ti­fi­zierst Fehler rascher. Hier sind die wich­tigs­ten Fil­ter­op­tio­nen.

Pro­to­kol­le anzeigen

Mit dem Befehl journalctl siehst du die Pro­to­kol­le des aktuellen Systems in um­ge­kehr­ter chro­no­lo­gi­scher Rei­hen­fol­ge. Nutze journalctl -f oder journalctl --follow, um Einträge in Echtzeit zu verfolgen – neue Meldungen er­schei­nen sofort am Bild­schirm.

Je nach Laufzeit deines Systems können das zehn­tau­sen­de Zeilen sein. Um den Überblick zu behalten, lässt sich die Ausgabe mit Linux-Befehlen weiter ein­gren­zen.

Filtern nach Zeit

Mit jour­nalctl kannst du Pro­to­kol­le auf bestimmte Zeit­punk­te ein­schrän­ken, um die Suche ef­fi­zi­en­ter zu gestalten.

Filtern nach Boot­vor­gän­gen

Das Filtern nach Boot­vor­gän­gen ist ideal, um Er­eig­nis­se eines be­stimm­ten Sys­tem­starts zu ana­ly­sie­ren. So grenzt du Fehler auf einen spe­zi­fi­schen Sys­tem­zu­stand ein.

  1. Aktueller Boot: journalctl -b zeigt alle Logs seit dem letzten Neustart.
  2. Ver­gan­ge­ne Boot­vor­gän­ge: Mit -b und einer Zahl (z. B. journalctl -b 1 für den vor­letz­ten Start) rufst du ältere Logs auf.
  3. Liste aller Boot­vor­gän­ge: journalctl --list-boots listet alle ver­füg­ba­ren Boot­vor­gän­ge inklusive IDs auf.

Bei manchen Dis­tri­bu­tio­nen muss das Speichern alter Boot-Logs erst aktiviert werden. Erstelle dazu das Ver­zeich­nis sudo mkdir -p /var/log/journal.

Al­ter­na­tiv be­ar­bei­test du die Kon­fi­gu­ra­ti­on mit sudo nano /etc/systemd/journald.conf und setzt unter [Journal] den Wert Storage= auf persistent:

. . .
[Journal]
Storage=persistent
bash

Filtern nach Zeit­fens­tern

Mit --since und --until grenzt du Einträge auf ein Zeit­fens­ter ein. Nutze das Format YYYY-MM-DD HH:MM:SS. Beispiel für den Zeitraum vom 1. bis 2. Januar 2023:

journalctl --since "2023-01-01 12:00:00" --until "2023-01-02 12:00:00"
bash

Die Kom­bi­na­ti­on beider Befehle erlaubt auch sehr kurze In­ter­val­le:

journalctl --since 09:00 --until "1 hour ago"
bash

Du kannst auch Teile des Formats weglassen, um z. B. alle Einträge ab einem Start­punkt zu sehen:

journalctl --since "2023-11-16 15:25:00"
bash

jour­nalctl versteht auch relative Begriffe wie yesterday (gestern), today (heute) oder tomorrow (morgen). Für gestrige Logs gibst du ein:

journalctl --since yesterday
bash

Filtern nach Nach­rich­ten­in­ter­es­se

Du kannst die Suche auf bestimmte Aspekte kon­zen­trie­ren, was bei der Feh­ler­dia­gno­se oder Si­cher­heits­über­prü­fung enorm hilft.

Filtern nach Priorität

Nutze die Prio­ri­tä­ten der Pro­to­koll­ein­trä­ge (Name oder Nummer). Je niedriger die Zahl, desto kri­ti­scher die Meldung:

  • 0: emerg (Notfall)
  • 1: alert (Alarm)
  • 2: crit (kritisch)
  • 3: err (Fehler)
  • 4: warning (Warnung)
  • 5: notice (Hinweis)
  • 6: info (In­for­ma­ti­on)
  • 7: debug (Feh­ler­su­che)

Filtere mit -p. Der folgende Befehl zeigt alle Meldungen ab der Stufe „err“ (Error) aufwärts:

journalctl -p err
bash

Filtern nach Einheit

Um Pro­to­kol­le spe­zi­fi­scher Dienste (Units) zu sehen, nutze -u. Für den Apache-Webserver lautet der Befehl:

journalctl -u apache2
bash

Kom­bi­nie­re dies mit Zeit­fil­tern, um etwa zu prüfen, ob der Dienst heute bereits aktiv war:

journalctl -u apache2 --since today
bash

Du kannst auch mehrere Units zu­sam­men­füh­ren, etwa wenn Nginx und PHP-FPM zu­sam­men­ar­bei­ten:

journalctl -u nginx.service -u php-fpm.service --since today-u apache2 --since today
bash

Filtern nach Prozess, Benutzer oder Gruppen-ID

Kennst du die PID eines Prozesses, filterst du mit _PID. Beispiel für PID 8088:

journalctl _PID=8088
bash

Al­ter­na­tiv zeigen _UID oder _GID alle Einträge eines Benutzers oder einer Gruppe. Die ID des Users „www-data“ findest du so:

id -u www-data
33
bash

Nutze die ID dann für den Filter:

journalctl _UID=33 --since today
bash

Eine Übersicht aller Gruppen-IDs im Journal liefert -F:

journalctl -F _GID
32
99
102
133
81
84
100
0
124
87
bash

Filtern nach Kom­po­nen­ten­feld

Dies ist ideal, um den Fokus auf spe­zi­fi­sche Software-Kom­po­nen­ten zu legen. Um etwa Einträge der aus­führ­ba­ren Datei bash zu sehen, gibst du ein:

journalctl /usr/bin/bash
bash

Kernel-Meldungen anzeigen

Das Ana­ly­sie­ren von Kernel-Meldungen hilft bei der Suche nach Hardware-Problemen oder Trei­ber­kon­flik­ten. Nutze dazu das Flag -k oder (ent­spricht dmesg):

journalctl -k
bash

Stan­dard­mä­ßig siehst du den aktuellen Boot. Für die letzten fünf Boot­vor­gän­ge gibst du Folgendes ein:

journalctl -k -b -5
bash

Journ­al­an­zei­ge in jour­nalctl anpassen

Passe die Dar­stel­lung an, um In­for­ma­tio­nen schneller zu erfassen.

Kürzen oder Erweitern der Ausgabe

Stan­dard­mä­ßig nutzt jour­nalctl einen Pager und lässt lange Zeilen rechts auslaufen. Mit --no-full kürzt du die Anzeige:

journalctl --no-full
bash

Mit -a wird hingegen der gesamte Inhalt angezeigt:

journalctl -a
bash

jour­nalctl auf Stan­dard­aus­ga­be setzen

Nor­ma­ler­wei­se wird ein Pager wie less genutzt. Möchtest du die Logs direkt in der Konsole (Stan­dard­aus­ga­be) ausgeben, nutze:

journalctl --no-pager
bash

Aus­ga­be­for­ma­te ein­stel­len

Mit -o und einem For­mat­be­zeich­ner änderst du den Stil. Für JSON-Ausgabe nutzt du:

journalctl -b -u nginx -o json
{ "__CURSOR" : "s=13a21661cf4948289c63075db6c25c00;i=116f1;b=81b58db8fd9046ab9f847ddb82a2fa2d;m=19f0daa;t=50e33c33587ae;x=e307daadb4858635", "__REALTIME_TIMESTAMP" : "1422990364739502", "__MONOTONIC_TIMESTAMP" : "27200938", "_BOOT_ID" : "81b58db8fd9046ab9f847ddb82a2fa2d", "PRIORITY" : "6", "_UID" : "0", "_GID" : "0", "_CAP_EFFECTIVE" : "3fffffffff", "_MACHINE_ID" : "752737531a9d1a9c1e3cb52a4ab967ee", "_HOSTNAME" : "desktop", "SYSLOG_FACILITY" : "3", "CODE_FILE" : "src/core/unit.c", "CODE_LINE" : "1402", "CODE_FUNCTION" :
bash

Ver­füg­ba­re Formate sind unter anderem:

  • cat: Nur das Mel­dungs­feld.
  • export: Bi­när­for­mat für Backups.
  • json: Ein JSON-Eintrag pro Zeile.
  • json-pretty: For­ma­tier­tes JSON für bessere Les­bar­keit.
  • short: Klas­si­scher syslog-Stil.
  • verbose: Zeigt alle ver­füg­ba­ren Felder eines Eintrags.

Aktive Pro­zess­über­wa­chung

Mit der Option -n (ähnlich wie beim Befehl tail -n) verfolgst du Prozesse aktiv und lässt dir nur die neuesten Einträge anzeigen.

Anzeigen aktueller Pro­to­kol­le

Stan­dard­mä­ßig siehst du mit diesem Befehl die letzten 10 Einträge:

journalctl -n
bash

Die Anzahl kannst du in­di­vi­du­ell anpassen, zum Beispiel auf 20:

journalctl -n 20
bash
Zum Hauptmenü