Linux-komentorivin ja Bash-komentosarjojen hallinta · Oppitunti

journaldin kyselyt journalctlillä skripteissä

Suodata systemd:n lokimerkintöjä yksikön, prioriteetin ja ajan perusteella automaattista häiriöiden ensiarviointia varten.

Oppitunti 3/413 vaihetta

journaldin kyselyt journalctlillä skripteissä on ilmainen Linux-komentorivin ja Bash-komentosarjojen hallinta-oppitunti CoddyKitissä. Tämä on oppitunti 3/4. Voit lukea koko oppitunnin alta ilmaiseksi ja harjoitella sen jälkeen käytännössä selaimessa sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla. Oppitunti kuuluu Linux-komentorivin ja Bash-komentosarjojen hallinta-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Linux-komentorivin ja Bash-komentosarjojen hallinta-kurssilla on yhteensä 4 oppituntia.

Miksi journaldia käytetään häiriöiden selvittämiseen?

Nykyaikaiset systemd-järjestelmää käyttävät Linux-järjestelmät keskittävät kaiken lokitulosteen journaliin — systemd-journald-palvelun hallinnoimaan jäsenneltyyn binääriseen lokivarastoon. Toisin kuin hakemiston /var/log tavalliset tekstitiedostot, jokainen journal-merkintä sisältää runsaasti metatietoja: yksikön nimen, prioriteettitason, PID:n, UID:n, aikaleiman ja muuta.

Automaattisissa häiriöiden selvitysskripteissä näiden metatietojen avulla voitte:

Suodattaa lokit yhteen palveluun ilman grep-ketjuja
Rajata kyselyt täsmällisiin aikaväleihin (viimeiset 15 minuuttia, käyttöönotosta lähtien)
Tulostaa vain kriittiset ja virheilmoitukset sekä jättää kohinan huomiotta
Syöttää jäsennellyn tulosteen suoraan hälytysputkiin

Kaiken tämän tarjoaa työkalu journalctl. Tässä oppitunnissa opitte käyttämään sitä ohjelmallisesti Bash-skripteissä.

journalctl-komennon perusteet

Komennon journalctl yksinkertaisin muoto tulostaa koko journalin. Skripteissä ette lähes koskaan halua sitä — lisätkää aina vähintään yksi suodatin. Tässä ovat yleisimmät yhdessä käytettävät valitsimet:

-u <unit> — suodata systemd-yksikön mukaan (esimerkiksi nginx.service)
-p <priority> — suodata syslog-prioriteetin mukaan (0=emerg … 7=debug)
--since / --until — aikaväli
-n <N> — viimeiset N riviä
--no-pager — poista käytöstä vuorovaikutteinen sivutus (välttämätön skripteissä)
-o <format> — tulostemuoto (short, json, cat jne.)

Välittäkää ei-vuorovaikutteisissa skripteissä aina --no-pager, jotta journalctl ei yritä käynnistää less-ohjelmaa ja jää jumiin.

#!/usr/bin/env bash
# Print the last 20 lines of the nginx service journal
journalctl --no-pager -u nginx.service -n 20

Suodattaminen systemd-yksikön mukaan

-u-valitsin hyväksyy minkä tahansa kelvollisen yksikön nimen. Voitte antaa sen useita kertoja yksiköiden yhdistämiseksi. Tämä on hyödyllistä, kun yksi sovellus käyttää useita palveluita (esimerkiksi ohjelmointirajapintaa ja sen tietokantasisarpalvelua).

Yksiköiden nimet noudattavat kaavoja <name>.service, <name>.socket, <name>.timer jne. Jokerimerkit ovat tuettuja: -u 'myapp*' vastaa yksiköitä myapp-api.service, myapp-worker.service ja niin edelleen.

Häiriöiden selvitysskriptissä yksikön nimi saadaan tyypillisesti argumenttina, jolloin suodatin on dynaaminen.

#!/usr/bin/env bash
# Usage: ./unit_logs.sh nginx.service
UNIT="${1:?Usage: $0 <unit>}"

echo "=== Journal for ${UNIT} (last 50 lines) ==="
journalctl --no-pager -u "${UNIT}" -n 50

# Combine two related units
echo "=== Combined: api + worker ==="
journalctl --no-pager -u myapp-api.service -u myapp-worker.service -n 30

Prioriteettitasot ja -p-lippu

-p-lippu vastaa vakiomuotoisia syslog-prioriteettitasoja:

0 — emerg
1 — alert
2 — crit
3 — err
4 — warning
5 — notice
6 — info
7 — debug

Voitte määrittää yhden tason (-p err), jolloin näette vain kyseisen tason, tai alueen (-p emerg..err), jolloin mukaan otetaan kaikki hätätilanteista virheisiin — tämä on yleisin valinta automaattisessa hälytyksessä.

Nimetyt aliakset (err, warning, crit) hyväksytään numeeristen arvojen rinnalla.

#!/usr/bin/env bash
# Extract only error-level and above entries for sshd
journalctl --no-pager \
  -u sshd.service \
  -p emerg..err \
  --since "1 hour ago"

# Exit non-zero if any errors were found (useful in CI health checks)
ERROR_COUNT=$(journalctl --no-pager -u sshd.service -p emerg..err \
  --since "1 hour ago" --output=cat | wc -l)

if [[ "${ERROR_COUNT}" -gt 0 ]]; then
  echo "[ALERT] ${ERROR_COUNT} error(s) detected in sshd" >&2
  exit 1
fi

Aikaikkunan suodatus lipuilla --since ja --until

Aikasuodattimet ovat tapahtumaikkunaa koskevien kyselyjen perusta. journalctl hyväksyy joustavat, ihmiselle luettavat aikaleimat:

Suhteelliset: "10 minutes ago", "2 hours ago", "yesterday"
Absoluuttiset: "2026-06-11 14:00:00"
Erityiset avainsanat: today, yesterday, -1h (lyhyt muoto)

Käyttöönottoa automatisoivissa skripteissä yleinen toimintatapa on tallentaa aikaleima juuri ennen käyttöönottoa ja kysellä sitten lokia kyseisestä hetkestä alkaen julkaisun aiheuttamien regressioiden havaitsemiseksi.

#!/usr/bin/env bash
# Record deploy start time, then check logs afterwards
DEPLOY_START=$(date +"%Y-%m-%d %H:%M:%S")

echo "Deploying at ${DEPLOY_START}..."
# ... your deploy steps here ...
sleep 2  # simulate deploy

echo "=== Journal since deploy start ==="
journalctl --no-pager \
  -u myapp.service \
  --since "${DEPLOY_START}" \
  -p emerg..warning

Rakenteinen tulostus JSON-muodossa

Koneellisesti luettavia putkia varten välittäkää -o json (yksi JSON-objekti riviä kohden, NDJSON) tai -o json-pretty (muotoiltu tulostus). Jokainen objekti sisältää kaikki lokin kentät:

MESSAGE — lokiteksti
PRIORITY — numeerinen prioriteetti (0–7)
_SYSTEMD_UNIT — alkuperäinen unit
__REALTIME_TIMESTAMP — mikrosekunnit epookista
_PID, _UID, _HOSTNAME — prosessin metatiedot

Voitte ohjata tämän NDJSON-virran jq-komennolle kenttien poimimista, suodattamista tai uudelleenmuotoilua varten. Tietoja voidaan käyttää myöhemmissä hälytysjärjestelmissä, kuten PagerDutyssä, Slack-webhookeissa tai SIEM-tiedonkerääjissä.

#!/usr/bin/env bash
# Extract error messages as a clean list for a Slack notification
MESSAGES=$(journalctl --no-pager \
  -u nginx.service \
  -p emerg..err \
  --since "30 minutes ago" \
  -o json \
  | jq -r '.MESSAGE' \
  | sort -u)

if [[ -n "${MESSAGES}" ]]; then
  echo "Errors detected:"
  echo "${MESSAGES}"
fi

Lokipäiväkirjan seuraaminen reaaliajassa

-f-lippu saa journalctl-komennon seuraamaan lokipäiväkirjaa reaaliajassa — vastaavasti kuin tail -f lokitiedostolle. Kun siihen yhdistetään unit- ja prioriteettisuodattimet, tuloksena on kohdennettu reaaliaikainen valvonta.

Skriptatuissa putkissa hyödyllisempi toimintatapa on kohdistinpohjainen kysely: tallentakaa nykyinen lokipäiväkirjan kohdistin ja välittäkää jokaisella kyselykerralla --after-cursor=<cursor>, jotta luetaan vain edellisen tarkistuksen jälkeen lisätyt merkinnät. Näin vanhoja rivejä ei käsitellä uudelleen.

Hakekaa viimeisin kohdistin komennolla --show-cursor -n 0 ja jäsentäkää tulosteen rivi -- cursor:.

#!/usr/bin/env bash
# Cursor-based polling: read only new journal entries each run
CURSOR_FILE="/tmp/triage_cursor"

if [[ -f "${CURSOR_FILE}" ]]; then
  CURSOR=$(cat "${CURSOR_FILE}")
  NEW_ENTRIES=$(journalctl --no-pager \
    -u myapp.service \
    -p emerg..err \
    --after-cursor="${CURSOR}" \
    -o json)
else
  # First run: look back 5 minutes
  NEW_ENTRIES=$(journalctl --no-pager \
    -u myapp.service \
    -p emerg..err \
    --since "5 minutes ago" \
    -o json)
fi

# Save updated cursor for next poll
journalctl --no-pager -n 0 --show-cursor 2>&1 \
  | grep '^-- cursor:' \
  | sed 's/-- cursor: //' \
  > "${CURSOR_FILE}"

echo "${NEW_ENTRIES}" | jq -r '.MESSAGE // empty'

Käynnistyskohtaiset kyselyt lipulla -b

-b-lippu rajaa kyselyn tiettyyn käynnistysistuntoon. Tämä on välttämätöntä kaatumisen tai odottamattoman uudelleenkäynnistyksen jälkeen, kun haluatte hakea edellisen käynnistyksen lokit nykyisen sijaan.

-b 0 — nykyinen käynnistys (oletus)
-b -1 — edellinen käynnistys
-b -2 — kaksi käynnistystä sitten
--list-boots — näyttää kaikki tallennetut käynnistysistunnot aikaleimoineen

Jälkianalyysiskriptit tallentavat usein edellisen käynnistyksen kriittiset lokit (-b -1) selvittääkseen, miksi järjestelmä kaatui tai palvelu epäonnistui käynnistyessään.

#!/usr/bin/env bash
# Post-mortem: collect critical logs from the previous boot
echo "=== Previous boot sessions ==="
journalctl --list-boots

echo ""
echo "=== Critical entries from previous boot ==="
journalctl --no-pager \
  -b -1 \
  -p emerg..crit \
  -o short-iso

Grep-haku journalctl:n tulosteesta ja natiiviset osumat

Voitte välittää raakaa grep-hakukuviota kaikkien lippujen jälkeen, mutta journalctl tukee myös natiiveja kenttäosumia syntaksilla FIELD=value. Natiiviset osumat kohdistetaan rakenteisiin metatietoihin, joten ne ovat paljon nopeampia kuin tekstin jälkikäsittely grep-komennolla.

Yleisiä hyödyllisiä osumia:

_PID=1234 — tietyn prosessin lokit
_COMM=python3 — kaikkien nimellä python3 suoritettavien prosessien lokit
SYSLOG_IDENTIFIER=myapp — mukautetulla tunnisteella merkityt lokit

Useat FIELD=value-argumentit yhdistetään AND-operaatiolla; niiden väliin sijoitettu + luo OR-operaation. Käyttäkää -g <regex>-valitsinta täyden tekstin grep-hakuun, jos rakenteiset metatiedot eivät riitä.

#!/usr/bin/env bash
# Native field match: errors from the postgres process only
journalctl --no-pager \
  _COMM=postgres \
  -p emerg..err \
  --since "1 hour ago"

# Full-text grep for a specific error string
journalctl --no-pager \
  -u postgresql.service \
  --since "1 hour ago" \
  -g "FATAL|PANIC" \
  --output=cat

Uudelleenkäytettävän triage-funktion rakentaminen

Kun yksittäiset liput ovat hallussa, niiden kokoaminen uudelleenkäytettäväksi Bash-funktioksi pitää triageskriptit selkeinä ja yhdenmukaisina. Hyvin suunnitellun funktion tulisi:

ottaa parametreina unit, prioriteettialue ja aikaikkuna
käyttää argumenttien puuttuessa turvallisia ja vähän kohinaa tuottavia oletusarvoja
palauttaa nollasta poikkeava poistumiskoodi, jos virheitä löytyy (integroituu CI-putkiin)
kirjoittaa havainnot sekä vakiotulosteeseen että aikaleimattuun lokitiedostoon tarkastusjälkeä varten

#!/usr/bin/env bash
# triage.sh — reusable journal triage function

triage_unit() {
  local unit="${1:?unit required}"
  local priority="${2:-emerg..err}"
  local since="${3:-1 hour ago}"
  local logfile="/tmp/triage_${unit//[^a-zA-Z0-9]/_}_$(date +%s).log"

  echo "[$(date -Iseconds)] Triaging ${unit} | prio=${priority} | since='${since}'" | tee "${logfile}"

  journalctl --no-pager \
    -u "${unit}" \
    -p "${priority}" \
    --since "${since}" \
    -o short-iso \
    | tee -a "${logfile}"

  local count
  count=$(wc -l < "${logfile}")
  # Subtract 1 for the header line
  (( count-- ))

  if [[ "${count}" -gt 0 ]]; then
    echo "[ALERT] ${count} line(s) logged to ${logfile}" >&2
    return 1
  fi
  return 0
}

# Example: triage nginx errors in the last 30 minutes
triage_unit nginx.service "emerg..err" "30 minutes ago"

Automaattinen tapahtumien triageskripti

Seuraava valmis skripti kokoaa kaikki käsitteet käytännölliseksi automaattiseksi triagetyökaluksi. Se lukee kriittisten palvelujen luettelon, kysyy kunkin palvelun lokit määritettävältä tarkasteluajalta, kokoaa havainnot ja päättyy virhekoodiin, jos virheitä havaittiin — siksi se sopii cron-työksi tai CI:n kuntotarkistusvaiheeksi.

#!/usr/bin/env bash
# incident_triage.sh — automated multi-service journal triage
set -euo pipefail

LOOKBACK="${1:-15 minutes ago}"
PRIORITY="emerg..err"
SERVICES=(nginx.service postgresql.service myapp-api.service myapp-worker.service)
REPORT="/tmp/incident_report_$(date +%Y%m%d_%H%M%S).txt"
FAILED=0

{
  echo "Incident Triage Report"
  echo "Generated : $(date -Iseconds)"
  echo "Lookback  : ${LOOKBACK}"
  echo "Priority  : ${PRIORITY}"
  echo "-----------------------------------"
} > "${REPORT}"

for svc in "${SERVICES[@]}"; do
  ENTRIES=$(journalctl --no-pager \
    -u "${svc}" \
    -p "${PRIORITY}" \
    --since "${LOOKBACK}" \
    --output=cat 2>/dev/null || true)

  COUNT=$(echo "${ENTRIES}" | grep -c . || true)

  if [[ "${COUNT}" -gt 0 ]]; then
    echo "[FAIL] ${svc}: ${COUNT} error(s)" | tee -a "${REPORT}"
    echo "${ENTRIES}" >> "${REPORT}"
    echo "-----------------------------------" >> "${REPORT}"
    FAILED=1
  else
    echo "[OK]   ${svc}"
  fi
done

echo ""
echo "Full report: ${REPORT}"
exit "${FAILED}"

Tietotesti: prioriteettialueen suodatus

Kirjoitatte skriptiä, joka hälyttää päivystävät insinöörit vain, kun palvelu kirjaa viestejä tasolla error tai vakavammalla tasolla (eli error, critical, alert tai emergency). Millä journalctl-lippuyhdistelmällä juuri tämä alue saadaan mukaan?

Vastaa interaktiivisessa oppitunnissa

Oppitunnin kertaus: journalctl skripteissä

Tässä oppitunnissa opitte kyselyjen tekemisen systemd-lokipäiväkirjasta ohjelmallisesti automaattista tapahtumien triagea varten:

Välittäkää skripteissä aina --no-pager, jotta interaktiivinen pysähtyminen estetään.
Unit-suodatus (-u) rajaa kyselyt yhteen tai useampaan palveluun; jokerimerkit ja useat -u-liput ovat tuettuja.
Prioriteettisuodatus (-p emerg..err) ottaa mukaan vain tarvitsemanne vakavuustasot — muistakaa, että pienemmät numerot tarkoittavat vakavampia tasoja.
Aikaikkunat (--since / --until) rajaavat lokitulosteen käyttöönottoikkunaan tai tarkasteluajalle ihmiselle luettavien aikaleimojen avulla.
Käynnistyksen rajaaminen (-b -1) antaa jälkianalyysiskriptien lukea edellisen kaatumisistunnon lokit.
JSON-tulostus (-o json) ja jq mahdollistavat rakenteiset putket hälytys- tai SIEM-järjestelmiä varten.
Kohdistinpohjainen kysely lipulla --after-cursor estää vanhojen merkintöjen käsittelyn uudelleen toistuvilla suorituksilla.
Natiiviset kenttäosumat (_COMM=, SYSLOG_IDENTIFIER=) ovat nopeampia kuin tulosteen ohjaaminen grep-komennolle.

Kun nämä liput yhdistetään uudelleenkäytettävään Bash-funktioon, saatte tuotantokelpoisen triagetyökalun, joka integroituu siististi croniin, CI-putkiin ja päivystyshälytyksen työnkulkuihin.

Aloita maksutta

Opi Bash tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 22
Oppitunnit: 88

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”journaldin kyselyt journalctlillä skripteissä” ilmainen?

Kyllä – oppitunnin ”journaldin kyselyt journalctlillä skripteissä” koko tekstin voi lukea täällä verkossa ilmaiseksi. Jos haluat harjoitella interaktiivisesti sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla sekä avata koko Linux-komentorivin ja Bash-komentosarjojen hallinta-kurssin, päivitä CoddyKit PROhon. Linux-komentorivin ja Bash-komentosarjojen hallinta-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”journaldin kyselyt journalctlillä skripteissä”?

Suodata systemd:n lokimerkintöjä yksikön, prioriteetin ja ajan perusteella automaattista häiriöiden ensiarviointia varten. Harjoittelet Linux-komentorivin ja Bash-komentosarjojen hallinta-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni Linux-komentorivin ja Bash-komentosarjojen hallinta-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin Linux-komentorivin ja Bash-komentosarjojen hallinta-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 3/4.

Kuinka kauan ”journaldin kyselyt journalctlillä skripteissä”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä Linux-komentorivin ja Bash-komentosarjojen hallinta-oppitunnilla?

Kyllä. Jokainen Linux-komentorivin ja Bash-komentosarjojen hallinta-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

Web- ja sovelluslokien jäsentäminen suuressa mittakaavassa
Lokien seuraaminen reaaliajassa ja suoratoistohälytykset
journaldin kyselyt journalctlillä skripteissä
Mittareiden ja histogrammien laskeminen lokivirroista

← Takaisin: Linux-komentorivin ja Bash-komentosarjojen hallinta