Linux Command Line & Bash Scripting Mastery · Pelajaran

Mengkueri journald dengan journalctl dalam Skrip

Saring entri jurnal systemd berdasarkan unit, prioritas, dan waktu untuk melakukan triase insiden secara otomatis.

Pelajaran 3 dari 413 langkah

Mengkueri journald dengan journalctl dalam Skrip adalah pelajaran Linux Command Line & Bash Scripting Mastery gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Linux Command Line & Bash Scripting Mastery, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Linux Command Line & Bash Scripting Mastery mencakup 4 pelajaran total.

Mengapa journald untuk Triase Insiden?

Sistem Linux modern yang menjalankan systemd memusatkan semua keluaran log dalam jurnal — penyimpanan log biner terstruktur yang dikelola oleh systemd-journald. Tidak seperti file teks biasa di /var/log, setiap entri jurnal membawa metadata yang kaya: nama unit, tingkat prioritas, PID, UID, cap waktu, dan lainnya.

Dalam skrip triase insiden otomatis, metadata ini memungkinkan Anda untuk:

Menyaring log ke satu layanan tanpa rangkaian grep
Membatasi kueri pada jendela waktu yang tepat (15 menit terakhir, sejak penerapan)
Mengeluarkan hanya pesan kritis/galat dan mengabaikan kebisingan
Memasukkan keluaran terstruktur langsung ke pipeline pemberian peringatan

Alat yang menyediakan semua kemampuan ini adalah journalctl. Pelajaran ini mengajarkan Anda cara mengendalikannya secara terprogram di dalam skrip Bash.

Pemanggilan Dasar journalctl

Bentuk paling sederhana dari journalctl membuang seluruh isi jurnal. Dalam skrip, Anda hampir tidak pernah menginginkan hal itu — selalu tambahkan setidaknya satu penyaring. Berikut opsi yang paling umum dirangkai:

-u <unit> — saring berdasarkan unit systemd (misalnya nginx.service)
-p <priority> — saring berdasarkan prioritas syslog (0=emerg … 7=debug)
--since / --until — jendela waktu
-n <N> — N baris terakhir
--no-pager — nonaktifkan penomoran halaman interaktif (penting dalam skrip)
-o <format> — format keluaran (short, json, cat, dan sebagainya)

Selalu teruskan --no-pager dalam skrip noninteraktif agar journalctl tidak mencoba menjalankan less dan terhenti.

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

Menyaring Berdasarkan Unit Systemd

Opsi -u menerima nama unit apa pun yang valid. Anda dapat memberikannya beberapa kali untuk menggabungkan unit, yang berguna ketika satu aplikasi mencakup beberapa layanan (misalnya API dan pendamping basis datanya).

Nama unit mengikuti pola <name>.service, <name>.socket, <name>.timer, dan sebagainya. Pencocokan pola global didukung: -u 'myapp*' cocok dengan myapp-api.service, myapp-worker.service, dan seterusnya.

Dalam skrip triase, biasanya Anda menerima nama unit sebagai argumen, sehingga penyaringnya bersifat dinamis.

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

Tingkat Prioritas dan Flag -p

Flag -p dipetakan ke tingkat prioritas syslog standar:

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

Anda dapat menentukan satu tingkat (-p err) untuk hanya melihat tingkat tersebut, atau rentang (-p emerg..err) untuk menangkap semua hal mulai dari kondisi darurat hingga kesalahan — pilihan yang paling umum untuk pemberian peringatan otomatis.

Alias bernama (err, warning, crit) dapat digunakan bersama nilai numerik.

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

Pemfilteran Rentang Waktu dengan --since dan --until

Filter waktu merupakan dasar kueri rentang waktu insiden. journalctl menerima cap waktu fleksibel yang mudah dibaca manusia:

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

Dalam skrip penerapan, pola yang umum adalah mengambil cap waktu tepat sebelum penerapan, lalu melakukan kueri jurnal mulai dari titik tersebut untuk mendeteksi regresi yang diperkenalkan oleh rilis 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 Terstruktur dengan Format JSON

Untuk alur yang dapat dibaca mesin, teruskan -o json (satu objek JSON per baris, NDJSON) atau -o json-pretty (berformat). Setiap objek berisi semua bidang jurnal:

MESSAGE — teks catatan
PRIORITY — prioritas numerik (0–7)
_SYSTEMD_UNIT — unit asal
__REALTIME_TIMESTAMP — mikrodetik sejak epoch
_PID, _UID, _HOSTNAME — metadata proses

Anda dapat menyalurkan aliran NDJSON ini ke jq untuk mengekstrak, memfilter, atau memformat ulang bidang untuk sistem pemberi peringatan lanjutan seperti PagerDuty, webhook Slack, atau pengumpul 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 Secara Real-Time

Flag -f membuat journalctl menampilkan jurnal secara langsung — serupa dengan tail -f pada berkas catatan. Jika digabungkan dengan filter unit dan prioritas, fitur ini menjadi pemantau real-time yang terarah.

Dalam alur berskrip, pola yang lebih berguna adalah polling berbasis kursor: simpan kursor jurnal saat ini, lalu pada setiap polling teruskan --after-cursor=<cursor> untuk membaca hanya entri baru sejak pemeriksaan terakhir. Dengan begitu, baris lama tidak diproses ulang.

Ambil kursor terbaru dengan --show-cursor -n 0 dan uraikan baris -- cursor: dari 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'

Kueri Berdasarkan Boot dengan -b

Flag -b membatasi kueri ke sesi boot tertentu. Ini penting setelah kerusakan atau boot ulang yang tidak terduga, agar Anda dapat mengambil catatan dari boot sebelumnya, bukan boot saat ini.

-b 0 — boot saat ini (bawaan)
-b -1 — boot sebelumnya
-b -2 — dua boot sebelumnya
--list-boots — tampilkan semua sesi boot yang tercatat beserta cap waktunya

Skrip post-mortem biasanya mencadangkan catatan kritis dari boot sebelumnya (-b -1) untuk mendiagnosis alasan sistem mengalami kerusakan atau layanan gagal saat dimulai.

#!/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 di Dalam journalctl vs Pencocokan Bawaan

Anda dapat meneruskan pola mentah grep setelah semua flag, tetapi journalctl juga mendukung pencocokan bidang bawaan menggunakan sintaks FIELD=value. Pencocokan bawaan dievaluasi terhadap metadata terstruktur — jauh lebih cepat daripada memproses teks setelahnya dengan grep.

Pencocokan umum yang berguna:

_PID=1234 — catatan dari proses tertentu
_COMM=python3 — catatan dari proses apa pun yang bernama python3
SYSLOG_IDENTIFIER=myapp — catatan yang diberi tag pengenal khusus

Beberapa argumen FIELD=value digabungkan dengan AND; tanda + di antaranya membuat OR. Gunakan -g <regex> untuk grep teks lengkap jika metadata terstruktur 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

Membangun Fungsi Triage yang Dapat Digunakan Ulang

Setelah menguasai setiap flag, menggabungkannya menjadi fungsi Bash yang dapat digunakan ulang akan membuat skrip triage Anda tetap rapi dan konsisten. Fungsi yang dirancang dengan baik seharusnya:

Menerima unit, rentang prioritas, dan rentang waktu sebagai parameter
Menggunakan nilai bawaan yang aman dan minim gangguan ketika argumen tidak diberikan
Mengembalikan kode keluar bukan nol ketika ditemukan kesalahan (terintegrasi dengan alur CI)
Menulis temuan ke stdout dan berkas catatan bercap waktu 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 Otomatis

Skrip lengkap berikut menggabungkan semua konsep menjadi alat triage otomatis yang praktis. Skrip ini membaca daftar layanan kritis, melakukan kueri jurnal untuk setiap layanan dalam rentang waktu penelusuran yang dapat dikonfigurasi, mengumpulkan temuan, dan keluar dengan kode kegagalan jika terdeteksi kesalahan apa pun — sehingga cocok digunakan sebagai tugas cron atau langkah pemeriksaan kesehatan 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}"

Pemeriksaan Pengetahuan: Pemfilteran Rentang Prioritas

Anda sedang menulis skrip untuk memberi tahu teknisi yang bertugas hanya ketika suatu layanan mencatat pesan dengan tingkat keparahan kesalahan atau yang lebih parah (yaitu kesalahan, kritis, peringatan, atau darurat). Kombinasi flag journalctl manakah yang tepat untuk menangkap rentang tersebut secara persis?

Jawab di pelajaran interaktif

Ringkasan Pelajaran: journalctl dalam Skrip

Dalam pelajaran ini, Anda mempelajari cara melakukan kueri jurnal systemd secara terprogram untuk triage insiden otomatis:

Selalu teruskan --no-pager dalam skrip untuk mencegah pemblokiran interaktif.
Pemfilteran unit (-u) membatasi kueri ke satu atau beberapa layanan; penggunaan glob dan beberapa flag -u didukung.
Pemfilteran prioritas (-p emerg..err) hanya menangkap tingkat keparahan yang Anda perlukan — ingat bahwa angka yang lebih rendah berarti tingkat keparahan yang lebih tinggi.
Rentang waktu (--since / --until) membatasi output catatan ke rentang penerapan atau periode penelusuran menggunakan cap waktu yang mudah dibaca manusia.
Pembatasan boot (-b -1) memungkinkan skrip post-mortem membaca catatan dari sesi kerusakan sebelumnya.
Output JSON (-o json) dan jq memungkinkan alur terstruktur yang memasok data ke sistem pemberi peringatan atau sistem SIEM.
Polling berbasis kursor dengan --after-cursor mencegah entri lama diproses ulang pada proses yang berulang.
Pencocokan bidang bawaan (_COMM=, SYSLOG_IDENTIFIER=) lebih cepat daripada menyalurkan data ke grep.

Menggabungkan flag ini dalam fungsi Bash yang dapat digunakan ulang memberi Anda alat triage siap produksi yang terintegrasi dengan rapi bersama cron, alur CI, dan alur kerja pemberian peringatan kepada petugas yang sedang berjaga.

Gratis untuk memulai

Belajar Bash dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus: 22
Pelajaran: 88

Mulai belajar gratis Lihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Mengkueri journald dengan journalctl dalam Skrip” gratis?

Ya — teks lengkap “Mengkueri journald dengan journalctl dalam Skrip” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Linux Command Line & Bash Scripting Mastery, upgrade ke CoddyKit PRO. Kursus Linux Command Line & Bash Scripting Mastery mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Mengkueri journald dengan journalctl dalam Skrip”?

Saring entri jurnal systemd berdasarkan unit, prioritas, dan waktu untuk melakukan triase insiden secara otomatis. Kamu berlatih Linux Command Line & Bash Scripting Mastery dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Linux Command Line & Bash Scripting Mastery?

Tidak diperlukan pengalaman sebelumnya. Linux Command Line & Bash Scripting Mastery di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “Mengkueri journald dengan journalctl dalam Skrip” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Linux Command Line & Bash Scripting Mastery ini?

Ya. Setiap pelajaran Linux Command Line & Bash Scripting Mastery menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

Mengurai Log Web dan Aplikasi dalam Skala Besar
Mengikuti Log secara Real-Time dan Mengalirkan Peringatan
Mengkueri journald dengan journalctl dalam Skrip
Menghitung Metrik dan Histogram dari Aliran Log

← Kembali ke Linux Command Line & Bash Scripting Mastery