# Mis on Journalctl ja mida see teeb?

Journalctl on tõhus lahendus süsteemilogide haldamiseks ja analüüsimiseks Linuxi keskkondades. Seda tööriista saab kasutada süsteemi tegevuse jälgimiseks, vigade kõrvaldamiseks ja logide reaalajas jälgimiseks, pakkudes olulist teavet süsteemiprobleemide tõhusaks diagnoosimiseks.

## Mis on Journalctl?

`journalctl` on võimas utiliit **sündmuslogide** ja logifailide **päringute** tegemiseks **ning kuvamiseks** Linuxis. See on süsteemi- ja teenustehalduspaketi systemd keskne komponent, mis kuulub paljude kaasaegsete Linuxi distributsioonide, nagu Ubuntu, Fedora ja Arch Linux, koosseisu. Nimi „journalctl“ on sõnade „journal“ (logi) ja „ctl“ (juhtimine) liit, mis viitab asjaolule, et käsku kasutatakse logide juhtimiseks ja analüüsimiseks.

`journalctl` lihtsustab juurdepääsu süsteemilogile, mida haldab `systemd-journald`. Süsteemilogi on Linuxi süsteemi töötamise käigus tekkivate sõnumite ja sündmuste tsentraliseeritud kogum. Erinevalt traditsioonilistest tekstipõhistest logidest pakub `journalctl` struktureeritud ja tõhusat viisi **logiandmete** otsimiseks, filtreerimiseks ja kuvamiseks **reaalajas**. See aitab diagnoosida probleeme või jälgida süsteemi seisundit.

Selleks salvestab Journalctl **logifailid binaarses formaadis**, kuna binaarsed logifailid on kompaktsemad ja tõhusamad kui nende tekstipõhised vasted. Arvestades logitud andmete suurt mahtu, võimaldab see logifailidest konkreetseid sündmusi või teavet kiiremini ja tõhusamalt otsida. Tänu oma struktureeritud ja krüpteeritud olemusele pakuvad binaarsed logifailid tekstipõhiste logidega võrreldes ka suuremat turvalisust, kuna nende formaat muudab logiandmete manipuleerimise keerulisemaks.

## Kuidas reguleerida logifailide salvestusruumi

`journalctl` abil saab piirata ja seadistada logifailide poolt kõvakettal hõivatavat salvestusruumi. Seda tehakse **süsteemiteenuse systemd-journald seadete** kaudu. Seadistused on salvestatud failis `/etc/systemd/journald.conf`. Sealt leiate järgmised kanded:

- `SystemMaxUse`: Piirab logifailide salvestusruumi süsteemikataloogis
- `RuntimeMaxUse`: Piirab logifailide salvestusruumi ajutises kataloogis

Mälupiirangu seadmiseks lisage järgmised read või muudke neid vastavalt vajadusele:

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

Selles näites esitatud väärtusi (50M) saab vastavalt vajadusele muuta. Samuti on võimalik kasutada teisi ühikuid, näiteks `K` (kilobaidid), `M` (megabaitid), `G` (gigabaitid) või `T` (terabaitid). Kui olete konfiguratsioonifaili muutnud, tuleb muutuste jõustumiseks taaskäivitada systemd-journald:

```bash
sudo systemctl restart systemd-journald
```

Nende sammude järgimisel seadistatakse systemd-journald nii, et logifailide jaoks eraldatavat kettaruumi piiratakse. Veenduge, et valitud piirang võimaldab olulisi logiandmeid piisavalt salvestada. Samal ajal on oluline vältida liigset kettaruumi kasutamist. Pange tähele, et **vanemad logid kustutatakse automaatselt**, kui eraldatud kettaruumi piir on täis.

### Hinda kettaruumi kasutamist

Enne logifailide salvestusruumi suuruse muutmist kontrollige, kui palju ruumi ajutine salvestusruum praegu hõivab. Selleks kasutage `--disk-usage`:

```bash
journalctl --disk-usage
```

Siin on näide, kuidas väljund välja näeb:

```bash
Journals take up 8.0M on disk.
```

### Kustuta vanad logikirjed

Kui Journal võtab liiga palju mälu, saate vanad logikirjed kustutada. Selleks on kaks võimalust:

Kasutage `--vacuum-size`, et vähendada päeviku mahtu, määrates selle suuruseks soovitud väärtuse. Selle meetodi puhul kustutatakse vanu kandeid, kuni päeviku poolt kõvakettal hõivatud kogumaht on saavutanud soovitud suuruse.

```bash
sudo journalctl --vacuum-size=1G
```

Teise võimalusena saate logifaili mahtu vähendada, määrates valikuga `--vacuum-time` säilitamisaja. Määratud ajast vanemad kanded kustutatakse. Eelmise aasta logikannete säilitamiseks võite kasutada järgmist käsku:

```bash
sudo journalctl --vacuum-time=1years
```

## Mida suudab Journalctl teha?

`journalctl` pakub võimsaid filtreerimisvõimalusi, mis võimaldavad kasutajatel **logikirjeid erinevate kriteeriumide alusel** läbi vaadata. See funktsioon võimaldab asjakohast teavet sihipäraselt otsida, aidates probleeme kiiremini tuvastada. Siin on mõned sagedamini kasutatavad `journalctl` filtreerimisvõimalused:

### Näita logisid

Käsu `journalctl` täitmisel kuvatakse praeguse süsteemi logikirjed käänulises kronoloogilises järjekorras. Kasutage `journalctl -f` või `journalctl --follow`, et kuvada kirjed **reaalajas**. Uued kirjed kuvatakse automaatselt sissetulevate järjekorras.

Sõltuvalt sellest, kui kaua on systemd teie süsteemis töötanud, kuvatakse teile tõenäoliselt hallamatu hulk andmeid, mis võib ulatuda kümnetesse või sadadesse tuhandetesse ridadesse. Et leida otsitavat kiiremini, saate logifaile erinevate Linuxi käskudega täiendavalt filtreerida.

## Kuidas filtreerida aja järgi

`journalctl` kasutades saab logifaile filtreerida vastavalt kindlale ajale, et neist oleks asjakohast teavet tõhusamalt otsida.

### Filtreeri käivitamisprotsessi järgi

Logide filtreerimine käivitamisprotsessi järgi on hindamatu abi süsteemisündmuste uurimisel kindlatel ajahetkedel või käivitamissituatsioonides. See sihipärane lähenemisviis lihtsustab probleemide diagnoosimist, suunates logikirjed konkreetsetele süsteemi seisunditele või konfiguratsioonidele.

1. **Praegune käivitamine**: valikuga `journalctl -b` kuvatakse kõik logikirjed, mis on kogutud alates viimasest taaskäivitamisest.
2. **Eelmised käivitused**: Kasutage valikut `-b`, millele järgneb number, et kuvada konkreetse eelmise käivituse logikirjed. Näiteks kui sisestate `journalctl -b 1`, kuvatakse eelmine käivitamine.
3. **Kõigi kättesaadavate käivitamisprotsesside loend**: Käsk `journalctl --list-boots` kuvab loendi kättesaadavatest käivitamistest koos nende vastavate ID-dega. Saate kasutada soovitud käivitamise ID-d, et kuvada konkreetse käivitamise logid.

Kuigi mõnes Linuxi distributsioonis on varasemate käivitamisprotsesside salvestamine vaikimisi sisse lülitatud, peavad kasutajad teistes distributsioonides selle **esmalt** ise **aktiveerima**. Selleks looge kataloog, kuhu logi salvestatakse, sisestades `sudo mkdir -p /var/log/journal`. Teise võimalusena võite redigeerida ajakirja konfiguratsioonifaili, kasutades `sudo nano /etc/systemd/journald.conf`. Seejärel seadke valik `Storage=` punktis `[Journal]` väärtuseks `persistent`, et aktiveerida püsiv logimine:

```bash
. . . 
[Journal] 
Storage=persistent
```

### Filtreeri ajavahemiku järgi

Mõnikord võib tekkida vajadus kuvada logikirjed kindla ajavahemiku kohta. `journalctl` pakub valikuid `--since` ja `--until`, mille abil saab piirata kirjeid **kindla ajavahemikuga**. Selleks kasutage ajaformaati `YYYY-MM-DD HH:MM:SS`. Käsk, millega kuvatakse kõik logikirjed ajavahemikus 1. jaanuar 2023 kell 12:00 kuni 2. jaanuar 2023 kell 12:00, näeb välja järgmine:

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

Nende kahe käsu kombinatsiooniga saab filtreerida ka lühema ajavahemiku puhul:

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

Teise võimalusena võid ka osa vormingust välja jätta. Näiteks kui soovid kuvada kõiki kandeid alates teatud ajahetkest:

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

`journalctl` tunnistab ka suhtelisi väärtusi, nagu `yesterday`, `today` või `tomorrow`. Eilsete sissekannete kuvamiseks sisestage järgmine käsk:

```bash
journalctl --since yesterday
```

## Kuidas filtreerida sõnumite omaduste järgi

`journalctl` kasutamine logikirjete filtreerimiseks tähtsuse või sisu alusel on samuti äärmiselt kasulik, kuna see võimaldab **otsida asjakohast teavet ja keskenduda süsteemilogide konkreetsetele aspektidele**. See võimaldab muu hulgas tõhusat veadiagnostikat, turvaprobleemide varast avastamist ja kiiret jõudluse jälgimist.

### Filtreeri prioriteedi järgi

Sõnumite tähtsuse järgi `journalctl` filtreerimiseks võite kasutada **logikirjete prioriteedikategooriaid**. Selleks võite kasutada kas prioriteedi nime või selle vastavat numbrilist väärtust. Mida väiksem number, seda olulisem on sõnum:

- 0: emerg (hädaolukord)
- 1: alert (häire)
- 2: crit (kriitiline)
- 3: err (viga)
- 4: warning (hoiatus)
- 5: notice (märkus)
- 6: info (teave)
- 7: debug (veaotsing)

Teatava prioriteediga sõnumeid saab filtreerida valiku `-p` abil. Näiteks kuvab järgmine käsk ainult neid logikirjeid, mille prioriteet on „err“ (viga) või kõrgem:

```bash
journalctl -p err
```

### Filtreeri üksuse järgi

Logide filtreerimine üksuste kaupa on kasulik, kui soovitakse keskenduda konkreetsetele teenustele või protsessidele. Neid saab filtreerida valiku `-u` abil. Näiteks Apache veebiserveri logikirjete kuvamiseks sisestage järgmine käsk:

```bash
journalctl -u apache2
```

Otsingut saab täpsustada ajavahemike abil. Et teada saada, kas teenus on täna juba osutatud, võite sisestada järgmise:

```bash
journalctl -u apache2 --since today
```

`journalctl` võimaldab ühendada eri üksuste andmekirjeid. Näiteks kui teie Nginx-protsess on seotud PHP FPM-üksusega, saab nende kirjed kronoloogiliselt ühendada. Selleks on vaja kasutada järgmist käsku:

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

### Filtreeri protsessi, kasutaja või grupi ID järgi

Journalctl suudab logikirjeid filtreerida protsessi, kasutaja või grupi ID järgi. Kui teate **otsitava protsessi täpset PID-i**, saate kirjeid filtreerida valikuga `_PID`. Näiteks kui PID on 8088, näeks käsk välja järgmine:

```bash
journalctl _PID=8088
```

Teise võimalusena võite kasutada filtreid `_UID` või `_GID`, et kuvada kõik konkreetse kasutaja või rühma poolt loodud kanded. Näiteks kui teie veebiserveri nimi on „www-data“, saate kasutaja ID leida järgmiselt:

```bash
id -u www-data
33
```

Raamatupidamiskandeid saab filtreerida ID järgi:

```bash
journalctl _UID=33 --since today
```

Selleks, et teada saada, milliste rühma-ID-de jaoks on kirjed loodud, võite kasutada valikut `-F`. See kuvab kõik väärtused, mis on salvestatud väljale „Rühma-ID“:

```bash
journalctl -F _GID
```

Siin on väljundi näide:

```bash
32
99
102
133
81
84
100
0
124
87
```

### Filtreeri komponendi järgi

Komponendi järgi filtreerimine on kasulik, kui soovitakse keskenduda konkreetsetele rakendustele, teenustele või protsessidele. Komponendi välja kasutavad tavaliselt **erinevad teenused või tarkvarakomponendid**, et eristada logides konkreetset teavet. See filtreerimine võimaldab kitsendada logikirjeid konkreetse komponendi, rakenduse või teenuseühiku tasandile. Näiteks, et filtreerida kirjeid, mis sisaldavad käivitatavat faili `bash`, sisestage järgmine käsk:

```bash
journalctl /usr/bin/bash
```

### Kuva tuumateated

Logikirjete filtreerimine tuumateadete järgi numbriga `journalctl` on tõhus viis Linuxi süsteemi tuuma tööd käsitleva teabe analüüsimiseks. Tuumateated võivad anda **vihjeid riistvaraprobleemide, draiverite konfliktide või muude süsteemisündmuste kohta**.

`dmesg` väljundis leiduvaid tuumasõnumeid saab filtreerida ka ajakirjast. Neid saab kuvada käsuga ``-k or `` koos lippudega `-k or`:

```bash
journalctl -k
```

Vaikimisi kuvatakse praeguse käivitamisprotsessi tuumasõnumeid. Eespool mainitud käivitamisvaliku lipukeste abil saate filtreerida sõnumeid **teistest käivitamisprotsessidest**. Kui soovite näiteks vaadata viimase viie käivitamisprotsessi tuumasõnumeid, sisestage:

```bash
journalctl -k -b -5
```

## Ajakirja kuvamise muutmine käsus Journalctl

`journalctl` kuvandi kohandamine võimaldab kasutajatel logifaile täpsemalt läbi otsida ja teavet kiiresti leida. Kasutajad saavad kuvandi seadistada nii, et see kuvaks logiandmeid kindla ajavahemiku kohta või reaalajas, mis hõlbustab süsteemivigade ja probleemide kiiret tuvastamist.

### Väljundi lühendamine või pikendamine

Võite kohandada `journalctl` andmete kuvamist, lühendades või laiendades väljundit. Vaikimisi kuvab `journalctl` kogu kande pageris ja jooksutab neid ekraani paremal poolel. Väljundit saab lühendada valikuga `--no-full`:

```bash
journalctl --no-full
```

Ekraani saab laiendada lipuga `-a`:

```bash
journalctl -a
```

### Suuna `journalctl` standardväljundisse

`journalctl`. versioonis kuvatakse logiväljund vaikimisi pager-tüüpi programmiga, nagu näiteks `less`. See võimaldab kasutajatel väljundit osade kaupa vaadata, mis lihtsustab pikkade logifailide sirvimist. Siiski on olukordi, kus on vaja kuvada logide standardväljundit. Seda saab teha järgmiselt:

```bash
journalctl --no-pager
```

### Väljundvormingute määramine

`journalctl` pakub ka võimalusi logifailide väljundvormingu kohandamiseks. Selleks võid kasutada `-o` koos vastava vormingu identifikaatoriga. Näiteks logikirjete väljastamiseks JSON-vormingus sisesta järgmine kood:

```bash
journalctl -b -u nginx -o json
```

Siin on tulemus:

```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" :
```

Journalctl-is saab kasutada järgmisi formaate:

- **cat**: kuvab ainult sõnumivälja
- **eksport**: edastamiseks või salvestamiseks sobiv binaarne formaat
- **json**: Standardne JSON, kus iga rida sisaldab ühte kirjet
- **json-pretty**: paremini loetavaks vormindatud JSON
- **json-sse**: vormindatud väljund, mis võimaldab lisada serveri poolt saadetud sündmusi
- **short**: standardne syslog-stiilis väljund
- **short-iso**: standardvorming ISO-8601 seinakella ajamärkide kuvamiseks
- **short-monotonic**: standardvorming monotoonsete ajamärkidega
- **short-precise**: standardvorming mikrosekundilise täpsusega
- **verbose**: kuvab iga vastava kande jaoks kättesaadava päevikuvälja

## Kuidas teostab `journalctl` protsesside aktiivset seiret?

Protsesside aktiivse jälgimise `journalctl`igus kasutatakse käsureaprogrammi `tail` logide reaalajas jälgimiseks ja viimaste sissekannete kuvamiseks. See lihtsustab süsteemisündmuste reaalajas jälgimist ja võimaldab probleemidele kiiresti reageerida.

## Kuidas kuvada praeguseid logifaile

Parameetrit `-n` saab kasutada kindla arvu andmekirjete kuvamiseks. See toimib täpselt samamoodi kui parame `tail -n`. Viimase 10 kirje kuvamiseks kasuta järgmist käsku:

```bash
journalctl -n
```

Samuti saad määrata kirjetele arvu, näiteks 20:

```bash
journalctl -n 20
```


This is a markdown version of: [https://www.ionos.com/et-ee/digitalguide/server/toeoeriistad/journalctl/](https://www.ionos.com/et-ee/digitalguide/server/toeoeriistad/journalctl/) for AI/LLM consumption.