Vad är Journalctl och vad kan det göra?

Journalctl är en effektiv lösning för hantering och analys av systemloggar i Linux-miljöer. Detta verktyg kan användas för övervakning av systemaktiviteter, felsökning och loggspårning i realtid, vilket ger viktiga insikter för effektiv diagnostik av systemproblem.

Vad är Journalctl?

journalctl är ett kraftfullt verktyg för att söka och visa händelseloggar eller loggfiler under Linux. Det är en central komponent i system- och tjänstehanteringspaketet systemd, som ingår i många moderna Linux-distributioner såsom Ubuntu, Fedora och Arch Linux. Namnet ”journalctl” är en blandning av ”journal” (logg) och ”ctl” (kontroll), vilket hänvisar till det faktum att kommandot används för att kontrollera och analysera loggar.

journalctl förenklar åtkomsten till systemloggen, som hanteras av systemd-journald. Systemloggen är en centraliserad samling av meddelanden och händelser som inträffar under driften av ett Linux-system. Till skillnad från traditionella textbaserade loggar erbjuder journalctl ett strukturerat och effektivt sätt att söka, filtrera och visa loggdata i realtid. Detta kan hjälpa till att diagnostisera problem eller övervaka systemstatus.

För detta ändamål sparar Journalctl loggfilerna i binärt format, eftersom binära loggfiler är mer kompakta och effektiva än sina textbaserade motsvarigheter. Med tanke på den stora mängden loggade data möjliggör detta en snabbare och effektivare sökning efter specifika händelser eller information i loggfilerna. Med sin strukturerade och krypterade karaktär ger binära loggfiler också förbättrad säkerhet jämfört med textbaserade loggar, eftersom deras format gör det svårare att manipulera loggdata.

Hur man justerar lagringsutrymmet för loggfiler

journalctl kan användas för att begränsa och konfigurera lagringsutrymmet som loggfilerna upptar på hårddisken. Detta görs via inställningarna för tjänsten systemd-journald. Konfigurationsinställningarna lagras i filen /etc/systemd/journald.conf. Här hittar du följande poster:

• SystemMaxUse: Begränsar lagringsutrymmet för loggar i systemkatalogen
• RuntimeMaxUse: Begränsar lagringsutrymmet för loggar i den tillfälliga katalogen

För att ställa in minnesgränsen, lägg till följande rader eller ändra dem efter behov:

[Journal] 
SystemMaxUse=50M 
RuntimeMaxUse=50M

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 konfigurationsfilen måste systemd-journald startas om för att ändringarna ska träda i kraft:

sudo systemctl restart systemd-journald

Om du följer dessa steg kommer systemd-journald att konfigureras så att det begränsar diskutrymmet för loggfiler. Se till att den gräns du väljer är tillräcklig för att lagra viktiga loggdata. Samtidigt är det viktigt att undvika att använda för mycket diskutrymme. Tänk på att äldre loggar automatiskt tas bort när gränsen för tilldelat diskutrymme har nåtts.

Utvärdera diskutrymmesanvändningen

Innan du justerar lagringsutrymmet för loggfiler, kontrollera hur mycket lagringsutrymme som för närvarande upptas av journalen. För att göra detta, använd --disk-usage:

journalctl --disk-usage

Här är ett exempel på hur resultatet ser ut:

Journals take up 8.0M on disk.

Ta bort gamla loggposter

Om Journal tar upp för mycket minne kan du radera gamla loggposter. 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 lagringsutrymmet för journalen på hårddisken har nått önskad storlek.

sudo journalctl --vacuum-size=1G

Alternativt kan du minska storleken på loggen genom att ange en lagringstid med alternativet --vacuum-time. Poster som är äldre än den angivna tiden kommer att raderas. För att behålla loggposter från det senaste året kan du använda följande kommando:

sudo journalctl --vacuum-time=1years

Vad kan Journalctl göra?

journalctl erbjuder kraftfulla filtreringsfunktioner som gör det möjligt för användare att söka igenom loggposter utifrån olika kriterier. Denna funktion möjliggör riktade sökningar efter relevant information, vilket underlättar snabbare problemidentifiering. Här är några vanliga journalctl filteralternativ:

Visa loggar

Genom att utföra kommandot journalctl visas loggposter för det aktuella systemet i omvänd kronologisk ordning. Använd journalctl -f eller journalctl --follow för att visa posterna i realtid. Nya poster visas automatiskt 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 ohanterlig mängd data, som kan vara tiotusentals eller hundratusentals rader lång. För att snabbare hitta det du letar efter kan du filtrera loggarna ytterligare 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 information.

Filtrera efter startprocess

Att filtrera loggar efter startprocessen är ovärderligt för att undersöka systemhändelser vid exakta tidpunkter eller under startscenarier. Denna målinriktade metod effektiviserar problemdiagnostiken genom att fokusera loggposter på specifika systemstatusar eller konfigurationer.

1. Aktuell uppstart: Med journalctl -b visas alla loggposter som har samlats in sedan senaste omstarten.
2. Tidigare uppstart: Använd alternativet -b följt av ett nummer för att visa loggposterna för en specifik tidigare uppstart. Om du till exempel anger journalctl -b 1 visas den tidigare uppstarten.
3. Lista över alla tillgängliga startprocesser: Kommandot journalctl --list-boots visar en lista över tillgängliga starter med respektive ID. Du kan använda önskat start-ID för att visa loggarna för en specifik start.

Även om sparandet av tidigare startprocesser är aktiverat som standard i vissa Linux-distributioner, 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. Alternativt kan du redigera journalens konfigurationsfil med sudo nano /etc/systemd/journald.conf. Ställ sedan in alternativet Storage= under [Journal] till persistent för att aktivera permanent loggning:

. . . 
[Journal] 
Storage=persistent

Filtrera efter tidsfönster

Ibland kan det vara nödvändigt att visa loggposter för en viss tidsperiod. journalctl erbjuder alternativen --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 tidsformatet YYYY-MM-DD HH:MM:SS. Kommandot för att visa alla loggposter 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"

Kombinationen av de två kommandona kan också filtrera för en kortare tidsperiod:

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

Alternativt 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"

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

Hur man filtrerar efter meddelandets egenskaper

Att använda journalctl för att filtrera loggposter baserat på vikt eller innehåll är också extremt användbart, eftersom det gör det möjligt att söka efter relevant information och fokusera på specifika aspekter av systemloggarna. Detta möjliggör bland annat effektiv feldiagnos, tidig upptäckt av säkerhetsproblem och snabb prestandaövervakning.

Filtrera efter prioritet

För att filtrera loggar med journalctl efter meddelandets viktighet kan du använda prioritetskategorierna för loggposter. För att göra detta kan du använda antingen prioritetsnamnet eller motsvarande numeriska värde. Ju lägre siffra, desto viktigare är meddelandet:

• 0: emerg (nödläge)
• 1: alert (larm)
• 2: kritisk (kritisk)
• 3: err (fel)
• 4: varning (varning)
• 5: notice (notis)
• 6: info (information)
• 7: debug (felsökning)

Meddelanden med en viss prioritet kan filtreras med hjälp av alternativet -p. Till exempel visar följande kommando endast loggposter med prioriteten “err” (fel) och högre:

journalctl -p err

Filtrera efter enhet

Att filtrera loggar efter enhet är användbart för att fokusera på specifika tjänster eller processer. Dessa kan filtreras med hjälp av alternativet -u. Om du till exempel vill visa loggposter för Apache-webbservern anger du följande:

journalctl -u apache2

Sökningen kan förfinas ytterligare med hjälp av relativa tidsvärden. För att avgöra om tjänsten redan har utförts idag kan du ange följande:

journalctl -u apache2 --since today

journalctl kan slå samman dataposter från olika enheter. Om din Nginx-process till exempel är länkad till en PHP FPM-enhet kan deras poster slås samman kronologiskt. Kommandot för detta är:

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

Filtrera efter process, användare eller grupp-ID

Journalctl kan filtrera loggposter 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 alternativet _PID för att filtrera posterna. Om PID-numret till exempel är 8088 skulle kommandot se ut så här:

journalctl _PID=8088

Alternativt 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 webbserver till exempel heter ”www-data” kan du hitta användar-ID:t genom att göra följande:

id -u www-data
33

Journalposterna kan filtreras med hjälp av ID:

journalctl _UID=33 --since today

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

journalctl -F _GID

Här är ett exempel på resultatet:

32
99
102
133
81
84
100
0
124
87

Filtrera efter komponent

Filtrering efter komponent är användbart för att koncentrera sig på specifika applikationer, tjänster eller processer. Komponentfältet används vanligtvis av olika tjänster eller programvarukomponenter för att skilja ut specifik information i loggarna. Denna filtrering gör det möjligt att begränsa loggposterna till en viss komponent, applikation eller tjänsteenhet. För att till exempel filtrera poster som innehåller den körbara filen bash, ange följande kommando:

journalctl /usr/bin/bash

Visa kärnmeddelanden

Att filtrera loggposter för kärnmeddelanden med journalctl är ett effektivt sätt att analysera information om kärnans funktion i ett Linux-system. Kärnmeddelanden kan ge indikationer på hårdvaruproblem, drivrutinskonflikter eller andra systemhändelser.

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

journalctl -k

Kärnmeddelanden från den aktuella startprocessen visas som standard. Du kan filtrera meddelanden från en alternativ start med hjälp av de tidigare nämnda startvalsflaggorna. Om du till exempel vill visa kärnmeddelanden från de senaste fem startprocesserna anger du:

journalctl -k -b -5

Ändra journalvisningen i Journalctl

Genom att anpassa visningen i journalctl kan användarna söka igenom loggarna mer precist och snabbt extrahera information. Användarna kan anpassa visningen så att loggdata för en viss period eller i realtid visas, vilket underlättar snabb identifiering av systemfel och problem.

Förkorta eller utöka utmatningen

Du kan anpassa hur journalctl visar data genom att förkorta eller utöka utdata. Som standard visar journalctl hela posten i personsökaren och kör dem på höger sida av skärmen. Utdata kan förkortas med alternativet --no-full:

journalctl --no-full

Du kan utöka visningen med flaggan -a:

journalctl -a

Ställ in journalctl till standardutgång

I journalctl visas loggutdata som standard med hjälp av en sidvisare som less. Detta gör att användarna kan visa utdata stegvis, vilket gör det enklare för dem att navigera genom långa loggfiler. Det finns dock tillfällen då det är nödvändigt att visa standardutdata från loggar. Så här gör du:

journalctl --no-pager

Ställ in utdataformat

journalctl erbjuder också alternativ för att anpassa utdataformatet för loggar. För att göra detta kan du använda alternativet -o med respektive formatidentifierare. Om du till exempel vill skriva ut loggposter i JSON-format anger du följande kod:

journalctl -b -u nginx -o json

Här är resultatet:

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

Följande format kan användas i Journalctl:

• cat: Visar endast meddelandefältet
• export: Binärt format som är lämpligt för överföring eller lagring
• json: Standard JSON med en post per rad
• json-pretty: JSON formaterat för bättre läsbarhet
• json-sse: Inlindad JSON-formaterad utdata som möjliggör tillägg av händelser som skickats av servern
• short: Standardutdata i syslog-stil
• short-iso: Standardformat för visning av ISO-8601-tidsstämplar
• short-monotonic: Standardformat med monotona tidsstämplar
• short-precise: Standardformat med mikrosekundprecision
• verbose: Visar alla journalfält som är tillgängliga för respektive post

Hur genomför journalctl aktiv processövervakning?

Under aktiv processövervakning med journalctl används kommandoradsprogrammet tail för att spåra loggar i realtid och visa de senaste posterna. Detta gör det enklare att övervaka systemhändelser i realtid och reagera snabbt på problem.

Hur man visar aktuella loggar

Alternativet -n kan användas för att visa ett visst antal dataposter. 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

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

journalctl -n 20