Bemästra Linux-kommandoraden och Bash-skriptning · Lektion

Fråga journald med journalctl i skript

Filtrera systemd-journalposter efter unit, prioritet och tid för automatiserad incidenttriage.

Lektion 3 av 413 steg

Fråga journald med journalctl i skript är en gratis lektion i Bemästra Linux-kommandoraden och Bash-skriptning på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Bemästra Linux-kommandoraden och Bash-skriptning, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Bemästra Linux-kommandoraden och Bash-skriptning innehåller totalt 4 lektioner.

Varför använda journald vid incidenttriage?

Moderna Linux-system som kör systemd centraliserar all loggutdata i journalen — ett strukturerat, binärt logglager som hanteras av systemd-journald. Till skillnad från vanliga textfiler i /var/log innehåller varje journalpost omfattande metadata: enhetsnamn, prioritetsnivå, PID, UID, tidsstämpel med mera.

I automatiserade skript för incidenttriage låter denna metadata Er:

filtrera loggar till en enda tjänst utan kedjor av grep
begränsa frågor till exakta tidsintervall (de senaste 15 minuterna, sedan en driftsättning)
skriva ut endast kritiska meddelanden och felmeddelanden och ignorera brus
mata strukturerad utdata direkt in i notifieringspipelines

Verktyget som ger åtkomst till allt detta är journalctl. Den här lektionen lär Er att styra det programmatiskt i Bash-skript.

Grundläggande användning av journalctl

Den enklaste formen av journalctl dumpar hela journalen. I skript vill Ni nästan aldrig göra det — lägg alltid till minst ett filter. Här är de vanligaste flaggorna som Ni kan kedja samman:

-u <unit> — filtrera efter systemd-enhet (till exempel nginx.service)
-p <priority> — filtrera efter syslog-prioritet (0=emerg … 7=debug)
--since / --until — tidsintervall
-n <N> — de senaste N raderna
--no-pager — inaktivera interaktiv sidvisning (nödvändigt i skript)
-o <format> — utdataformat (short, json, cat med flera)

Skicka alltid med --no-pager i icke-interaktiva skript så att journalctl inte försöker starta less och hänger sig.

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

Filtrera efter systemd-enhet

Flaggan -u accepterar alla giltiga enhetsnamn. Ni kan ange den flera gånger för att kombinera enheter, vilket är användbart när en enskild applikation omfattar flera tjänster (till exempel ett API och dess databas-sidecar).

Enhetsnamn följer mönstret <name>.service, <name>.socket, <name>.timer och så vidare. Globbing stöds: -u 'myapp*' matchar myapp-api.service, myapp-worker.service och så vidare.

I ett triageskript får Ni vanligtvis enhetsnamnet som ett argument, vilket gör filtret dynamiskt.

#!/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

Prioritetsnivåer och flaggan -p

Flaggan -p motsvarar standardiserade syslog-prioritetsnivåer:

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

Ni kan ange en enskild nivå (-p err) för att endast visa den nivån, eller ett intervall (-p emerg..err) för att fånga allt från nödlägen till fel — det vanligaste valet för automatiserad avisering.

Namngivna alias (err, warning, crit) kan användas tillsammans med numeriska värden.

#!/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

Filtrering efter tidsintervall med --since och --until

Tidsfilter är grunden för frågor som avgränsas till ett incidentintervall. journalctl accepterar flexibla, läsbara tidsangivelser:

Relativa: "10 minutes ago", "2 hours ago", "yesterday"
Absoluta: "2026-06-11 14:00:00"
Särskilda nyckelord: today, yesterday, -1h (kortform)

I deployskript är ett vanligt mönster att hämta tidsstämpeln precis före en deploy och sedan fråga journalen från den tidpunkten för att upptäcka regressioner som releasen har orsakat.

#!/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

Strukturerade utdata i JSON-format

För maskinläsbara pipelines anger ni -o json (ett JSON-objekt per rad, NDJSON) eller -o json-pretty (formaterat). Varje objekt innehåller alla journalfält:

MESSAGE — loggtexten
PRIORITY — numerisk prioritet (0–7)
_SYSTEMD_UNIT — enheten som genererade posten
__REALTIME_TIMESTAMP — mikrosekunder sedan epoken
_PID, _UID, _HOSTNAME — processmetadata

Ni kan skicka denna NDJSON-ström till jq för att extrahera, filtrera eller formatera om fält för efterföljande aviseringssystem som PagerDuty, Slack-webhooks eller SIEM-inkomponenter.

#!/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

Följ journalen i realtid

Flaggan -f gör att journalctl följer journalen live — på samma sätt som tail -f för en loggfil. Tillsammans med filter för enhet och prioritet blir detta en riktad övervakning i realtid.

I skriptade pipelines är det mer användbara mönstret markörbaserad avläsning: spara den aktuella journalmarkören och ange sedan --after-cursor=<cursor> vid varje avläsning för att endast läsa nya poster sedan den senaste kontrollen. På så sätt undviker ni att bearbeta gamla rader igen.

Hämta den senaste markören med --show-cursor -n 0 och tolka raden -- cursor: i utdata.

#!/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'

Frågor avgränsade till en uppstart med -b

Flaggan -b avgränsar en fråga till en specifik uppstartssession. Detta är viktigt efter en krasch eller oväntad omstart, när ni vill hämta loggar från den föregående uppstarten i stället för den aktuella.

-b 0 — aktuell uppstart (standard)
-b -1 — föregående uppstart
-b -2 — uppstarten dessförinnan
--list-boots — visa alla registrerade uppstartssessioner med tidsstämplar

För efteranalys dumpar skript ofta kritiska loggar från den föregående uppstarten (-b -1) för att diagnostisera varför systemet kraschade eller varför en tjänst inte startade.

#!/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

Sökning i journalctl jämfört med inbyggda matchningar

Ni kan ange ett obehandlat grep-mönster efter alla flaggor, men journalctl stöder även inbyggda fältmatchningar med syntaxen FIELD=value. Inbyggda matchningar jämförs mot strukturerad metadata — betydligt snabbare än att efterbearbeta text med grep.

Vanliga användbara matchningar:

_PID=1234 — loggar från en specifik process
_COMM=python3 — loggar från alla processer med namnet python3
SYSLOG_IDENTIFIER=myapp — loggar märkta med en anpassad identifierare

Flera argument av typen FIELD=value kombineras med AND; ett + mellan dem skapar ett OR. Använd -g <regex> för fulltextsökning med grep när strukturerad metadata inte räcker.

#!/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

Skapa en återanvändbar triagefunktion

När Ni behärskar de enskilda flaggorna kan Ni kombinera dem i en återanvändbar Bash-funktion, vilket håller triageskripten rena och konsekventa. En väl utformad funktion bör:

ta emot enhet, prioritetsintervall och tidsintervall som parametrar
använda säkra värden med låg brusnivå som standard när argument saknas
returnera en utgångskod som inte är noll när fel hittas (för integrering med CI-pipelines)
skriva resultat både till stdout och till en tidsstämplad loggfil för granskningsspår

#!/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"

Automatiserat incidenttriageskript

Följande kompletta skript sammanför alla koncept till ett praktiskt automatiserat triageverktyg. Det läser en lista över kritiska tjänster, frågar journalen för var och en under ett konfigurerbart återblicksintervall, sammanställer resultaten och avslutar med en felkod om några fel upptäcktes — vilket gör det lämpligt som cron-jobb eller som ett hälsokontrollsteg i en CI-pipeline.

#!/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}"

Kunskapskontroll: filtrering efter prioritetsintervall

Ni skriver ett skript som endast ska avisera jourtekniker när en tjänst loggar med fel allvarlighetsgrad eller högre (det vill säga error, critical, alert eller emergency). Vilken kombination av flaggor för journalctl fångar exakt detta intervall?

Besvara frågan i den interaktiva lektionen

Lektionssammanfattning: journalctl i skript

I den här lektionen har Ni lärt Er att programmatiskt fråga systemd-journalen för automatiserad incidenttriage:

Ange alltid --no-pager i skript för att förhindra interaktiv blockering.
Enhetsfiltrering (-u) avgränsar frågor till en eller flera tjänster; globbning och flera -u-flaggor stöds.
Prioritetsfiltrering (-p emerg..err) fångar endast de allvarlighetsnivåer Ni behöver — kom ihåg att lägre tal betyder högre allvarlighetsgrad.
Tidsintervall (--since / --until) begränsar loggutdata till ett deployintervall eller en återblicksperiod med läsbara tidsangivelser.
Uppstartsavgränsning (-b -1) gör att efteranalys-skript kan läsa loggar från en tidigare kraschsession.
JSON-utdata (-o json) och jq möjliggör strukturerade pipelines som matar aviserings- eller SIEM-system.
Markörbaserad avläsning med --after-cursor förhindrar att gamla poster bearbetas igen vid upprepade körningar.
Inbyggda fältmatchningar (_COMM=, SYSLOG_IDENTIFIER=) är snabbare än att skicka utdata till grep.

Genom att kombinera dessa flaggor i en återanvändbar Bash-funktion får Ni ett triageverktyg för produktionsmiljöer som smidigt kan integreras med cron, CI-pipelines och aviseringsflöden för jourtekniker.

Gratis att börja

Lär dig Bash med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 22
Lektioner: 88

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Fråga journald med journalctl i skript” gratis?

Ja – hela texten till ”Fråga journald med journalctl i skript” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Bemästra Linux-kommandoraden och Bash-skriptning, kan Ni uppgradera till CoddyKit PRO. Kursen i Bemästra Linux-kommandoraden och Bash-skriptning innehåller totalt 4 lektioner.

Vad lär jag mig i ”Fråga journald med journalctl i skript”?

Filtrera systemd-journalposter efter unit, prioritet och tid för automatiserad incidenttriage. Ni övar på Bemästra Linux-kommandoraden och Bash-skriptning med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Bemästra Linux-kommandoraden och Bash-skriptning?

Du behöver inga förkunskaper. Utbildningen i Bemästra Linux-kommandoraden och Bash-skriptning på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Fråga journald med journalctl i skript”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Bemästra Linux-kommandoraden och Bash-skriptning-lektionen?

Ja. Varje Bemästra Linux-kommandoraden och Bash-skriptning-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Analysera webb- och applikationsloggar i stor skala
Följ loggar i realtid och skapa strömmande aviseringar
Fråga journald med journalctl i skript
Beräkna mätvärden och histogram från loggströmmar

← Tillbaka till Bemästra Linux-kommandoraden och Bash-skriptning