Wat is Jour­nalctl en wat kan het doen?

Jour­nalctl is een ef­fi­ci­ën­te oplossing voor het beheren en ana­ly­se­ren van sys­teem­log­boe­ken in Linux-om­ge­vin­gen. Deze tool kan worden gebruikt voor het monitoren van sys­teem­ac­ti­vi­tei­ten, het oplossen van problemen en het realtime volgen van logboeken, waardoor cruciale inzichten worden verkregen voor het effectief dia­gnos­ti­ce­ren van sys­teem­pro­ble­men.

Wat is Jour­nalctl?

journalctl is een krachtig hulp­pro­gram­ma voor het opvragen en weergeven van ge­beur­te­nis­log­boe­ken of log­be­stan­den onder Linux. Het is een centraal onderdeel van de systeem- en ser­vi­ce­be­heers­ui­te systemd, die bij veel moderne Linux-dis­tri­bu­ties zoals Ubuntu, Fedora en Arch Linux wordt geleverd. De naam ‘jour­nalctl’ is een com­bi­na­tie van ‘journal’ (logboek) en ‘ctl’ (controle), wat verwijst naar het feit dat het commando wordt gebruikt om logboeken te con­tro­le­ren en te ana­ly­se­ren.

journalctl ver­een­vou­digt de toegang tot het sys­teem­log­boek, dat wordt beheerd door systemd-journald. Het sys­teem­log­boek is een ge­cen­tra­li­seer­de ver­za­me­ling van berichten en ge­beur­te­nis­sen die plaats­vin­den tijdens de werking van een Linux-systeem. In te­gen­stel­ling tot tra­di­ti­o­ne­le tekst­ge­ba­seer­de logboeken biedt journalctl een ge­struc­tu­reer­de en ef­fi­ci­ën­te manier om log­ge­ge­vens in realtime te door­zoe­ken, te filteren en weer te geven. Dit kan helpen bij het dia­gnos­ti­ce­ren van problemen of het bewaken van de sys­teem­sta­tus.

Voor dit doel slaat Jour­nalctl de log­be­stan­den op in binair formaat, omdat binaire log­be­stan­den compacter en ef­fi­ci­ën­ter zijn dan hun op tekst ge­ba­seer­de te­gen­han­gers. Gezien de grote hoe­veel­heid gelogde gegevens maakt dit een snellere en ef­fi­ci­ën­te­re zoek­op­dracht naar spe­ci­fie­ke ge­beur­te­nis­sen of in­for­ma­tie binnen de log­be­stan­den mogelijk. Door hun ge­struc­tu­reer­de en ge­co­deer­de aard bieden binaire log­be­stan­den ook ver­be­ter­de be­vei­li­ging in ver­ge­lij­king met op tekst ge­ba­seer­de logs, aangezien hun formaat het ma­ni­pu­le­ren van log­ge­ge­vens moei­lij­ker maakt.

Hoe u de op­slag­ruim­te voor log­be­stan­den kunt aanpassen

journalctl kan worden gebruikt om de op­slag­ruim­te die log­be­stan­den op de harde schijf innemen te beperken en te con­fi­gu­re­ren. Dit gebeurt via de in­stel­lin­gen van de service systemd-journald. De con­fi­gu­ra­tie-in­stel­lin­gen worden op­ge­sla­gen in het bestand /etc/systemd/journald.conf. Hier vindt u de volgende ver­mel­din­gen:

• SystemMaxUse: Beperkt de op­slag­ruim­te voor log­be­stan­den in de sys­teem­map
• RuntimeMaxUse: Beperkt de op­slag­ruim­te voor log­be­stan­den in de tij­de­lij­ke map

Om de ge­heu­gen­li­miet in te stellen, voegt u de volgende regels toe of wijzigt u deze indien nodig:

[Journal] 
SystemMaxUse=50M 
RuntimeMaxUse=50M

De waarden uit dit voorbeeld (50M) kunnen naar behoefte worden aangepast. U kunt ook andere eenheden gebruiken, zoals K (kilobytes), M (megabytes), G (gigabytes) of T (terabytes). Nadat u het con­fi­gu­ra­tie­be­stand hebt bewerkt, moet systemd-journald opnieuw worden opgestart om de wij­zi­gin­gen door te voeren:

sudo systemctl restart systemd-journald

Door deze stappen te volgen, wordt systemd-journald ge­con­fi­gu­reerd om de schijf­ruim­te voor log­be­stan­den te beperken. Zorg ervoor dat de limiet die u kiest voldoende is om es­sen­ti­ë­le log­ge­ge­vens op te slaan. Te­ge­lij­ker­tijd is het be­lang­rijk om te voorkomen dat u bui­ten­spo­rig veel schijf­ruim­te gebruikt. Houd er rekening mee dat oudere logs au­to­ma­tisch worden ver­wij­derd zodra de limiet van de toe­ge­we­zen schijf­ruim­te is bereikt.

Beoordeel het gebruik van schijf­ruim­te

Con­tro­leer voordat u de op­slag­ruim­te voor log­be­stan­den aanpast hoeveel op­slag­ruim­te momenteel door het journaal wordt ingenomen. Gebruik hiervoor --disk-usage:

journalctl --disk-usage

Hier is een voorbeeld van hoe de uitvoer eruitziet:

Journals take up 8.0M on disk.

Oude log­boek­ver­mel­din­gen ver­wij­de­ren

Als Journal te veel geheugen in beslag neemt, kunt u oude log­boek­ver­mel­din­gen ver­wij­de­ren. Er zijn twee manieren om dit te doen:

Gebruik --vacuum-size om de grootte van uw dagboek te ver­klei­nen door de grootte op te geven. Met deze methode worden oude ver­mel­din­gen ver­wij­derd totdat de totale op­slag­ruim­te van het dagboek op de harde schijf de gewenste grootte heeft bereikt.

sudo journalctl --vacuum-size=1G

Als al­ter­na­tief kunt u het logboek ver­klei­nen door een be­waar­ter­mijn in te stellen met behulp van de optie --vacuum-time. Invoer die ouder is dan de opgegeven tijd wordt ver­wij­derd. Om log­boek­ver­mel­din­gen van het afgelopen jaar te bewaren, kunt u de volgende opdracht gebruiken:

sudo journalctl --vacuum-time=1years

Wat kan Jour­nalctl doen?

journalctl biedt krachtige fil­ter­mo­ge­lijk­he­den, waarmee ge­brui­kers log­boek­ver­mel­din­gen op basis van ver­schil­len­de criteria kunnen door­zoe­ken. Deze functie maakt het mogelijk om gericht naar relevante in­for­ma­tie te zoeken, waardoor problemen sneller kunnen worden ge­ï­den­ti­fi­ceerd. Hier volgen enkele veel­ge­bruik­te journalctl fil­ter­op­ties:

Logs weergeven

Door het commando journalctl uit te voeren, worden log­boek­ver­mel­din­gen voor het huidige systeem in om­ge­keer­de chro­no­lo­gi­sche volgorde weer­ge­ge­ven. Gebruik journalctl -f of journalctl --follow om de ver­mel­din­gen in realtime weer te geven. Nieuwe ver­mel­din­gen worden au­to­ma­tisch weer­ge­ge­ven in de volgorde waarin ze bin­nen­ko­men.

Af­han­ke­lijk van hoe lang systemd al op uw systeem draait, krijgt u waar­schijn­lijk een on­be­heers­ba­re hoe­veel­heid gegevens te zien, die tien­dui­zen­den of zelfs hon­derd­dui­zen­den regels lang kan zijn. Om sneller te vinden wat u zoekt, kunt u de log­be­stan­den verder filteren met behulp van ver­schil­len­de Linux-commando’s.

Hoe filteren op tijd

Met behulp van journalctl kunnen log­be­stan­den worden gefilterd op een specifiek tijdstip, zodat ze ef­fi­ci­ën­ter kunnen worden doorzocht op relevante in­for­ma­tie.

Filteren op op­start­pro­ces

Het filteren van log­be­stan­den op basis van het op­start­pro­ces is van on­schat­ba­re waarde voor het on­der­zoe­ken van sys­teem­ge­beur­te­nis­sen op spe­ci­fie­ke tijd­stip­pen of tijdens op­start­sce­na­rio’s. Deze gerichte aanpak stroom­lijnt de pro­bleem­di­a­gno­se door log­boek­ver­mel­din­gen te con­cen­tre­ren op spe­ci­fie­ke sys­teem­sta­tus­sen of con­fi­gu­ra­ties.

1. Huidige opstart: Met journalctl -b worden alle log­boek­ver­mel­din­gen weer­ge­ge­ven die sinds de laatste herstart zijn verzameld.
2. Eerdere op­start­ses­sies: Gebruik de optie -b gevolgd door een nummer om de log­boek­ver­mel­din­gen voor een spe­ci­fie­ke eerdere op­start­ses­sie weer te geven. Als u bij­voor­beeld journalctl -b 1 invoert, wordt de vorige op­start­ses­sie weer­ge­ge­ven.
3. Lijst met alle be­schik­ba­re op­start­pro­ces­sen: Met het commando journalctl --list-boots wordt een lijst met be­schik­ba­re op­start­ses­sies met hun res­pec­tie­ve­lij­ke ID’s weer­ge­ge­ven. U kunt de gewenste opstart-ID gebruiken om de logboeken voor een spe­ci­fie­ke op­start­ses­sie weer te geven.

Hoewel het opslaan van eerdere op­start­pro­ces­sen standaard is in­ge­scha­keld op sommige Linux-dis­tri­bu­ties, moeten ge­brui­kers dit op andere dis­tri­bu­ties mogelijk eerst in­scha­ke­len. Om dit te doen, maakt u een map aan waar het log­be­stand wordt op­ge­sla­gen door sudo mkdir -p /var/log/journal in te voeren. U kunt ook het con­fi­gu­ra­tie­be­stand van het logboek bewerken met sudo nano /etc/systemd/journald.conf. Stel ver­vol­gens de optie Storage= onder [Journal] in op persistent om per­ma­nen­te log­boek­re­gi­stra­tie in te schakelen:

. . . 
[Journal] 
Storage=persistent

Filteren op tijd­ven­ster

Soms kan het nodig zijn om log­boek­ver­mel­din­gen voor een bepaalde periode weer te geven. journalctl biedt de opties --since en --until, die kunnen worden gebruikt om de ver­mel­din­gen tot een bepaalde periode te beperken. Gebruik hiervoor de tijd­no­ta­tie YYYY-MM-DD HH:MM:SS. Het commando om alle log­boek­ver­mel­din­gen tussen 1 januari 2023 om 12:00 uur en 2 januari 2023 om 12:00 uur weer te geven, ziet er als volgt uit:

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

De com­bi­na­tie van de twee commando’s kan ook filteren voor een kortere periode:

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

Je kunt ook delen van het formaat weglaten. Als je bij­voor­beeld alle ver­mel­din­gen vanaf een bepaald tijdstip wilt weergeven:

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

journalctl herkent ook relatieve waarden zoals yesterday, today of tomorrow. Om de gegevens van gisteren weer te geven, voert u het volgende in:

journalctl --since yesterday

Hoe filteren op be­richt­ken­mer­ken

Het gebruik van journalctl om log­boek­ver­mel­din­gen te filteren op basis van be­lang­rijk­heid of inhoud is ook uiterst nuttig, omdat u hiermee naar relevante in­for­ma­tie kunt zoeken en u kunt con­cen­tre­ren op spe­ci­fie­ke aspecten van de sys­teem­log­boe­ken. Dit maakt onder andere een ef­fi­ci­ën­te fout­dia­gno­se, vroege detectie van be­vei­li­gings­pro­ble­men en snelle pres­ta­tie­be­wa­king mogelijk.

Filteren op pri­o­ri­teit

Om log­be­stan­den met journalctl te filteren op be­lang­rijk­heid van het bericht, kunt u de pri­o­ri­teits­ca­te­go­rie­ën voor log­boek­ver­mel­din­gen gebruiken. Hiervoor kunt u de pri­o­ri­teits­naam of de bij­be­ho­ren­de numerieke waarde gebruiken. Hoe lager het getal, hoe be­lang­rij­ker het bericht:

• 0: emerg (nood­si­tu­a­tie)
• 1: alert (alarm)
• 2: crit (kritiek)
• 3: err (fout)
• 4: waar­schu­wing (warning)
• 5: notice (opmerking)
• 6: info (in­for­ma­tie)
• 7: debug (pro­bleem­op­los­sing)

Berichten met een bepaalde pri­o­ri­teit kunnen worden gefilterd met behulp van de optie -p. Het volgende commando geeft bij­voor­beeld alleen log­boek­ver­mel­din­gen weer met de pri­o­ri­teit ‘err’ (fout) en hoger:

journalctl -p err

Filteren op eenheid

Het filteren van log­be­stan­den per eenheid is handig om u te con­cen­tre­ren op spe­ci­fie­ke services of processen. Deze kunnen worden gefilterd met behulp van de optie -u. Om bij­voor­beeld log­boek­ver­mel­din­gen voor de Apache-webserver weer te geven, voert u het volgende in:

journalctl -u apache2

De zoek­op­dracht kan verder worden verfijnd met behulp van relatieve tijd­waar­den. Om te bepalen of de dienst vandaag al is uit­ge­voerd, kunt u het volgende invoeren:

journalctl -u apache2 --since today

journalctl kan ge­ge­vens­re­cords van ver­schil­len­de eenheden sa­men­voe­gen. Als uw Nginx-proces bij­voor­beeld is gekoppeld aan een PHP FPM-eenheid, kunnen hun ver­mel­din­gen chro­no­lo­gisch worden sa­men­ge­voegd. Het commando hiervoor is:

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

Filteren op proces, gebruiker of groeps-ID

Jour­nalctl kan log­boek­ver­mel­din­gen filteren op proces-, ge­brui­kers- of groeps-ID. Als u de exacte PID hebt van het proces dat u wilt zoeken, kunt u de optie _PID gebruiken om ver­mel­din­gen te filteren. Als de PID bij­voor­beeld 8088 is, ziet het commando er als volgt uit:

journalctl _PID=8088

Je kunt ook de filters _UID of _GID gebruiken om alle ver­mel­din­gen weer te geven die door een bepaalde gebruiker of groep zijn ge­re­gi­streerd. Als je webserver bij­voor­beeld ‘www-data’ heet, kun je de ge­brui­kers-ID als volgt vinden:

id -u www-data
33

De jour­naal­boe­kin­gen kunnen worden gefilterd op basis van het ID:

journalctl _UID=33 --since today

Om te bepalen voor welke groep-ID’s er ver­mel­din­gen zijn aan­ge­maakt, kunt u de optie -F gebruiken. Hiermee worden alle waarden weer­ge­ge­ven die zijn op­ge­sla­gen voor het veld Groep-ID:

journalctl -F _GID

Hier is een voorbeeld van de uitvoer:

32
99
102
133
81
84
100
0
124
87

Filteren op component

Filteren op component is handig om u te con­cen­tre­ren op spe­ci­fie­ke toe­pas­sin­gen, services of processen. Het com­po­nent­veld wordt doorgaans gebruikt door ver­schil­len­de services of soft­wa­re­com­po­nen­ten om spe­ci­fie­ke in­for­ma­tie in de logboeken te on­der­schei­den. Met deze filtering kunt u log­boek­ver­mel­din­gen beperken tot een bepaalde component, toe­pas­sing of service-eenheid. Als u bij­voor­beeld ver­mel­din­gen wilt filteren die het uit­voer­ba­re bestand bash bevatten, voert u de volgende opdracht in:

journalctl /usr/bin/bash

Ker­nel­be­rich­ten weergeven

Het filteren van log­boek­ver­mel­din­gen voor ker­nel­be­rich­ten met journalctl is een ef­fec­tie­ve manier om in­for­ma­tie over de werking van de kernel in een Linux-systeem te ana­ly­se­ren. Ker­nel­be­rich­ten kunnen aan­wij­zin­gen geven over hard­wa­re­pro­ble­men, stuur­pro­gram­ma-con­flic­ten of andere sys­teem­ge­beur­te­nis­sen.

Ker­nel­be­rich­ten die in de dmesg -uitvoer te vinden zijn, kunnen ook uit het journaal worden gefilterd. Ze kunnen worden weer­ge­ge­ven met de vlaggen `-k or ``:

journalctl -k

De ker­nel­be­rich­ten van het huidige op­start­pro­ces worden standaard weer­ge­ge­ven. U kunt filteren op berichten van een al­ter­na­tie­ve op­start­pro­ce­du­re met behulp van de eerder genoemde op­start­se­lec­tie­vlag­gen. Als u bij­voor­beeld de ker­nel­be­rich­ten van de laatste vijf op­start­pro­ces­sen wilt bekijken, voert u het volgende in:

journalctl -k -b -5

De weergave van het logboek wijzigen in Jour­nalctl

Door de weergave in journalctl aan te passen, kunnen ge­brui­kers nauw­keu­ri­ger door log­be­stan­den zoeken en snel in­for­ma­tie ex­tra­he­ren. Ge­brui­kers kunnen de weergave aanpassen om log­ge­ge­vens over een spe­ci­fie­ke periode of in realtime weer te geven, zodat sys­teem­fou­ten en -problemen snel kunnen worden ge­ï­den­ti­fi­ceerd.

De output verkorten of uit­brei­den

U kunt de manier waarop journalctl gegevens weergeeft aanpassen door de uitvoer in te korten of uit te breiden. Standaard geeft journalctl de volledige invoer weer in de pager en voert deze uit aan de rech­ter­kant van het scherm. De uitvoer kan worden ingekort met de optie --no-full:

journalctl --no-full

U kunt de weergave uit­brei­den met de vlag -a:

journalctl -a

Stel journalctl in op stan­daard­uit­voer

In journalctl wordt de loguit­voer standaard weer­ge­ge­ven met behulp van een pager zoals less. Hierdoor kunnen ge­brui­kers de uitvoer staps­ge­wijs bekijken, waardoor ze ge­mak­ke­lij­ker door lange log­be­stan­den kunnen navigeren. Er zijn echter gevallen waarin het weergeven van de stan­daard­uit­voer van logs nood­za­ke­lijk is. Hier volgt hoe u dat kunt doen:

journalctl --no-pager

Uit­voer­for­ma­ten instellen

journalctl biedt ook opties voor het aanpassen van het uit­voer­for­maat van log­be­stan­den. Hiervoor kunt u de optie -o gebruiken met de bij­be­ho­ren­de for­maat­i­den­ti­fi­ca­tie. Om bij­voor­beeld log­boek­ver­mel­din­gen in JSON-formaat uit te voeren, voert u de volgende code in:

journalctl -b -u nginx -o json

Dit is de uitvoer:

{ "__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" :

De volgende formaten kunnen worden gebruikt in Jour­nalctl:

• cat: Geeft alleen het be­richt­veld weer
• export: Binair formaat geschikt voor over­dracht of opslag
• json: Standaard JSON met één ver­mel­ding per regel
• json-pretty: JSON-opmaak voor betere lees­baar­heid
• json-sse: Om­wik­kel­de JSON-opmaak waarmee door de server verzonden ge­beur­te­nis­sen kunnen worden toe­ge­voegd
• short: Standaard syslog-stijl uitvoer
• short-iso: Stan­daard­for­maat voor het weergeven van ISO-8601-tijd­stem­pels
• short-monotonic: Stan­daard­for­maat met monotone tijd­stem­pels
• short-precise: stan­daard­for­maat met mi­cro­se­con­de­pre­ci­sie
• verbose: Geeft elk be­schik­baar jour­naal­veld voor de be­tref­fen­de invoer weer

Hoe voert journalctl actieve pro­ces­be­wa­king uit?

Tijdens actieve pro­ces­be­wa­king met journalctl wordt het op­dracht­re­gel­pro­gram­ma tail gebruikt om log­be­stan­den in realtime bij te houden en de meest recente ver­mel­din­gen weer te geven. Dit maakt het ge­mak­ke­lij­ker om sys­teem­ge­beur­te­nis­sen in realtime te bewaken en snel op problemen te reageren.

Hoe de huidige log­be­stan­den weergeven

De optie -n kan worden gebruikt om een bepaald aantal ge­ge­vens­re­cords weer te geven. Deze werkt op precies dezelfde manier als tail -n. Om de laatste 10 ver­mel­din­gen weer te geven, gebruikt u de volgende opdracht:

journalctl -n

U kunt ook het aantal ver­mel­din­gen instellen, bij­voor­beeld op 20:

journalctl -n 20