Kem Intensif DevOps · Pelajaran

Membuat Pertanyaan journald dengan journalctl dalam Skrip

Tapis entri jurnal systemd mengikut unit, keutamaan dan masa untuk triage insiden automatik

Pelajaran 3 daripada 413 langkah

Membuat Pertanyaan journald dengan journalctl dalam Skrip ialah pelajaran Kem Intensif DevOps percuma di CoddyKit. Ini ialah pelajaran 3 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Kem Intensif DevOps, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Kem Intensif DevOps merangkumi sejumlah 4 pelajaran.

Mengapa journald untuk Penilaian Awal Insiden?

Sistem Linux moden yang menjalankan systemd memusatkan semua output log dalam jurnal — stor log binari berstruktur yang diurus oleh systemd-journald. Tidak seperti fail teks biasa dalam /var/log, setiap entri jurnal membawa metadata yang kaya: nama unit, tahap keutamaan, PID, UID, cap masa dan banyak lagi.

Dalam skrip penilaian awal insiden automatik, metadata ini membolehkan Anda:

Menapis log kepada satu perkhidmatan tanpa rangkaian grep
Mengehadkan pertanyaan kepada tetingkap masa yang tepat (15 minit terakhir, sejak pelancaran)
Mengeluarkan hanya mesej kritikal/ralat dan mengabaikan gangguan
Menyalurkan output berstruktur terus ke dalam saluran paip amaran

Alat yang menyediakan semua fungsi ini ialah journalctl. Pelajaran ini mengajar Anda mengawalnya secara teratur dalam skrip Bash.

Panggilan Asas journalctl

Bentuk paling ringkas journalctl membuang keseluruhan jurnal. Dalam skrip, Anda hampir tidak pernah memerlukannya — sentiasa tambahkan sekurang-kurangnya satu penapis. Berikut ialah bendera paling biasa yang akan Anda rangkaikan:

-u <unit> — tapis mengikut unit systemd (contohnya nginx.service)
-p <priority> — tapis mengikut keutamaan syslog (0=emerg … 7=debug)
--since / --until — tetingkap masa
-n <N> — N baris terakhir
--no-pager — nyahdayakan penomboran interaktif (penting dalam skrip)
-o <format> — format output (short, json, cat dan sebagainya)

Sentiasa berikan --no-pager dalam skrip bukan interaktif supaya journalctl tidak cuba memanggil less lalu tergantung.

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

Menapis Mengikut Unit Systemd

Bendera -u menerima sebarang nama unit yang sah. Anda boleh membekalkannya beberapa kali untuk menggabungkan unit, yang berguna apabila satu aplikasi merentasi beberapa perkhidmatan (contohnya API dan pendamping pangkalan datanya).

Nama unit mengikut corak <name>.service, <name>.socket, <name>.timer dan sebagainya. Pencorakan glob disokong: -u 'myapp*' sepadan dengan myapp-api.service, myapp-worker.service dan lain-lain.

Dalam skrip penilaian awal, Anda biasanya menerima nama unit sebagai argumen, menjadikan penapis itu dinamik.

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

Tahap PRIORITY dan Bendera -p

Bendera -p dipetakan kepada tahap PRIORITY syslog standard:

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

Anda boleh menentukan satu tahap (-p err) untuk melihat tahap itu sahaja, atau julat (-p emerg..err) untuk menangkap segala-galanya daripada kecemasan hingga ralat — pilihan yang paling biasa untuk pemberitahuan automatik.

Alias bernama (err, warning, crit) diterima bersama nilai berangka.

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

Penapisan Tetingkap Masa dengan --since dan --until

Penapis masa ialah asas pertanyaan tetingkap insiden. journalctl menerima cap masa yang fleksibel dan mudah dibaca manusia:

Relatif: "10 minutes ago", "2 hours ago", "yesterday"
Mutlak: "2026-06-11 14:00:00"
Kata kunci khas: today, yesterday, -1h (bentuk ringkas)

Dalam skrip pelancaran, corak yang biasa digunakan ialah menangkap cap masa sejurus sebelum pelancaran, kemudian membuat pertanyaan jurnal bermula dari titik itu untuk mengesan regresi yang diperkenalkan oleh keluaran tersebut.

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

Output Berstruktur dengan Format JSON

Untuk pipeline yang boleh dibaca mesin, hantarkan -o json (satu objek JSON bagi setiap baris, NDJSON) atau -o json-pretty (diformatkan). Setiap objek mengandungi semua FIELD jurnal:

MESSAGE — teks log
PRIORITY — PRIORITY berangka (0–7)
_SYSTEMD_UNIT — unit asal
__REALTIME_TIMESTAMP — mikrosaat sejak epok
_PID, _UID, _HOSTNAME — metadata proses

Anda boleh menyalurkan strim NDJSON ini ke dalam jq untuk mengekstrak, menapis atau memformat semula FIELD bagi sistem pemberitahuan hiliran seperti PagerDuty, webhook Slack atau penginges SIEM.

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

Mengikuti Jurnal dalam Masa Nyata

Bendera -f membuat journalctl mengikuti jurnal secara langsung — serupa dengan tail -f pada file log. Apabila digabungkan dengan penapis unit dan PRIORITY, ini menjadi pemantau masa nyata yang disasarkan.

Dalam pipeline berskrip, corak yang lebih berguna ialah pengundian berasaskan kursor: simpan kursor jurnal semasa, kemudian pada setiap pengundian hantarkan --after-cursor=<cursor> untuk membaca entri baharu sahaja sejak pemeriksaan terakhir. Ini mengelakkan pemprosesan semula baris lama.

Dapatkan kursor terkini dengan --show-cursor -n 0 dan hurai baris -- cursor: daripada output.

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

Pertanyaan Berskop But dengan -b

Bendera -b mengehadkan skop pertanyaan kepada sesi but tertentu. Ini penting selepas ranap atau but semula yang tidak dijangka, supaya log daripada but sebelumnya boleh diperoleh dan bukannya log daripada but semasa.

-b 0 — but semasa (lalai)
-b -1 — but sebelumnya
-b -2 — dua but yang lalu
--list-boots — paparkan semua sesi but yang direkodkan bersama cap masa

Skrip bedah siasat biasanya membuang log kritikal daripada but sebelumnya (-b -1) untuk mendiagnosis sebab sistem ranap atau sebab perkhidmatan gagal ketika dimulakan.

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

Menggunakan grep dalam journalctl berbanding Padanan Asli

Anda boleh menghantar corak mentah grep selepas semua bendera, tetapi journalctl juga menyokong padanan FIELD asli menggunakan sintaks FIELD=value. Padanan asli dinilai terhadap metadata berstruktur — jauh lebih pantas daripada memproses teks selepas itu dengan grep.

Padanan berguna yang biasa:

_PID=1234 — log daripada proses tertentu
_COMM=python3 — log daripada mana-mana proses bernama python3
SYSLOG_IDENTIFIER=myapp — log yang ditandai dengan pengecam tersuai

Beberapa argumen FIELD=value digabungkan dengan AND; tanda + di antaranya menghasilkan OR. Gunakan -g <regex> untuk grep teks penuh apabila metadata berstruktur tidak mencukupi.

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

Membina Fungsi Triage yang Boleh Digunakan Semula

Setelah anda menguasai bendera individu, menggabungkannya ke dalam fungsi Bash yang boleh digunakan semula menjadikan skrip triage anda kemas dan konsisten. Fungsi yang direka bentuk dengan baik hendaklah:

Menerima unit, julat PRIORITY dan tetingkap masa sebagai parameter
Menggunakan nilai lalai yang selamat dan kurang hingar apabila argumen tidak diberikan
Mengembalikan kod keluar bukan sifar apabila ralat ditemui (berintegrasi dengan pipeline CI)
Menulis penemuan kepada stdout dan juga file log bercap masa untuk jejak audit

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

Skrip Triage Insiden Automatik

Skrip lengkap berikut menggabungkan semua konsep menjadi alat triage automatik yang praktikal. Skrip ini membaca senarai perkhidmatan kritikal, membuat pertanyaan jurnal bagi setiap perkhidmatan dalam tetingkap lihat kembali yang boleh dikonfigurasi, mengagregatkan penemuan dan keluar dengan kod kegagalan jika sebarang ralat dikesan — menjadikannya sesuai sebagai kerja cron atau langkah pemeriksaan kesihatan CI.

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

Semakan Pengetahuan: Penapisan Julat PRIORITY

Anda sedang menulis skrip untuk memberi pemberitahuan kepada jurutera bertugas hanya apabila sesuatu perkhidmatan mencatat mesej pada tahap ralat atau lebih teruk (iaitu ralat, kritikal, amaran atau kecemasan). Gabungan bendera journalctl manakah yang menangkap julat tepat tersebut?

Jawab dalam pelajaran interaktif

Imbas Kembali Pelajaran: journalctl dalam Skrip

Dalam pelajaran ini, anda mempelajari cara membuat pertanyaan jurnal systemd secara programatik untuk triage insiden automatik:

Sentiasa hantarkan --no-pager dalam skrip untuk mengelakkan sekatan interaktif.
Penapisan unit (-u) mengehadkan skop pertanyaan kepada satu atau lebih perkhidmatan; penggunaan glob dan beberapa bendera -u disokong.
Penapisan PRIORITY (-p emerg..err) menangkap hanya tahap keterukan yang anda perlukan — ingat bahawa nombor yang lebih rendah adalah lebih teruk.
Tetingkap masa (--since / --until) mengasingkan output log kepada tetingkap pelancaran atau tempoh lihat kembali menggunakan cap masa yang mudah dibaca manusia.
Penskopan but (-b -1) membolehkan skrip bedah siasat membaca log daripada sesi ranap sebelumnya.
Output JSON (-o json) dan jq membolehkan pipeline berstruktur yang menyalurkan data kepada sistem pemberitahuan atau SIEM.
Pengundian berasaskan kursor dengan --after-cursor mengelakkan pemprosesan semula entri lama pada larian berulang.
Padanan FIELD asli (_COMM=, SYSLOG_IDENTIFIER=) lebih pantas daripada menyalurkan data kepada grep.

Menggabungkan bendera ini dalam fungsi Bash yang boleh digunakan semula memberikan anda alat triage bertaraf pengeluaran yang berintegrasi dengan kemas dengan cron, pipeline CI dan aliran kerja pemberitahuan jurutera bertugas.

Percuma untuk bermula

Pelajari Kem Intensif DevOps dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 142
Pelajaran: 568

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Membuat Pertanyaan journald dengan journalctl dalam Skrip” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Kem Intensif DevOps, termasuk “Membuat Pertanyaan journald dengan journalctl dalam Skrip”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Kem Intensif DevOps merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Membuat Pertanyaan journald dengan journalctl dalam Skrip”?

Tapis entri jurnal systemd mengikut unit, keutamaan dan masa untuk triage insiden automatik Anda berlatih Kem Intensif DevOps menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Kem Intensif DevOps?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Kem Intensif DevOps di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 4.

Berapa lamakah pelajaran “Membuat Pertanyaan journald dengan journalctl dalam Skrip” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Kem Intensif DevOps ini?

Ya. Setiap pelajaran Kem Intensif DevOps menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

Menghuraikan Log Web dan Aplikasi pada Skala Besar
Mengikuti Log Masa Nyata dan Menstrim Amaran
Membuat Pertanyaan journald dengan journalctl dalam Skrip
Mengira Metrik dan Histogram daripada Aliran Log

← Kembali ke Kem Intensif DevOps