# Hvad er Journalctl, og hvad kan det? Journalctl er en effektiv løsning til administration og analyse af systemlogfiler i Linux-miljøer. Dette værktøj kan bruges til overvågning af systemaktiviteter, fejlfinding og logsporing i realtid, hvilket giver vigtig indsigt til effektiv diagnosticering af systemproblemer. ## Hvad er Journalctl? `journalctl` er et kraftfuldt værktøj til **at søge i og vise hændelseslogfiler** eller logfiler under Linux. Det er en central del af system- og tjenestestyringspakken systemd, som følger med mange moderne Linux-distributioner såsom Ubuntu, Fedora og Arch Linux. Navnet »journalctl« er en sammensætning af »journal« (log) og »ctl« (kontrol), hvilket henviser til, at kommandoen bruges til at styre og analysere logfiler. `journalctl` gør det nemmere at få adgang til systemloggen, som administreres af `systemd-journald`. Systemloggen er en samlet oversigt over meddelelser og hændelser, der opstår under driften af et Linux-system. I modsætning til traditionelle tekstbaserede logfiler giver `journalctl` en struktureret og effektiv måde at søge, filtrere og vise **logdata i realtid**. Dette kan hjælpe med at diagnosticere problemer eller overvåge systemets status. Til dette formål gemmer Journalctl **logfilerne i binært format**, da binære logfiler er mere kompakte og effektive end deres tekstbaserede modstykker. I betragtning af den store mængde loggede data muliggør dette en hurtigere og mere effektiv søgning efter specifikke hændelser eller oplysninger i logfilerne. Takket være deres strukturerede og krypterede karakter giver binære logfiler også øget sikkerhed i forhold til tekstbaserede logfiler, da deres format gør det vanskeligere at manipulere logdataene. ## Sådan justeres lagerpladsen til logfiler `journalctl` kan bruges til at begrænse og konfigurere den lagerplads, som logfiler optager på harddisken. Dette gøres via **indstillingerne for tjenesten systemd-journald**. Konfigurationsindstillingerne gemmes i filen `/etc/systemd/journald.conf`. Her finder du følgende poster: - `SystemMaxUse`: Begrænser lagerpladsen til logfiler i systemmappen - `RuntimeMaxUse`: Begrænser lagerpladsen til logfiler i det midlertidige bibliotek For at indstille hukommelsesgrænsen skal du tilføje følgende linjer eller ændre dem efter behov: ```bash [Journal] SystemMaxUse=50M RuntimeMaxUse=50M ``` Værdierne i dette eksempel (50M) kan ændres efter behov. Du kan også bruge andre enheder, f.eks. `K` (kilobyte), `M` (megabyte), `G` (gigabyte) eller `T` (terabyte). Når du har redigeret konfigurationsfilen, skal systemd-journald genstartes, for at ændringerne træder i kraft: ```bash sudo systemctl restart systemd-journald ``` Når du følger disse trin, bliver systemd-journald konfigureret til at begrænse diskpladsen til logfiler. Sørg for, at den valgte grænse er tilstrækkelig til at gemme vigtige logdata. Samtidig er det vigtigt at undgå at bruge for meget diskplads. Husk, at **ældre logfiler automatisk slettes**, når den tildelte diskplads er opbrugt. ### Vurder brugen af diskplads Inden du justerer lagerpladsen til logfiler, skal du kontrollere, hvor meget plads journalen i øjeblikket optager. Det gør du ved at bruge `--disk-usage`: ```bash journalctl --disk-usage ``` Her er et eksempel på, hvordan resultatet ser ud: ```bash Journals take up 8.0M on disk. ``` ### Slet gamle logposter Hvis Journal bruger for meget hukommelse, kan du slette gamle logposter. Der er to måder at gøre det på: Brug `--vacuum-size` til at reducere journalens størrelse ved at angive den ønskede størrelse. Med denne metode slettes gamle poster, indtil den samlede plads, som journalen optager på harddisken, har nået den ønskede størrelse. ```bash sudo journalctl --vacuum-size=1G ``` Du kan også reducere logfilen ved at angive en opbevaringsperiode med indstilling `--vacuum-time`. Indtastninger, der er ældre end den angivne periode, slettes. Hvis du vil beholde logindtastninger fra det seneste år, kan du bruge følgende kommando: ```bash sudo journalctl --vacuum-time=1years ``` ## Hvad kan Journalctl? `journalctl` tilbyder avancerede filtreringsfunktioner, der giver brugerne mulighed for at gennemgå **logposter ud fra forskellige kriterier**. Denne funktion gør det muligt at foretage målrettede søgninger efter relevante oplysninger, hvilket gør det nemmere at identificere problemer hurtigere. Her er nogle af de mest anvendte `journalctl` filterindstillinger: ### Vis logfiler Når du udfører kommandoen `journalctl`, vises logposter for det aktuelle system i omvendt kronologisk rækkefølge. Brug `journalctl -f` eller `journalctl --follow` for at få vist posterne **i realtid**. Nye poster vises automatisk i den rækkefølge, de modtages. Afhængigt af hvor længe systemd har kørt på dit system, vil du sandsynligvis blive præsenteret for en uoverskuelig mængde data, der kan bestå af titusinder eller hundreder af tusinder af linjer. For at finde det, du leder efter, hurtigere, kan du filtrere logfilerne yderligere ved hjælp af forskellige Linux-kommandoer. ## Sådan filtrerer du efter tid Ved hjælp af `journalctl` kan logfiler filtreres efter et bestemt tidspunkt, så man lettere kan finde relevante oplysninger. ### Filtrer efter opstartsproces Filtrering af logfiler efter opstartsprocessen er uvurderlig, når man skal undersøge systemhændelser på bestemte tidspunkter eller under forskellige opstartsscenarier. Denne målrettede tilgang gør fejlfinding mere effektiv ved at indsnævre logposterne til bestemte systemtilstande eller konfigurationer. 1. **Nuværende opstart**: Med `journalctl -b` vises alle logposter, der er indsamlet siden den sidste genstart. 2. **Tidligere opstarter**: Brug indstillingen `-b` efterfulgt af et tal for at vise logposterne for en bestemt tidligere opstart. Hvis du f.eks. indtaster `journalctl -b 1`, vises den forrige opstart. 3. **Liste over alle tilgængelige opstartsprocesser**: Kommandoen `journalctl --list-boots` viser en liste over tilgængelige opstarter med deres respektive ID’er. Du kan bruge det ønskede opstarts-ID til at vise logfilerne for en bestemt opstart. Selvom lagring af tidligere opstartsprocesser er aktiveret som standard i nogle Linux-distributioner, kan det være nødvendigt for brugerne **først at aktivere** funktionen i andre. For at gøre dette skal du oprette et bibliotek, hvor loggen skal gemmes, ved at indtaste `sudo mkdir -p /var/log/journal`. Alternativt kan du redigere journalens konfigurationsfil med `sudo nano /etc/systemd/journald.conf`. Indstil derefter indstillingen `Storage=` under `[Journal]` til `persistent` for at aktivere vedvarende logning: ```bash . . . [Journal] Storage=persistent ``` ### Filtrer efter tidsinterval Nogle gange kan det være nødvendigt at vise logposter for en bestemt periode. `journalctl` tilbyder indstillingerne `--since` og `--until`, som kan bruges til at begrænse posterne til en **bestemt periode**. Til dette formål skal du bruge tidsformatet `YYYY-MM-DD HH:MM:SS`. Kommandoen til at vise alle logposter mellem den 1. januar 2023 kl. 12:00 og den 2. januar 2023 kl. 12:00 ser således ud: ```bash journalctl --since "2023-01-01 12:00:00" --until "2023-01-02 12:00:00" ``` Ved at kombinere de to kommandoer kan man også filtrere efter en kortere periode: ```bash journalctl --since 09:00 --until "1 hour ago" ``` Du kan også vælge at udelade dele af formatet. Hvis du f.eks. vil vise alle poster fra et bestemt tidspunkt: ```bash journalctl --since "2023-11-16 15:25:00" ``` `journalctl` genkender også relative værdier som f.eks. `yesterday`, `today` eller `tomorrow`. For at få vist poster fra i går skal du indtaste følgende: ```bash journalctl --since yesterday ``` ## Sådan filtrerer du efter meddelelseskarakteristika Det er også yderst nyttigt at bruge `journalctl` til at filtrere logposter efter vigtighed eller indhold, da det giver dig mulighed for **at søge efter relevante oplysninger og fokusere på bestemte aspekter af systemlogfilerne**. Dette muliggør blandt andet effektiv fejlfinding, tidlig opdagelse af sikkerhedsproblemer og hurtig overvågning af systemets ydeevne. ### Filtrer efter prioritet For at filtrere logfiler med `journalctl` efter meddelelsens vigtighed kan du bruge **prioritetskategorierne for logposter**. Du kan enten bruge prioritetsnavnet eller den tilhørende numeriske værdi. Jo lavere tallet er, desto vigtigere er meddelelsen: - 0: emerg (nødsituation) - 1: alert (alarm) - 2: kritisk - 3: fejl (fejl) - 4: warning (advarsel) - 5: notice (bemærkning) - 6: info (information) - 7: debug (fejlfinding) Meddelelser med en bestemt prioritet kan filtreres ved hjælp af indstillingen `-p`. F.eks. viser følgende kommando kun logposter med prioriteten »err« (fejl) og højere: ```bash journalctl -p err ``` ### Filtrer efter enhed Det er nyttigt at filtrere logfiler efter enhed, hvis man vil fokusere på bestemte tjenester eller processer. Disse kan filtreres ved hjælp af indstillingen `-u`. Hvis du f.eks. vil vise logposter for Apache-webserveren, skal du indtaste følgende: ```bash journalctl -u apache2 ``` Søgningen kan yderligere indsnævres ved hjælp af relative tidsangivelser. For at finde ud af, om tjenesten allerede er blevet udført i dag, kan du indtaste følgende: ```bash journalctl -u apache2 --since today ``` `journalctl` kan sammenflette dataposter fra forskellige enheder. Hvis din Nginx-proces f.eks. er knyttet til en PHP FPM-enhed, kan deres poster sammenflettes i kronologisk rækkefølge. Kommandoen til dette er: ```bash journalctl -u nginx.service -u php-fpm.service --since today-u apache2 --since today ``` ### Filtrer efter proces-, bruger- eller gruppe-ID Journalctl kan filtrere logposter efter proces-, bruger- eller gruppe-ID. Hvis du kender det **nøjagtige PID for den proces**, du vil søge efter, kan du bruge optionen `_PID` til at filtrere posterne. Hvis PID’et f.eks. er 8088, vil kommandoen se således ud: ```bash journalctl _PID=8088 ``` Du kan også bruge filtrene `_UID` eller `_GID` til at vise alle poster, der er logget af en bestemt bruger eller gruppe. Hvis din webserver f.eks. hedder »www-data«, kan du finde bruger-ID’et ved at gøre følgende: ```bash id -u www-data 33 ``` Journalposterne kan filtreres ved hjælp af ID’et: ```bash journalctl _UID=33 --since today ``` For at se, hvilke gruppe-ID’er der er oprettet poster for, kan du bruge indstilling `-F`. Dette viser alle de værdier, der er gemt i feltet »Gruppe-ID«: ```bash journalctl -F _GID ``` Her er et eksempel på resultatet: ```bash 32 99 102 133 81 84 100 0 124 87 ``` ### Filtrer efter komponent Filtrering efter komponent er nyttigt, når man ønsker at fokusere på bestemte applikationer, tjenester eller processer. Komponentfeltet bruges typisk af **forskellige tjenester eller softwarekomponenter** til at udskille specifikke oplysninger i logfilerne. Denne filtrering gør det muligt at indsnævre logposterne til en bestemt komponent, applikation eller tjenesteenhed. Hvis du f.eks. vil filtrere poster, der indeholder den eksekverbare fil `bash`, skal du indtaste følgende kommando: ```bash journalctl /usr/bin/bash ``` ### Vis kernebeskeder Filtrering af logposter efter kernelmeldinger med `journalctl` er en effektiv metode til at analysere oplysninger om kernens drift i et Linux-system. Kernelmeldinger kan give **en indikation af hardwareproblemer, driverkonflikter eller andre systemhændelser**. Kernelmeddelelser, der findes i `dmesg` -udskriften, kan også filtreres fra journalen. De kan vises med flagene `-k or ``: ```bash journalctl -k ``` Kernelmeddelelserne fra den aktuelle opstartsproces vises som standard. Du kan filtrere efter meddelelser fra en **alternativ opstart** ved hjælp af de tidligere nævnte flag til valg af opstart. Hvis du f.eks. vil se kernelmeddelelserne fra de sidste fem opstartsprocesser, skal du indtaste: ```bash journalctl -k -b -5 ``` ## Ændring af journalvisningen i Journalctl Ved at tilpasse visningen i `journalctl` kan brugerne søge mere præcist i logfilerne og hurtigt udtrække oplysninger. Brugerne kan tilpasse visningen, så den viser logdata for en bestemt periode eller i realtid, hvilket gør det lettere at identificere systemfejl og problemer hurtigt. ### At forkorte eller udvide udskriften Du kan tilpasse, hvordan `journalctl` viser data, ved at forkorte eller udvide udskriften. Som standard viser `journalctl` hele indtastningen i pageren og placerer den i højre side af skærmen. Udskriften kan forkortes med `--no-full`: ```bash journalctl --no-full ``` Du kan udvide visningen ved hjælp af flagget `-a`: ```bash journalctl -a ``` ### Indstil `journalctl` til standardudgangen I `journalctl` vises logudskriften som standard ved hjælp af et pager-program som `less`. Dette giver brugerne mulighed for at se udskriften i små dele, hvilket gør det nemmere at navigere gennem lange logfiler. Der er dog tilfælde, hvor det er nødvendigt at vise logfilernes standardudskrift. Sådan gør du: ```bash journalctl --no-pager ``` ### Indstil outputformater `journalctl` giver også mulighed for at tilpasse logfilernes outputformat. Til dette formål kan du bruge `-o` sammen med den relevante formatkode. Hvis du f.eks. vil udskrive logposter i JSON-format, skal du indtaste følgende kode: ```bash journalctl -b -u nginx -o json ``` Her er resultatet: ```bash { "__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ølgende formater kan bruges i Journalctl: - **cat**: Viser kun meddelelsesfeltet - **eksport**: Binært format, der er egnet til overførsel eller gemning - **json**: Standard JSON med én post pr. linje - **json-pretty**: JSON formateret for bedre læsbarhed - **json-sse**: Indpakket JSON-formateret output, der tillader tilføjelse af begivenheder sendt af serveren - **short**: Standardudskrift i syslog-stil - **short-iso**: Standardformat til visning af ISO-8601-tidsstempler - **short-monotonic**: Standardformat med monotone tidsstempler - **short-precise**: Standardformat med mikrosekundpræcision - **verbose**: Viser alle journalfelter, der er tilgængelige for den pågældende post ## Hvordan foretager `journalctl` aktiv procesovervågning? Under aktiv procesovervågning med `journalctl` bruges kommandolinjeprogrammet `tail` til at følge logfilerne i realtid og vise de seneste poster. Dette gør det nemmere at overvåge systemhændelser i realtid og reagere hurtigt på problemer. ## Sådan vises aktuelle logfiler Indstillingen `-n` kan bruges til at vise et bestemt antal dataposter. Den fungerer på nøjagtig samme måde som `tail -n`. For at vise de sidste 10 poster skal du bruge følgende kommando: ```bash journalctl -n ``` Du kan også indstille antallet af poster, f.eks. til 20: ```bash journalctl -n 20 ``` This is a markdown version of: [https://www.ionos.com/da-dk/digitalguide/server/vaerktoejer/journalctl/](https://www.ionos.com/da-dk/digitalguide/server/vaerktoejer/journalctl/) for AI/LLM consumption.