Jour­nalctl är en effektiv lösning för hantering och analys av system­log­gar i Linux-miljöer. Detta verktyg kan användas för över­vak­ning av sys­te­mak­ti­vi­te­ter, fel­sök­ning och logg­spår­ning i realtid, vilket ger viktiga insikter för effektiv di­a­gnostik av system­pro­blem.

Vad är Jour­nalctl?

journalctl är ett kraft­fullt verktyg för att söka och visa hän­del­se­log­gar eller loggfiler under Linux. Det är en central komponent i system- och tjäns­te­han­te­rings­pa­ke­tet systemd, som ingår i många moderna Linux-dis­tri­bu­tio­ner såsom Ubuntu, Fedora och Arch Linux. Namnet ”jour­nalctl” är en blandning av ”journal” (logg) och ”ctl” (kontroll), vilket hänvisar till det faktum att kommandot används för att kon­trol­le­ra och analysera loggar.

journalctl förenklar åtkomsten till system­log­gen, som hanteras av systemd-journald. System­log­gen är en cent­ra­li­se­rad samling av med­de­lan­den och händelser som inträffar under driften av ett Linux-system. Till skillnad från tra­di­tio­nel­la text­ba­se­ra­de loggar erbjuder journalctl ett struk­tu­re­rat och effektivt sätt att söka, filtrera och visa loggdata i realtid. Detta kan hjälpa till att di­a­gnos­ti­se­ra problem eller övervaka systemsta­tus.

För detta ändamål sparar Jour­nalctl logg­fi­ler­na i binärt format, eftersom binära loggfiler är mer kompakta och effektiva än sina text­ba­se­ra­de mot­sva­rig­he­ter. Med tanke på den stora mängden loggade data möjliggör detta en snabbare och ef­fek­ti­va­re sökning efter specifika händelser eller in­for­ma­tion i logg­fi­ler­na. Med sin struk­tu­re­ra­de och kryp­te­ra­de karaktär ger binära loggfiler också för­bätt­rad säkerhet jämfört med text­ba­se­ra­de loggar, eftersom deras format gör det svårare att ma­ni­pu­le­ra loggdata.

Hur man justerar lag­rings­ut­rym­met för loggfiler

journalctl kan användas för att begränsa och kon­fi­gu­re­ra lag­rings­ut­rym­met som logg­fi­ler­na upptar på hård­dis­ken. Detta görs via in­ställ­ning­ar­na för tjänsten systemd-journald. Kon­fi­gu­ra­tions­in­ställ­ning­ar­na lagras i filen /etc/systemd/journald.conf. Här hittar du följande poster:

  • SystemMaxUse: Begränsar lag­rings­ut­rym­met för loggar i system­ka­ta­lo­gen
  • RuntimeMaxUse: Begränsar lag­rings­ut­rym­met för loggar i den till­fäl­li­ga katalogen

För att ställa in min­nes­grän­sen, lägg till följande rader eller ändra dem efter behov:

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

Värdena i detta exempel (50M) kan ändras efter behov. Du kan också använda andra enheter, till exempel K (kilobyte), M (megabyte), G (gigabyte) eller T (terabyte). När du har redigerat kon­fi­gu­ra­tions­fi­len måste systemd-journald startas om för att änd­ring­ar­na ska träda i kraft:

sudo systemctl restart systemd-journald
bash

Om du följer dessa steg kommer systemd-journald att kon­fi­gu­re­ras så att det begränsar dis­kut­rym­met för loggfiler. Se till att den gräns du väljer är till­räck­lig för att lagra viktiga loggdata. Samtidigt är det viktigt att undvika att använda för mycket dis­kut­rym­me. Tänk på att äldre loggar au­to­ma­tiskt tas bort när gränsen för tilldelat dis­kut­rym­me har nåtts.

Utvärdera dis­kut­rym­me­san­vänd­ning­en

Innan du justerar lag­rings­ut­rym­met för loggfiler, kon­trol­le­ra hur mycket lag­rings­ut­rym­me som för när­va­ran­de upptas av journalen. För att göra detta, använd --disk-usage:

journalctl --disk-usage
bash

Här är ett exempel på hur re­sul­ta­tet ser ut:

Journals take up 8.0M on disk.
bash

Ta bort gamla logg­pos­ter

Om Journal tar upp för mycket minne kan du radera gamla logg­pos­ter. Det finns två sätt att göra detta:

Använd --vacuum-size för att minska storleken på din journal genom att ange storleken. Med denna metod tas gamla poster bort tills det totala lag­rings­ut­rym­met för journalen på hård­dis­ken har nått önskad storlek.

sudo journalctl --vacuum-size=1G
bash

Al­ter­na­tivt kan du minska storleken på loggen genom att ange en lag­rings­tid med al­ter­na­ti­vet --vacuum-time. Poster som är äldre än den angivna tiden kommer att raderas. För att behålla logg­pos­ter från det senaste året kan du använda följande kommando:

sudo journalctl --vacuum-time=1years
bash

Vad kan Jour­nalctl göra?

journalctl erbjuder kraft­ful­la fil­tre­rings­funk­tio­ner som gör det möjligt för användare att söka igenom logg­pos­ter utifrån olika kriterier. Denna funktion möjliggör riktade sökningar efter relevant in­for­ma­tion, vilket un­der­lät­tar snabbare pro­ble­mi­den­ti­fi­e­ring. Här är några vanliga journalctl fil­te­ral­ter­na­tiv:

Visa loggar

Genom att utföra kommandot journalctl visas logg­pos­ter för det aktuella systemet i omvänd kro­no­lo­gisk ordning. Använd journalctl -f eller journalctl --follow för att visa posterna i realtid. Nya poster visas au­to­ma­tiskt i den ordning de anländer.

Beroende på hur länge systemd har körts på ditt system kommer du troligen att få se en ohan­ter­lig mängd data, som kan vara ti­o­tu­sen­tals eller hund­ra­tu­sen­tals rader lång. För att snabbare hitta det du letar efter kan du filtrera loggarna yt­ter­li­ga­re med hjälp av olika Linux-kommandon.

Hur man filtrerar efter tid

Med hjälp av journalctl kan loggar filtreras enligt en specifik tidpunkt så att de kan sökas mer effektivt efter relevant in­for­ma­tion.

Filtrera efter start­pro­cess

Att filtrera loggar efter start­pro­ces­sen är ovär­der­ligt för att undersöka system­hän­del­ser vid exakta tid­punk­ter eller under startsce­na­ri­er. Denna mål­in­rik­ta­de metod ef­fek­ti­vi­se­rar pro­blemdi­a­gnosti­ken genom att fokusera logg­pos­ter på specifika systemsta­tu­sar eller kon­fi­gu­ra­tio­ner.

  1. Aktuell uppstart: Med journalctl -b visas alla logg­pos­ter som har samlats in sedan senaste omstarten.
  2. Tidigare uppstart: Använd al­ter­na­ti­vet -b följt av ett nummer för att visa logg­pos­ter­na för en specifik tidigare uppstart. Om du till exempel anger journalctl -b 1 visas den tidigare upp­star­ten.
  3. Lista över alla till­gäng­li­ga start­pro­ces­ser: Kommandot journalctl --list-boots visar en lista över till­gäng­li­ga starter med re­spek­ti­ve ID. Du kan använda önskat start-ID för att visa loggarna för en specifik start.

Även om sparandet av tidigare start­pro­ces­ser är aktiverat som standard i vissa Linux-dis­tri­bu­tio­ner, kan användare behöva aktivera det först i andra. För att göra detta, skapa en katalog där loggen ska sparas genom att ange sudo mkdir -p /var/log/journal. Al­ter­na­tivt kan du redigera jour­na­lens kon­fi­gu­ra­tions­fil med sudo nano /etc/systemd/journald.conf. Ställ sedan in al­ter­na­ti­vet Storage= under [Journal] till persistent för att aktivera permanent loggning:

. . . 
[Journal] 
Storage=persistent
bash

Filtrera efter tids­föns­ter

Ibland kan det vara nöd­vän­digt att visa logg­pos­ter för en viss tids­pe­ri­od. journalctl erbjuder al­ter­na­ti­ven --since och --until, som kan användas för att begränsa posterna till en viss period. För att göra detta använder du tids­for­ma­tet YYYY-MM-DD HH:MM:SS. Kommandot för att visa alla logg­pos­ter mellan 1 januari 2023 kl. 12:00 och 2 januari 2023 kl. 12:00 ser ut så här:

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

Kom­bi­na­tio­nen av de två kom­man­do­na kan också filtrera för en kortare tids­pe­ri­od:

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

Al­ter­na­tivt kan du också utelämna delar av formatet. Om du till exempel vill visa alla poster från en viss tidpunkt:

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

journalctl känner också igen relativa värden som yesterday, today eller tomorrow. För att visa poster från igår, ange följande:

journalctl --since yesterday
bash

Hur man filtrerar efter med­de­lan­dets egen­ska­per

Att använda journalctl för att filtrera logg­pos­ter baserat på vikt eller innehåll är också extremt an­vänd­bart, eftersom det gör det möjligt att söka efter relevant in­for­ma­tion och fokusera på specifika aspekter av system­log­gar­na. Detta möjliggör bland annat effektiv fel­di­a­gnos, tidig upptäckt av sä­ker­hets­pro­blem och snabb pre­stan­daö­ver­vak­ning.

Filtrera efter prioritet

För att filtrera loggar med journalctl efter med­de­lan­dets viktighet kan du använda pri­o­ri­tets­ka­te­go­ri­er­na för logg­pos­ter. För att göra detta kan du använda antingen pri­o­ri­tets­nam­net eller mot­sva­ran­de numeriska värde. Ju lägre siffra, desto viktigare är med­de­lan­det:

  • 0: emerg (nödläge)
  • 1: alert (larm)
  • 2: kritisk (kritisk)
  • 3: err (fel)
  • 4: varning (varning)
  • 5: notice (notis)
  • 6: info (in­for­ma­tion)
  • 7: debug (fel­sök­ning)

Med­de­lan­den med en viss prioritet kan filtreras med hjälp av al­ter­na­ti­vet -p. Till exempel visar följande kommando endast logg­pos­ter med pri­o­ri­te­ten “err” (fel) och högre:

journalctl -p err
bash

Filtrera efter enhet

Att filtrera loggar efter enhet är an­vänd­bart för att fokusera på specifika tjänster eller processer. Dessa kan filtreras med hjälp av al­ter­na­ti­vet -u. Om du till exempel vill visa logg­pos­ter för Apache-webb­ser­vern anger du följande:

journalctl -u apache2
bash

Sökningen kan förfinas yt­ter­li­ga­re med hjälp av relativa tids­vär­den. För att avgöra om tjänsten redan har utförts idag kan du ange följande:

journalctl -u apache2 --since today
bash

journalctl kan slå samman da­ta­pos­ter från olika enheter. Om din Nginx-process till exempel är länkad till en PHP FPM-enhet kan deras poster slås samman kro­no­lo­giskt. Kommandot för detta är:

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

Filtrera efter process, användare eller grupp-ID

Jour­nalctl kan filtrera logg­pos­ter efter process-, användar- eller grupp-ID. Om du har det exakta PID-numret för den process du vill söka efter kan du använda al­ter­na­ti­vet _PID för att filtrera posterna. Om PID-numret till exempel är 8088 skulle kommandot se ut så här:

journalctl _PID=8088
bash

Al­ter­na­tivt kan du använda filtren _UID eller _GID för att visa alla poster som loggats av en viss användare eller grupp. Om din webb­ser­ver till exempel heter ”www-data” kan du hitta användar-ID:t genom att göra följande:

id -u www-data
33
bash

Jour­nalpos­ter­na kan filtreras med hjälp av ID:

journalctl _UID=33 --since today
bash

För att avgöra vilka grupp-ID-poster som har skapats kan du använda al­ter­na­ti­vet -F. Detta visar alla värden som har sparats för fältet Grupp-ID:

journalctl -F _GID
bash

Här är ett exempel på re­sul­ta­tet:

32
99
102
133
81
84
100
0
124
87
bash

Filtrera efter komponent

Fil­tre­ring efter komponent är an­vänd­bart för att kon­cen­tre­ra sig på specifika ap­pli­ka­tio­ner, tjänster eller processer. Kom­po­nent­fäl­tet används van­ligt­vis av olika tjänster eller pro­gram­va­ru­kom­po­nen­ter för att skilja ut specifik in­for­ma­tion i loggarna. Denna fil­tre­ring gör det möjligt att begränsa logg­pos­ter­na till en viss komponent, ap­pli­ka­tion eller tjäns­te­en­het. För att till exempel filtrera poster som in­ne­hål­ler den körbara filen bash, ange följande kommando:

journalctl /usr/bin/bash
bash

Visa kärn­med­de­lan­den

Att filtrera logg­pos­ter för kärn­med­de­lan­den med journalctl är ett effektivt sätt att analysera in­for­ma­tion om kärnans funktion i ett Linux-system. Kärn­med­de­lan­den kan ge in­di­ka­tio­ner på hård­va­ru­pro­blem, driv­ru­tins­kon­flik­ter eller andra system­hän­del­ser.

Kärn­med­de­lan­den som finns i utdata dmesg kan också filtreras från journalen. De kan visas med flaggorna `-k or ``:

journalctl -k
bash

Kärn­med­de­lan­den från den aktuella start­pro­ces­sen visas som standard. Du kan filtrera med­de­lan­den från en al­ter­na­tiv start med hjälp av de tidigare nämnda start­vals­flag­gor­na. Om du till exempel vill visa kärn­med­de­lan­den från de senaste fem start­pro­ces­ser­na anger du:

journalctl -k -b -5
bash

Ändra jour­nalvis­ning­en i Jour­nalctl

Genom att anpassa visningen i journalctl kan an­vän­dar­na söka igenom loggarna mer precist och snabbt extrahera in­for­ma­tion. An­vän­dar­na kan anpassa visningen så att loggdata för en viss period eller i realtid visas, vilket un­der­lät­tar snabb iden­ti­fi­e­ring av systemfel och problem.

Förkorta eller utöka ut­mat­ning­en

Du kan anpassa hur journalctl visar data genom att förkorta eller utöka utdata. Som standard visar journalctl hela posten i per­son­sö­ka­ren och kör dem på höger sida av skärmen. Utdata kan förkortas med al­ter­na­ti­vet --no-full:

journalctl --no-full
bash

Du kan utöka visningen med flaggan -a:

journalctl -a
bash

Ställ in journalctl till stan­dardut­gång

I journalctl visas loggut­da­ta som standard med hjälp av en sidvisare som less. Detta gör att an­vän­dar­na kan visa utdata stegvis, vilket gör det enklare för dem att navigera genom långa loggfiler. Det finns dock till­fäl­len då det är nöd­vän­digt att visa stan­dardut­da­ta från loggar. Så här gör du:

journalctl --no-pager
bash

Ställ in ut­da­ta­for­mat

journalctl erbjuder också al­ter­na­tiv för att anpassa ut­da­ta­for­ma­tet för loggar. För att göra detta kan du använda al­ter­na­ti­vet -o med re­spek­ti­ve for­ma­ti­den­ti­fi­e­ra­re. Om du till exempel vill skriva ut logg­pos­ter i JSON-format anger du följande kod:

journalctl -b -u nginx -o json
bash

Här är re­sul­ta­tet:

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

Följande format kan användas i Jour­nalctl:

  • cat: Visar endast med­de­lan­de­fäl­tet
  • export: Binärt format som är lämpligt för över­fö­ring eller lagring
  • json: Standard JSON med en post per rad
  • json-pretty: JSON for­ma­te­rat för bättre läsbarhet
  • json-sse: Inlindad JSON-for­ma­te­rad utdata som möjliggör tillägg av händelser som skickats av servern
  • short: Stan­dardut­da­ta i syslog-stil
  • short-iso: Stan­dard­for­mat för visning av ISO-8601-tids­stämp­lar
  • short-monotonic: Stan­dard­for­mat med monotona tids­stämp­lar
  • short-precise: Stan­dard­for­mat med mik­ro­se­kund­pre­ci­sion
  • verbose: Visar alla journalfält som är till­gäng­li­ga för re­spek­ti­ve post

Hur genomför journalctl aktiv pro­ces­sö­ver­vak­ning?

Under aktiv pro­ces­sö­ver­vak­ning med journalctl används kom­man­do­rads­pro­gram­met tail för att spåra loggar i realtid och visa de senaste posterna. Detta gör det enklare att övervaka system­hän­del­ser i realtid och reagera snabbt på problem.

Hur man visar aktuella loggar

Al­ter­na­ti­vet -n kan användas för att visa ett visst antal da­ta­pos­ter. Det fungerar på exakt samma sätt som tail -n. För att visa de senaste 10 posterna använder du följande kommando:

journalctl -n
bash

Du kan också ställa in antalet poster, t.ex. till 20:

journalctl -n 20
bash
Gå till huvudmeny