Mikä on Jour­nalctl ja mihin sitä voidaan käyttää?

Jour­nalctl on tehokas ratkaisu jär­jes­tel­mä­lo­kien hal­lin­taan ja ana­ly­soin­tiin Linux-ym­pä­ris­töis­sä. Työkalua voidaan käyttää jär­jes­tel­män toiminnan seu­ran­taan, vian­mää­ri­tyk­seen ja lokien re­aa­liai­kai­seen seu­ran­taan, ja se tarjoaa tärkeää tietoa jär­jes­tel­mä­on­gel­mien te­hok­kaa­seen diag­no­soin­tiin.

Mikä on Jour­nalctl?

journalctl on tehokas apuoh­jel­ma ta­pah­tu­ma­lo­kien tai lo­ki­tie­dos­to­jen ha­ke­mi­seen ja näyt­tä­mi­seen Linux-ym­pä­ris­tös­sä. Se on keskeinen osa jär­jes­tel­mä- ja pal­ve­lun­hal­lin­taoh­jel­mis­toa systemd, joka sisältyy moniin ny­ky­ai­kai­siin Linux-ja­ke­lui­hin, kuten Ubuntuun, Fedoraan ja Arch Linuxiin. Nimi ”jour­nalctl” on yh­dis­tel­mä sanoista ”journal” (loki) ja ”ctl” (ohjaus), mikä viittaa siihen, että komentoa käytetään lokien hal­lin­taan ja ana­ly­soin­tiin.

journalctl helpottaa jär­jes­tel­mä­lo­kin käyttöä, jota hallinnoi systemd-journald. Jär­jes­tel­mä­lo­ki on kes­ki­tet­ty kokoelma viestejä ja ta­pah­tu­mia, jotka syntyvät Linux-jär­jes­tel­män käytön aikana. Toisin kuin pe­rin­tei­set teks­ti­poh­jai­set lokit, journalctl tarjoaa jä­sen­nel­lyn ja tehokkaan tavan hakea, suodattaa ja näyttää lo­ki­tie­to­ja re­aa­lia­jas­sa. Tämä voi auttaa ongelmien diag­no­soin­nis­sa tai jär­jes­tel­män tilan seu­ran­nas­sa.

Tätä varten Jour­nalctl tallentaa lo­ki­tie­dos­tot bi­nää­ri­muo­dos­sa, sillä bi­nää­ri­lo­ki­tie­dos­tot ovat tii­viim­piä ja te­hok­kaam­pia kuin vastaavat teks­ti­tie­dos­tot. Lo­ki­tie­to­jen suuren määrän vuoksi tämä mah­dol­lis­taa tiettyjen ta­pah­tu­mien tai tietojen nopeamman ja te­hok­kaam­man haun lo­ki­tie­dos­tois­ta. Ra­ken­teel­li­sen ja salatun luon­teen­sa ansiosta bi­nää­ri­lo­ki­tie­dos­tot tarjoavat myös paremman tie­to­tur­van kuin teks­ti­tie­dos­tot, sillä niiden muoto vai­keut­taa lo­ki­tie­to­jen ma­ni­pu­loin­tia.

Kuinka säätää lo­ki­tie­dos­to­jen tal­len­nus­ti­laa

journalctl avulla voidaan rajoittaa ja määrittää lo­ki­tie­dos­to­jen käyttämää tal­len­nus­ti­laa kiin­to­le­vyl­lä. Tämä tapahtuu systemd-journald-palvelun asetusten kautta. Mää­ri­tyk­set tal­len­ne­taan tie­dos­toon /etc/systemd/journald.conf. Siellä on seuraavat merkinnät:

• SystemMaxUse: Rajoittaa lo­ki­tie­dos­to­jen tal­len­nus­ti­laa jär­jes­tel­mä­ha­ke­mis­tos­sa
• RuntimeMaxUse: Rajoittaa lokien tal­len­nus­ti­laa vä­liai­kai­ses­sa ha­ke­mis­tos­sa

Määritä muistin enim­mäis­mää­rä li­sää­mäl­lä seuraavat rivit tai muok­kaa­mal­la niitä tarpeen mukaan:

[Journal] 
SystemMaxUse=50M 
RuntimeMaxUse=50M

Tämän esimerkin arvoja (50M) voi muokata tarpeen mukaan. Voit käyttää myös muita yksiköitä, kuten K (kilotavua), M (megatavua), G (gigatavua) tai T (teratavua). Kun olet muokannut ase­tus­tie­dos­toa, systemd-journald on käyn­nis­tet­tä­vä uudelleen, jotta muutokset astuvat voimaan:

sudo systemctl restart systemd-journald

Näiden ohjeiden avulla systemd-journald mää­ri­te­tään ra­joit­ta­maan lo­ki­tie­dos­to­jen levytilaa. Varmista, että va­lit­se­ma­si raja riittää vält­tä­mät­tö­mien lo­ki­tie­to­jen tal­len­ta­mi­seen. Samalla on tärkeää välttää liian suuren levytilan käyttöä. Muista, että vanhemmat lokit pois­te­taan au­to­maat­ti­ses­ti, kun varattu levytila on täyttynyt.

Arvioi levytilan käyttö

Ennen kuin säädät lo­ki­tie­dos­to­jen tal­len­nus­ti­laa, tarkista, kuinka paljon tilaa lo­ki­tie­dos­tot tällä hetkellä vievät. Voit tehdä tämän ko­men­nol­la --disk-usage:

journalctl --disk-usage

Tässä on esimerkki siitä, miltä tulos näyttää:

Journals take up 8.0M on disk.

Poista vanhat lo­ki­mer­kin­nät

Jos Journal vie liikaa muistia, voit poistaa vanhoja lo­ki­mer­kin­tö­jä. Tähän on kaksi tapaa:

Käytä --vacuum-size pie­nen­tääk­se­si lo­ki­tie­dos­ton kokoa mää­rit­tä­mäl­lä sen koon. Tällä me­ne­tel­mäl­lä vanhoja mer­kin­tö­jä pois­te­taan, kunnes lo­ki­tie­dos­ton käyttämä ko­ko­nais­ka­pa­si­teet­ti kiin­to­le­vyl­lä on saa­vut­ta­nut halutun koon.

sudo journalctl --vacuum-size=1G

Vaih­toeh­toi­ses­ti voit pienentää lo­ki­tie­dos­ton kokoa aset­ta­mal­la säi­ly­ty­sa­jan vaih­toeh­dol­la --vacuum-time. Mää­ri­tet­tyä aikaa vanhemmat merkinnät pois­te­taan. Jos haluat säilyttää viimeisen vuoden lo­ki­mer­kin­nät, voit käyttää seuraavaa komentoa:

sudo journalctl --vacuum-time=1years

Mitä Jour­nalctl pystyy tekemään?

journalctl tarjoaa tehokkaat suo­da­tuso­mi­nai­suu­det, joiden avulla käyttäjät voivat lajitella lo­ki­mer­kin­tö­jä eri kri­tee­rien pe­rus­teel­la. Tämän omi­nai­suu­den avulla voidaan etsiä koh­den­ne­tus­ti olen­nais­ta tietoa, mikä nopeuttaa ongelmien tun­nis­ta­mis­ta. Tässä on muutamia yleisesti käy­tet­ty­jä journalctl suo­da­tin­vaih­toeh­toa:

Näytä lokit

Komentoa journalctl suo­rit­ta­mal­la nykyisen jär­jes­tel­män lo­ki­mer­kin­nät näytetään kään­tei­ses­sä ai­ka­jär­jes­tyk­ses­sä. Käytä komento journalctl -f tai journalctl --follow, jos haluat nähdä merkinnät re­aa­lia­jas­sa. Uudet merkinnät näkyvät au­to­maat­ti­ses­ti saa­pu­mis­jär­jes­tyk­ses­sä.

Riippuen siitä, kuinka kauan systemd on ollut käynnissä jär­jes­tel­mäs­sä­si, näytölle tulee to­den­nä­köi­ses­ti hal­lit­se­ma­ton määrä tietoja, joka voi olla kymmeniä tai satoja tuhansia rivejä pitkä. Löy­tääk­se­si etsimäsi tiedot nopeammin, voit suodattaa lo­ki­tie­dos­to­ja edelleen eri­lai­sil­la Linux-ko­men­noil­la.

Kuinka suodattaa ajan mukaan

Käyt­tä­mäl­lä journalctl lo­ki­tie­dos­to­ja voidaan suodattaa tietyn ajan­koh­dan mukaan, jolloin niistä löytyy helpommin etsittyä tietoa.

Suodata käyn­nis­tyspro­ses­sin mukaan

Lokien suo­dat­ta­mi­nen käyn­nis­tyspro­ses­sin pe­rus­teel­la on kor­vaa­ma­ton­ta apua, kun halutaan tutkia jär­jes­tel­män ta­pah­tu­mia tietyillä ajan­koh­til­la tai käyn­nis­tys­ti­lan­teis­sa. Tämä koh­den­net­tu lä­hes­ty­mis­ta­pa tehostaa vian­mää­ri­tys­tä, sillä se keskittää lo­ki­mer­kin­nät tiet­tyi­hin jär­jes­tel­män tiloihin tai ko­koon­pa­noi­hin.

1. Nykyinen käyn­nis­tys: Va­lit­se­mal­la journalctl -b saat näkyviin kaikki lo­ki­mer­kin­nät, jotka on kerätty edellisen uu­del­leen­käyn­nis­tyk­sen jälkeen.
2. Aiemmat käyn­nis­tyk­set: Käytä vaih­toeh­toa -b ja sen jälkeen numeroa, jos haluat näyttää tietyn aiemman käyn­nis­tyk­sen lo­ki­mer­kin­nät. Jos esi­mer­kik­si syötät journalctl -b 1, edellinen käyn­nis­tys tulee näkyviin.
3. Luettelo kaikista käy­tet­tä­vis­sä olevista käyn­nis­tyspro­ses­seis­ta: Komento journalctl --list-boots näyttää luettelon käy­tet­tä­vis­sä olevista käyn­nis­tyk­sis­tä ja niiden tun­nuk­sis­ta. Voit käyttää ha­lua­maa­si käyn­nis­tys­tun­nus­ta tietyn käyn­nis­tyk­sen lokien näyt­tä­mi­seen.

Vaikka aiempien käyn­nis­tyspro­ses­sien tallennus on ole­tusar­voi­ses­ti käytössä joissakin Linux-ja­ke­luis­sa, käyt­tä­jien on joissakin ta­pauk­sis­sa ensin otettava se käyttöön. Tee tämä luomalla hakemisto, johon loki tal­len­ne­taan, kir­joit­ta­mal­la sudo mkdir -p /var/log/journal. Vaih­toeh­toi­ses­ti voit muokata journal-mää­ri­tys­tie­dos­toa ko­men­nol­la sudo nano /etc/systemd/journald.conf. Aseta sitten kohdassa [Journal] oleva asetus Storage= arvoksi persistent, jotta jatkuva lo­ki­tal­len­nus otetaan käyttöön:

. . . 
[Journal] 
Storage=persistent

Suodata aikavälin mukaan

Joskus voi olla tarpeen näyttää tietyn ajan­jak­son lo­ki­mer­kin­nät. journalctl on vaih­toeh­dot --since ja --until, joiden avulla merkinnät voidaan rajata tiettyyn ajan­jak­soon. Tätä varten käytetään ai­ka­muo­toa YYYY-MM-DD HH:MM:SS. Komento, jolla näytetään kaikki lo­ki­mer­kin­nät ajalta 1.1.2023 klo 12.00 – 2.1.2023 klo 12.00, on seuraava:

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

Näiden kahden komennon yh­dis­tel­mäl­lä voi suodattaa tuloksia myös ly­hyem­mäl­tä ajan­jak­sol­ta:

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

Vaih­toeh­toi­ses­ti voit myös jättää osan muodosta pois. Jos esi­mer­kik­si haluat näyttää kaikki tietueet tietystä ajan­koh­das­ta alkaen:

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

journalctl tunnistaa myös suh­teel­li­set arvot, kuten yesterday, today tai tomorrow. Jos haluat näyttää eilisen merkinnät, kirjoita seuraava:

journalctl --since yesterday

Kuinka suodattaa viestien omi­nai­suuk­sien pe­rus­teel­la

journalctl käyttö lo­ki­mer­kin­tö­jen suo­dat­ta­mi­seen niiden tärkeyden tai sisällön pe­rus­teel­la on myös erittäin hyö­dyl­lis­tä, sillä sen avulla voi etsiä olen­nais­ta tietoa ja keskittyä jär­jes­tel­mä­lo­kien tiet­tyi­hin osa-alueisiin. Tämä mah­dol­lis­taa muun muassa tehokkaan vian­mää­ri­tyk­sen, tie­to­tur­vaon­gel­mien varhaisen ha­vait­se­mi­sen ja suo­ri­tus­ky­vyn nopean seurannan.

Suodata tär­keys­jär­jes­tyk­sen mukaan

Voit suodattaa journalctl n lokit viestien tärkeyden mukaan käyt­tä­mäl­lä lo­ki­mer­kin­tö­jen prio­ri­teet­ti­luok­kia. Tätä varten voit käyttää joko prio­ri­tee­tin nimeä tai sitä vastaavaa nu­mee­ris­ta arvoa. Mitä pienempi luku, sitä tärkeämpi viesti on:

• 0: emerg (hä­tä­ti­lan­ne)
• 1: alert (hälytys)
• 2: crit (kriit­ti­nen)
• 3: err (virhe)
• 4: varoitus (warning)
• 5: notice (huomautus)
• 6: info (tieto)
• 7: debug (vian­mää­ri­tys)

Viestit, joilla on tietty prio­ri­teet­ti, voidaan suodattaa vaih­toeh­dol­la -p. Esi­mer­kik­si seuraava komento näyttää vain lo­ki­mer­kin­nät, joiden prio­ri­teet­ti on ”err” (virhe) tai korkeampi:

journalctl -p err

Suodata yksikön mukaan

Lokien suo­dat­ta­mi­nen yk­si­köit­täin on hyö­dyl­lis­tä, kun halutaan keskittyä tiet­tyi­hin pal­ve­lui­hin tai pro­ses­sei­hin. Ne voidaan suodattaa käyt­tä­mäl­lä vaih­toeh­toa -u. Jos haluat esi­mer­kik­si näyttää Apache-verk­ko­pal­ve­li­men lo­ki­mer­kin­nät, kirjoita seuraava komento:

journalctl -u apache2

Hakuja voidaan tarkentaa edelleen suh­teel­lis­ten aika-arvojen avulla. Jos haluat selvittää, onko palvelu jo suo­ri­tet­tu tänään, voit kir­joit­taa seuraavat tiedot:

journalctl -u apache2 --since today

journalctl voi yhdistää eri yk­si­köi­den tietueita. Jos esi­mer­kik­si Nginx-pro­ses­si­si on liitetty PHP FPM -yksikköön, niiden tietueet voidaan yhdistää ai­ka­jär­jes­tyk­ses­sä. Komento tähän on:

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

Suodata prosessin, käyttäjän tai ryhmän tunnuksen mukaan

Jour­nalctl voi suodattaa lo­ki­mer­kin­tö­jä prosessin, käyttäjän tai ryhmän tunnuksen pe­rus­teel­la. Jos tiedät tar­kal­leen sen prosessin PID-tunnuksen, jota haluat etsiä, voit käyttää suo­dat­ta­mi­seen optiota _PID. Jos PID-tunnus on esi­mer­kik­si 8088, komento näyttäisi tältä:

journalctl _PID=8088

Vaih­toeh­toi­ses­ti voit käyttää suo­dat­ti­mia _UID tai _GID näyt­tääk­se­si kaikki tietyn käyttäjän tai ryhmän kirjaamat merkinnät. Jos esi­mer­kik­si verk­ko­pal­ve­li­me­si nimi on ”www-data”, voit selvittää käyt­tä­jä­tun­nuk­sen seu­raa­vas­ti:

id -u www-data
33

Kir­jauk­set voidaan suodattaa tun­nis­teen pe­rus­teel­la:

journalctl _UID=33 --since today

Voit selvittää, mille ryh­mä­tun­nuk­sil­le tietueita on luotu, käyt­tä­mäl­lä vaih­toeh­toa -F. Tämä näyttää kaikki arvot, jotka on tal­len­net­tu Ryh­mä­tun­nus-kenttään:

journalctl -F _GID

Tässä on esimerkki tu­lok­ses­ta:

32
99
102
133
81
84
100
0
124
87

Suodata kom­po­nent­tien mukaan

Suo­dat­ta­mi­nen kom­po­nen­tin mukaan on hyö­dyl­lis­tä, kun halutaan keskittyä tiet­tyi­hin so­vel­luk­siin, pal­ve­lui­hin tai pro­ses­sei­hin. Kom­po­nent­ti­kent­tää käyttävät yleensä erilaiset palvelut tai oh­jel­mis­to­kom­po­nen­tit erot­ta­maan tiettyjä tietoja lo­ki­tie­dois­ta. Tämän suo­da­tuk­sen avulla lo­ki­mer­kin­nät voidaan rajata koskemaan tiettyä kom­po­nent­tia, so­vel­lus­ta tai pal­ve­lu­yk­sik­köä. Jos esi­mer­kik­si haluat suodattaa merkinnät, jotka si­säl­tä­vät suo­ri­tus­tie­dos­ton bash, kirjoita seuraava komento:

journalctl /usr/bin/bash

Näytä ytimen viestit

Lo­ki­mer­kin­tö­jen suo­dat­ta­mi­nen ytimen vies­teil­lä, joiden tunnus on journalctl, on tehokas tapa ana­ly­soi­da tietoa ytimen toi­min­nas­ta Linux-jär­jes­tel­mäs­sä. Ytimen viestit voivat antaa viitteitä lait­teis­to-on­gel­mis­ta, oh­jain­ris­ti­rii­dois­ta tai muista jär­jes­tel­mä­ta­pah­tu­mis­ta.

dmesg tu­los­tees­ta löytyvät ytimen viestit voidaan suodattaa myös journal-tie­dos­tos­ta. Ne voidaan näyttää ko­men­nol­la `-k or ``:

journalctl -k

Ole­tuk­se­na näytetään nykyisen käyn­nis­tyspro­ses­sin ytimen viestit. Voit suodattaa viestit vaih­toeh­toi­ses­ta käyn­nis­tyk­ses­tä käyt­tä­mäl­lä aiemmin mai­nit­tu­ja käyn­nis­tys­va­lin­ta­lip­pu­ja. Jos haluat esi­mer­kik­si tar­kas­tel­la viiden viimeisen käyn­nis­tyspro­ses­sin ytimen viestejä, kirjoita:

journalctl -k -b -5

Jour­nalctl-komennon lo­ki­nä­ky­män muut­ta­mi­nen

Näytön mu­kaut­ta­mi­nen journalctl antaa käyt­tä­jil­le mah­dol­li­suu­den selata lo­ki­tie­to­ja tarkemmin ja poimia tietoja nopeasti. Käyttäjät voivat mukauttaa näytön näyt­tä­mään lo­ki­tie­to­ja tietyn ajan­jak­son ajalta tai re­aa­lia­jas­sa, mikä helpottaa jär­jes­tel­mä­vir­hei­den ja ongelmien nopeaa tun­nis­ta­mis­ta.

Tuloksen ly­hen­tä­mi­nen tai laa­jen­ta­mi­nen

Voit muokata journalctl tietojen näyt­tö­ta­paa ly­hen­tä­mäl­lä tai laa­jen­ta­mal­la tu­los­tet­ta. Ole­tusar­voi­ses­ti journalctl näyttää koko merkinnän ha­ku­lis­tas­sa ja sijoittaa ne näytön oikealle puolelle. Tu­los­tet­ta voidaan lyhentää --no-full vaih­toeh­dol­la:

journalctl --no-full

Voit laajentaa näyttöä -a lipulla:

journalctl -a

Aseta journalctl va­kio­tu­los­tuk­seen

Vuonna journalctl lo­ki­tie­dos­to­jen tulostus näy­tet­tiin ole­tuk­se­na si­vut­tais­näyt­tö­oh­jel­mal­la, kuten less. Tämä mah­dol­lis­ti tu­los­tuk­sen kat­se­le­mi­sen osissa, mikä helpotti pitkien lo­ki­tie­dos­to­jen se­laa­mis­ta. On kuitenkin ti­lan­tei­ta, joissa lokien va­kio­tu­los­tuk­sen näyt­tä­mi­nen on tarpeen. Näin se tehdään:

journalctl --no-pager

Määritä tu­los­tus­muo­dot

journalctl tarjoaa myös vaih­toeh­to­ja lokien tu­los­tus­muo­don mu­kaut­ta­mi­seen. Tätä varten voit käyttää -o yhdessä asian­omai­sen muo­toi­lu­tun­nis­teen kanssa. Jos haluat esi­mer­kik­si tulostaa lo­ki­mer­kin­nät JSON-muodossa, kirjoita seuraava koodi:

journalctl -b -u nginx -o json

Tässä on tulos:

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

Jour­nalctl-ko­men­nos­sa voidaan käyttää seuraavia muotoja:

• cat: Näyttää vain vies­ti­ken­tän
• export: Siirtoon tai tal­len­nuk­seen sopiva bi­nää­ri­muo­to
• json: Standardi-JSON, yksi merkintä riviä kohden
• json-pretty: Luet­ta­vuu­den pa­ran­ta­mi­sek­si muotoiltu JSON
• json-sse: Kääritty JSON-muotoiltu tuloste, joka mah­dol­lis­taa pal­ve­li­men lä­het­tä­mien ta­pah­tu­mien li­sää­mi­sen
• short: Va­kio­muo­toi­nen syslog-tyylinen tuloste
• short-iso: Va­kio­muo­to ISO-8601-kel­lon­ajan leimojen näyt­tä­mi­seen
• short-monotonic: Va­kio­muo­to, jossa on mo­no­to­ni­set ai­ka­lei­mat
• short-precise: Va­kio­muo­to, jossa tarkkuus on mik­ro­se­kun­te­ja
• verbose: Näyttää kaikki ky­sei­sel­le mer­kin­näl­le käy­tet­tä­vis­sä olevat lo­ki­ken­tät

Miten journalctl toteuttaa pro­ses­sien ak­tii­vis­ta valvontaa?

Kun pro­ses­se­ja seurataan ak­tii­vi­ses­ti oh­jel­mal­la journalctl, ko­men­to­ri­vioh­jel­maa tail käytetään lokien re­aa­liai­kai­seen seu­ran­taan ja uusimpien mer­kin­tö­jen näyt­tä­mi­seen. Tämä helpottaa jär­jes­tel­mä­ta­pah­tu­mien re­aa­liai­kais­ta seurantaa ja mah­dol­lis­taa nopean rea­goin­nin ongelmiin.

Kuinka näyttää nykyiset lokit

Ko­men­nol­la -n voidaan näyttää tietty määrä tietueita. Se toimii täs­mäl­leen samalla tavalla kuin tail -n. Jos haluat näyttää viimeiset 10 tietuetta, käytä seuraavaa komentoa:

journalctl -n

Voit myös määrittää mer­kin­tö­jen lu­ku­mää­rän, esi­mer­kik­si 20:

journalctl -n 20