# Hva er Journalctl, og hva kan det brukes til? Journalctl er en effektiv løsning for administrasjon og analyse av systemlogger i Linux-miljøer. Dette verktøyet kan brukes til overvåking av systemaktiviteter, feilsøking og loggsporing i sanntid, og gir viktig informasjon for effektiv diagnostisering av systemproblemer. ## Hva er Journalctl? `journalctl` er et kraftig verktøy for **å søke i og vise hendelseslogger** eller loggfiler under Linux. Det er en sentral komponent i system- og tjenestestyringspakken systemd, som følger med mange moderne Linux-distribusjoner som Ubuntu, Fedora og Arch Linux. Navnet «journalctl» er en sammensetning av «journal» (logg) og «ctl» (kontroll), noe som henviser til at kommandoen brukes til å kontrollere og analysere logger. `journalctl` gjør det enklere å få tilgang til systemloggen, som administreres av `systemd-journald`. Systemloggen er en sentralisert samling av meldinger og hendelser som oppstår under driften av et Linux-system. I motsetning til tradisjonelle tekstbaserte logger gir `journalctl` en strukturert og effektiv måte å søke, filtrere og vise **loggdata i sanntid på**. Dette kan bidra til å diagnostisere problemer eller overvåke systemstatusen. For dette formålet lagrer Journalctl **loggfilene i binært format**, ettersom binære loggfiler er mer kompakte og effektive enn deres tekstbaserte motstykker. Gitt den store mengden loggdata gjør dette det mulig å søke raskere og mer effektivt etter bestemte hendelser eller opplysninger i loggfilene. Takket være sin strukturerte og krypterte natur gir binære loggfiler også økt sikkerhet sammenlignet med tekstbaserte logger, siden formatet gjør det vanskeligere å manipulere loggdataene. ## Slik justerer du lagringsplassen for loggfiler `journalctl` kan brukes til å begrense og konfigurere lagringsplassen som loggfilene opptar på harddisken. Dette gjøres via **innstillingene for tjenesten systemd-journald**. Konfigurasjonsinnstillingene lagres i filen `/etc/systemd/journald.conf`. Her finner du følgende oppføringer: - `SystemMaxUse`: Begrenser lagringsplassen for loggfiler i systemkatalogen - `RuntimeMaxUse`: Begrenser lagringsplassen for logger i den midlertidige katalogen For å angi minnegrensen, legg til følgende linjer eller endre dem etter behov: ```bash [Journal] SystemMaxUse=50M RuntimeMaxUse=50M ``` Verdiene i dette eksemplet (50M) kan endres etter behov. Du kan også bruke andre enheter, for eksempel `K` (kilobyte), `M` (megabyte), `G` (gigabyte) eller `T` (terabyte). Når du har redigert konfigurasjonsfilen, må systemd-journald startes på nytt for at endringene skal tre i kraft: ```bash sudo systemctl restart systemd-journald ``` Ved å følge disse trinnene vil systemd-journald bli konfigurert til å begrense diskplassen for loggfiler. Sørg for at grensen du velger er stor nok til å lagre viktige loggdata. Samtidig er det viktig å unngå å bruke for mye diskplass. Husk at **eldre logger fjernes automatisk** når grensen for den tildelte diskplassen er nådd. ### Vurdere bruken av diskplass Før du justerer lagringsplassen for loggfiler, bør du sjekke hvor mye lagringsplass journalen opptar for øyeblikket. For å gjøre dette, bruk `--disk-usage`: ```bash journalctl --disk-usage ``` Her er et eksempel på hvordan resultatet ser ut: ```bash Journals take up 8.0M on disk. ``` ### Slett gamle loggoppføringer Hvis Journal bruker for mye minne, kan du slette gamle loggoppføringer. Det finnes to måter å gjøre dette på: Bruk `--vacuum-size` for å redusere størrelsen på loggfilen ved å angi størrelsen. Med denne metoden slettes gamle oppføringer inntil den totale lagringsplassen som loggfilen opptar på harddisken, har nådd den ønskede størrelsen. ```bash sudo journalctl --vacuum-size=1G ``` Alternativt kan du redusere loggfilens størrelse ved å angi en oppbevaringsperiode ved hjelp av alternativ `--vacuum-time`. Oppføringer som er eldre enn den angitte tiden, vil bli slettet. For å beholde loggoppføringer fra det siste året kan du bruke følgende kommando: ```bash sudo journalctl --vacuum-time=1years ``` ## Hva kan Journalctl gjøre? `journalctl` har kraftige filtreringsfunksjoner som lar brukerne sortere **loggoppføringer etter ulike kriterier**. Denne funksjonen gjør det mulig å søke målrettet etter relevant informasjon, noe som bidrar til raskere problemidentifisering. Her er noen vanlige `journalctl` filteralternativer: ### Vis logger Når du utfører kommandoen `journalctl`, vises loggoppføringene for det aktuelle systemet i omvendt kronologisk rekkefølge. Bruk `journalctl -f` eller `journalctl --follow` for å vise oppføringene **i sanntid**. Nye oppføringer vises automatisk i den rekkefølgen de kommer inn. Avhengig av hvor lenge systemd har kjørt på systemet ditt, vil du sannsynligvis få opp en uoversiktlig mengde data, som kan bestå av titusenvis eller hundretusenvis av linjer. For å finne det du leter etter raskere, kan du filtrere loggene ytterligere ved hjelp av ulike Linux-kommandoer. ## Slik filtrerer du etter tid Ved å bruke `journalctl` kan loggene filtreres etter et bestemt tidspunkt, slik at man lettere kan finne relevant informasjon. ### Filtrer etter oppstartsprosess Å filtrere logger etter oppstartsprosessen er uvurderlig når man skal undersøke systemhendelser på bestemte tidspunkter eller under ulike oppstartsscenarier. Denne målrettede tilnærmingen effektiviserer feilsøkingen ved å fokusere loggoppføringene på bestemte systemtilstander eller konfigurasjoner. 1. **Nåværende oppstart**: Med `journalctl -b` vises alle loggoppføringer som er samlet inn siden forrige omstart. 2. **Tidligere oppstarter**: Bruk alternativet `-b` etterfulgt av et tall for å vise loggoppføringene for en bestemt tidligere oppstart. Hvis du for eksempel skriver inn `journalctl -b 1`, vises den forrige oppstarten. 3. **Liste over alle tilgjengelige oppstartsprosesser**: Kommandoen `journalctl --list-boots` viser en liste over tilgjengelige oppstarter med deres respektive ID-er. Du kan bruke ønsket oppstarts-ID for å vise loggene for en bestemt oppstart. Selv om lagring av tidligere oppstartsprosesser er aktivert som standard i noen Linux-distribusjoner, kan det hende at brukerne **først** må **aktivere** den i andre. For å gjøre dette oppretter du en katalog der loggen skal lagres ved å skrive inn `sudo mkdir -p /var/log/journal`. Alternativt kan du redigere konfigurasjonsfilen for journalen med `sudo nano /etc/systemd/journald.conf`. Deretter angir du alternativet `Storage=` under `[Journal]` til `persistent` for å aktivere permanent loggføring: ```bash . . . [Journal] Storage=persistent ``` ### Filtrer etter tidsvindu Noen ganger kan det være nødvendig å vise loggoppføringer for en bestemt tidsperiode. `journalctl` tilbyr alternativene `--since` og `--until`, som kan brukes til å begrense oppføringene til en **bestemt periode**. For å gjøre dette, bruk tidsformatet `YYYY-MM-DD HH:MM:SS`. Kommandoen for å vise alle loggoppføringer mellom 1. januar 2023 kl. 12:00 og 2. januar 2023 kl. 12:00 ser slik ut: ```bash journalctl --since "2023-01-01 12:00:00" --until "2023-01-02 12:00:00" ``` Kombinasjonen av de to kommandoene kan også filtrere etter en kortere tidsperiode: ```bash journalctl --since 09:00 --until "1 hour ago" ``` Alternativt kan du også utelate deler av formatet. Hvis du for eksempel ønsker å vise alle oppføringer fra et bestemt tidspunkt: ```bash journalctl --since "2023-11-16 15:25:00" ``` `journalctl` gjenkjenner også relative verdier som `yesterday`, `today` eller `tomorrow`. For å vise oppføringer fra i går, skriv inn følgende: ```bash journalctl --since yesterday ``` ## Slik filtrerer du etter meldingsegenskaper Det er også svært nyttig å bruke `journalctl` til å filtrere loggoppføringer etter viktighet eller innhold, da dette gjør det mulig å **søke etter relevant informasjon og fokusere på bestemte deler av systemloggene**. Dette muliggjør blant annet effektiv feilsøking, tidlig oppdagelse av sikkerhetsproblemer og rask ytelsesovervåking. ### Filtrer etter prioritet For å filtrere logger med `journalctl` etter meldingens viktighet, kan du bruke **prioritetskategoriene for loggoppføringer**. Du kan enten bruke prioritetsnavnet eller den tilhørende numeriske verdien. Jo lavere tall, desto viktigere er meldingen: - 0: emerg (nødsituasjon) - 1: alert (alarm) - 2: kritisk - 3: feil (feil) - 4: warning (advarsel) - 5: notice (merknad) - 6: info (informasjon) - 7: feilsøking (feilsøking) Meldinger med en bestemt prioritet kan filtreres ved hjelp av alternativet `-p`. Følgende kommando viser for eksempel bare loggoppføringer med prioriteten «err» (feil) og høyere: ```bash journalctl -p err ``` ### Filtrer etter enhet Det er nyttig å filtrere logger etter enhet for å fokusere på bestemte tjenester eller prosesser. Disse kan filtreres ved hjelp av alternativ `-u`. Hvis du for eksempel vil vise loggoppføringer for Apache-webserveren, skriver du inn følgende: ```bash journalctl -u apache2 ``` Søket kan avgrenses ytterligere ved hjelp av relative tidsverdier. For å finne ut om tjenesten allerede er utført i dag, kan du skrive inn følgende: ```bash journalctl -u apache2 --since today ``` `journalctl` kan slå sammen dataposter fra ulike enheter. Hvis for eksempel Nginx-prosessen din er koblet til en PHP FPM-enhet, kan oppføringene deres slås sammen i kronologisk rekkefølge. Kommandoen for dette er: ```bash journalctl -u nginx.service -u php-fpm.service --since today-u apache2 --since today ``` ### Filtrer etter prosess-, bruker- eller gruppe-ID Journalctl kan filtrere loggoppføringer etter prosess-, bruker- eller gruppe-ID. Hvis du har den **eksakte PID-en til prosessen** du vil søke etter, kan du bruke alternativet `_PID` til å filtrere oppføringene. Hvis PID-en for eksempel er 8088, vil kommandoen se slik ut: ```bash journalctl _PID=8088 ``` Alternativt kan du bruke filtrene `_UID` eller `_GID` for å vise alle oppføringer som er logget av en bestemt bruker eller gruppe. Hvis webserveren din for eksempel heter «www-data», kan du finne bruker-ID-en ved å gjøre følgende: ```bash id -u www-data 33 ``` Journalpostene kan filtreres ved hjelp av ID-en: ```bash journalctl _UID=33 --since today ``` For å finne ut hvilke gruppe-ID-er oppføringene er opprettet for, kan du bruke alternativ `-F`. Dette viser alle verdiene som er lagret 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 etter komponent Filtrering etter komponent er nyttig for å fokusere på bestemte applikasjoner, tjenester eller prosesser. Komponentfeltet brukes vanligvis av **ulike tjenester eller programvarekomponenter** for å skille ut bestemt informasjon i loggene. Denne filtreringen gjør det mulig å begrense loggoppføringene til en bestemt komponent, applikasjon eller tjenesteenhet. Hvis du for eksempel vil filtrere oppføringer som inneholder den kjørbare filen `bash`, skriver du inn følgende kommando: ```bash journalctl /usr/bin/bash ``` ### Vis kjernemeldinger Å filtrere loggoppføringer etter kjernemeldinger med `journalctl` er en effektiv måte å analysere informasjon om kjernens drift i et Linux-system på. Kjernemeldinger kan gi **indikasjoner på maskinvareproblemer, driverkonflikter eller andre systemhendelser**. Kjernemeldinger som finnes i `dmesg`, kan også filtreres ut fra journalen. De kan vises med flaggene `-k or ``: ```bash journalctl -k ``` Kjernemeldingene fra den nåværende oppstartsprosessen vises som standard. Du kan filtrere etter meldinger fra en **alternativ oppstart** ved hjelp av de tidligere nevnte flaggene for oppstartsvalg. Hvis du for eksempel ønsker å se kjernemeldingene fra de fem siste oppstartsprosessene, skriver du inn: ```bash journalctl -k -b -5 ``` ## Endre visningen av loggen i Journalctl Ved å tilpasse visningen i `journalctl` kan brukerne søke mer presist i loggene og hente ut informasjon raskt. Brukerne kan tilpasse visningen slik at den viser loggdata for en bestemt periode eller i sanntid, noe som gjør det enklere å oppdage systemfeil og problemer raskt. ### Korte ned eller utvide utdataene Du kan tilpasse hvordan `journalctl` viser data ved å forkorte eller utvide utdataene. Som standard viser `journalctl` hele oppføringen i pageren og viser den på høyre side av skjermen. Utdataene kan forkortes med `--no-full`: ```bash journalctl --no-full ``` Du kan utvide visningen ved å bruke flagget `-a`: ```bash journalctl -a ``` ### Send `journalctl` til standardutdata I `journalctl` vises loggutdata som standard ved hjelp av et sidevisningsverktøy som `less`. Dette gjør at brukerne kan se utdataene trinnvis, noe som gjør det enklere å navigere gjennom lange loggfiler. Det kan imidlertid være tilfeller der det er nødvendig å vise standardutdataene fra loggene. Slik gjør du det: ```bash journalctl --no-pager ``` ### Angi utdataformater `journalctl` tilbyr også muligheter for å tilpasse utdataformatet for logger. For å gjøre dette kan du bruke `-o` sammen med den aktuelle formatidentifikatoren. Hvis du for eksempel vil skrive ut loggoppføringer i JSON-format, skriver du inn 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 brukes i Journalctl: - **cat**: Viser kun meldingsfeltet - **eksport**: Binært format egnet for overføring eller lagring - **json**: Standard JSON med én oppføring per linje - **json-pretty**: JSON-formatert for bedre lesbarhet - **json-sse**: Innpakket JSON-formatert utdata som tillater å legge til hendelser sendt av serveren - **short**: Standard utdata i syslog-stil - **short-iso**: Standardformat for visning av ISO-8601-tidsstempler - **short-monotonic**: Standardformat med monotone tidsstempler - **short-precise**: Standardformat med mikrosekundpresisjon - **verbose**: Viser alle journalfelt som er tilgjengelige for den respektive oppføringen ## Hvordan gjennomfører `journalctl` aktiv prosessovervåking? Under aktiv prosessovervåking med `journalctl` brukes kommandolinjeprogrammet `tail` til å spore logger i sanntid og vise de nyeste oppføringene. Dette gjør det enklere å overvåke systemhendelser i sanntid og reagere raskt på problemer. ## Slik viser du gjeldende logger Alternativet `-n` kan brukes til å vise et bestemt antall dataposter. Det fungerer på nøyaktig samme måte som `tail -n`. For å vise de 10 siste oppføringene, bruk følgende kommando: ```bash journalctl -n ``` Du kan også angi antall oppføringer, f.eks. til 20: ```bash journalctl -n 20 ``` This is a markdown version of: [https://www.ionos.com/nb-no/digitalguide/server/verktoey/journalctl/](https://www.ionos.com/nb-no/digitalguide/server/verktoey/journalctl/) for AI/LLM consumption.