การติดตามบันทึกแบบเรียลไทม์และการแจ้งเตือนแบบสตรีม
ติดตามและกรองกระแสบันทึกแบบสด เพื่อเรียกการแจ้งเตือนทันทีที่พบรูปแบบข้อผิดพลาด
การติดตามบันทึกแบบเรียลไทม์และการแจ้งเตือนแบบสตรีม เป็นบทเรียน Linux Command Line & Bash Scripting Mastery ฟรีบน CoddyKit นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Linux Command Line & Bash Scripting Mastery และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Linux Command Line & Bash Scripting Mastery มีบทเรียนทั้งหมด 4 บทเรียน
เหตุใดการติดตามบันทึกแบบเรียลไทม์จึงสำคัญ
ในระบบที่ใช้งานจริง ไฟล์บันทึกจะเพิ่มขึ้นอย่างต่อเนื่อง การรอให้มีผู้รายงานปัญหาก่อนตรวจสอบบันทึก หมายความว่าระบบหยุดทำงานจนสร้างความเสียหายไปแล้ว การติดตามบันทึกแบบเรียลไทม์ช่วยให้คุณดูเหตุการณ์ที่เกิดขึ้นได้ทันทีที่มีการเขียนข้อมูล ทำให้ตอบสนองต่อความล้มเหลว เหตุการณ์ด้านความปลอดภัย และประสิทธิภาพที่ลดลงได้อย่างฉับไว
- เว็บเซิร์ฟเวอร์เขียนหนึ่งบรรทัดต่อหนึ่งคำขอ — ข้อผิดพลาดจึงปรากฏทันที
- ดีมอนของแอปพลิเคชันบันทึกการติดตามสแตกทันทีที่เกิดข้อยกเว้น
- ระบบตรวจสอบสิทธิ์บันทึกความพยายามเข้าสู่ระบบที่ล้มเหลวแบบเรียลไทม์
เครื่องมือ Unix พื้นฐานสำหรับงานนี้คือ tail -f ซึ่งใช้ร่วมกับยูทิลิตีสำหรับการกรองและการแจ้งเตือน เพื่อเปลี่ยนกระแสบันทึกดิบให้เป็นสัญญาณที่นำไปดำเนินการได้
tail -f: การติดตามบันทึกที่กำลังเกิดขึ้น
tail -f (ติดตาม) จะเปิดไฟล์ค้างไว้และพิมพ์บรรทัดใหม่เมื่อมีการต่อท้ายข้อมูล เป็นเครื่องมือบันทึกแบบเรียลไทม์ที่เรียบง่ายและมีให้ใช้งานอย่างแพร่หลายที่สุด
รูปแบบการใช้งานที่พบบ่อย:
tail -f /var/log/syslog— ติดตามบันทึกระบบtail -n 50 -f app.log— แสดง 50 บรรทัดล่าสุดแล้วติดตามต่อtail -f /var/log/nginx/access.log— ติดตามคำขอของ nginx แบบเรียลไทม์
กด Ctrl+C เพื่อหยุด กระบวนการจะยังคงทำงานและเชื่อมต่ออยู่จนกว่าคุณจะยกเลิกหรือปิดเทอร์มินัล
#!/usr/bin/env bash
# Simulate a live log and follow it
LOGFILE='/tmp/demo_app.log'
# Write a header
echo '[INFO] Application started' >> "$LOGFILE"
# In a real scenario you would run:
# tail -f "$LOGFILE"
# Below we demonstrate tail showing the last 3 lines then exit
tail -n 3 "$LOGFILE"tail -F: รับมือการหมุนเวียนบันทึก
หลายระบบจะหมุนเวียนไฟล์บันทึกตอนเที่ยงคืนหรือเมื่อไฟล์มีขนาดถึงขีดจำกัด เมื่อเกิดเหตุการณ์นี้ ไฟล์เดิมจะถูกเปลี่ยนชื่อ (เช่น app.log.1) และสร้าง app.log ขึ้นใหม่ หากใช้ tail -f โปรแกรมจะอ่านไฟล์เดิมที่ถูกเปลี่ยนชื่ออย่างเงียบ ๆ ต่อไป ทำให้พลาดข้อมูลใหม่ทั้งหมด
tail -F (F ตัวพิมพ์ใหญ่) แก้ปัญหานี้ด้วยการเฝ้าดูชื่อไฟล์ ไม่ใช่ตัวระบุไฟล์ เมื่อไฟล์หายไปแล้วปรากฏขึ้นใหม่ tail -F จะเปิดไฟล์อีกครั้งโดยอัตโนมัติและติดตามต่อ
- ในสคริปต์ที่ใช้งานจริง ให้เลือก
tail -Fแทนtail -fเสมอ - ทำงานร่วมกับ logrotate, newsyslog และโปรแกรมควบคุมบันทึกของ Docker ที่หมุนเวียนไฟล์ได้
# Follow nginx access log, surviving log rotation
tail -F /var/log/nginx/access.log
# Follow multiple files simultaneously
tail -F /var/log/nginx/access.log /var/log/nginx/error.logการกรองกระแสข้อมูลด้วย grep
การติดตามบันทึกดิบที่มีข้อมูลหนาแน่นนั้นทำให้รับมือได้ยาก — เว็บเซิร์ฟเวอร์ที่มีการใช้งานสูงอาจเขียนหลายร้อยบรรทัดต่อวินาที ส่งผลลัพธ์ของ tail -F เข้า grep เพื่อแยกเฉพาะรูปแบบที่คุณสนใจ
ตัวเลือกสำคัญสำหรับ grep แบบสตรีม:
--line-buffered— ส่งแต่ละบรรทัดที่ตรงเงื่อนไขออกทันทีแทนการเก็บไว้ในบัฟเฟอร์ จำเป็นในสายงาน มิฉะนั้นผลลัพธ์อาจล่าช้าหรือสูญหาย-i— จับคู่โดยไม่คำนึงถึงตัวพิมพ์เล็กใหญ่-E— นิพจน์ทั่วไปแบบขยายสำหรับการเลือกหลายทาง (error|warn|crit)-v— กลับเงื่อนไขการจับคู่ (ไม่รวมบรรทัดที่ตรงเงื่อนไข)
# Show only ERROR and WARN lines from a live application log
tail -F /var/log/myapp/app.log | grep --line-buffered -Ei 'error|warn|critical'
# Follow nginx and exclude health-check requests
tail -F /var/log/nginx/access.log | grep --line-buffered -v '/health'การเพิ่มการประทับเวลาและบริบทด้วย awk
บางครั้งบรรทัดบันทึกไม่มีบริบทที่ช่วยคัดแยกเหตุขัดข้อง คุณสามารถเพิ่มข้อมูลให้กระแสข้อมูลแบบเรียลไทม์ด้วย awk — เช่น เพิ่มการประทับเวลาท้องถิ่น ดึงฟิลด์ หรือจัดรูปแบบผลลัพธ์ใหม่ให้อ่านง่าย
awk ยังทำงานในโหมดสตรีม (เก็บข้อมูลทีละบรรทัด) เมื่อรับข้อมูลผ่านการส่งต่อ ทำให้ใช้งานในสายงานแบบสดได้อย่างปลอดภัยโดยไม่ต้องระบุตัวเลือกเพิ่มเติม
# Prepend a reception timestamp to every ERROR line
tail -F /var/log/myapp/app.log | \
grep --line-buffered -i 'error' | \
awk '{ print strftime("[%Y-%m-%d %H:%M:%S]"), $0; fflush() }'
# Extract HTTP status code (field 9) and URL (field 7) from nginx combined log
tail -F /var/log/nginx/access.log | \
awk '{ print $9, $7; fflush() }' | \
grep --line-buffered '^5'การส่งการแจ้งเตือนด้วยเว็บฮุกของ Slack
การกรองเป็นเพียงครึ่งหนึ่งของงาน — เมื่อคุณตรวจพบรูปแบบข้อผิดพลาดแล้ว คุณต้องแจ้งให้ผู้อื่นทราบ เว็บฮุกขาเข้าของ Slack ช่วยให้คุณส่งข้อความไปยังช่องได้ด้วยการเรียก curl เพียงครั้งเดียว โดยไม่ต้องใช้ SDK ของ Slack หรือข้อมูลรับรองใด ๆ นอกเหนือจาก URL ของเว็บฮุก
รูปแบบคือ กรองกระแสข้อมูล แล้วส่ง HTTP POST สำหรับแต่ละบรรทัดที่ตรงเงื่อนไข
#!/usr/bin/env bash
# Real-time alert: send every ERROR line to a Slack channel
LOGFILE='/var/log/myapp/app.log'
WEBHOOK_URL='https://hooks.slack.com/services/T000/B000/XXXX'
tail -F "$LOGFILE" | grep --line-buffered -i 'error' | while IFS= read -r line; do
payload=$(printf '{"text":"*[ERROR ALERT]*\n%s"}' "$line")
curl -s -o /dev/null -X POST -H 'Content-Type: application/json' \
-d "$payload" "$WEBHOOK_URL"
doneการจำกัดอัตราการแจ้งเตือนเพื่อป้องกันสัญญาณรบกวน
กระแสบันทึกที่ท่วมท้นอาจสร้างบรรทัดข้อผิดพลาดนับพันภายในหนึ่งนาที การส่งข้อความ Slack หนึ่งข้อความต่อบรรทัดจะทำให้ช่องเต็มไปด้วยข้อความและทำให้ผู้รับเหนื่อยล้าจากการแจ้งเตือน คุณจึงต้องใช้การจำกัดอัตรา — แจ้งเตือนหนึ่งครั้ง แล้วระงับการแจ้งเตือนเพิ่มเติมชั่วคราวในช่วงพัก
ทำได้ด้วยไฟล์เก็บการประทับเวลาอย่างง่าย โดยบันทึกเวลาที่ส่งการแจ้งเตือนครั้งล่าสุด และข้ามการแจ้งเตือนหากช่วงพักยังไม่หมด
#!/usr/bin/env bash
# Alert on ERROR lines but no more than once every 60 seconds
LOGFILE='/var/log/myapp/app.log'
WEBHOOK_URL='https://hooks.slack.com/services/T000/B000/XXXX'
COOLDOWN=60
LAST_ALERT_FILE='/tmp/last_alert_ts'
tail -F "$LOGFILE" | grep --line-buffered -i 'error' | while IFS= read -r line; do
now=$(date +%s)
last=0
[ -f "$LAST_ALERT_FILE" ] && last=$(cat "$LAST_ALERT_FILE")
if (( now - last >= COOLDOWN )); then
echo "$now" > "$LAST_ALERT_FILE"
payload=$(printf '{"text":"*[ERROR ALERT]*\n%s"}' "$line")
curl -s -o /dev/null -X POST -H 'Content-Type: application/json' \
-d "$payload" "$WEBHOOK_URL"
echo "[$(date)] Alert sent: $line"
else
echo "[$(date)] Suppressed (cooldown): $line"
fi
doneการนับการปะทุของข้อผิดพลาดด้วยหน้าต่างเลื่อน
บางครั้งข้อผิดพลาดเพียงหนึ่งบรรทัดอาจไม่มีนัยสำคัญ — แต่ข้อผิดพลาด 20 รายการใน 30 วินาทีถือเป็นปัญหาร้ายแรง ตัวนับแบบหน้าต่างเลื่อนช่วยให้คุณเรียกการแจ้งเตือนเฉพาะเมื่ออัตราข้อผิดพลาดเกินเกณฑ์ ซึ่งช่วยลดผลบวกลวง
เทคนิคนี้เก็บการประทับเวลาแบบยุคของเหตุการณ์ที่ตรงเงื่อนไขแต่ละรายการไว้ในไฟล์ชั่วคราว จากนั้นนับว่ามีกี่รายการอยู่ภายในหน้าต่างเวลาก่อนตัดสินใจแจ้งเตือน
#!/usr/bin/env bash
# Alert when more than 10 errors occur within any 60-second window
LOGFILE='/var/log/myapp/app.log'
WINDOW=60
THRESHOLD=10
TS_FILE='/tmp/error_timestamps'
WEBHOOK_URL='https://hooks.slack.com/services/T000/B000/XXXX'
tail -F "$LOGFILE" | grep --line-buffered -i 'error' | while IFS= read -r line; do
now=$(date +%s)
echo "$now" >> "$TS_FILE"
# Keep only timestamps within the window
cutoff=$(( now - WINDOW ))
tmp=$(mktemp)
awk -v c="$cutoff" '$1 > c' "$TS_FILE" > "$tmp" && mv "$tmp" "$TS_FILE"
count=$(wc -l < "$TS_FILE")
if (( count > THRESHOLD )); then
msg="*[BURST ALERT]* ${count} errors in ${WINDOW}s — last: ${line}"
curl -s -o /dev/null -X POST -H 'Content-Type: application/json' \
-d "{\"text\":\"$msg\"}" "$WEBHOOK_URL"
# Clear to avoid re-alerting until next burst
> "$TS_FILE"
fi
donejournalctl -f: การติดตามบันทึกของ systemd
ในระบบ Linux รุ่นใหม่ (RHEL, Ubuntu 20.04 ขึ้นไป, Debian 10 ขึ้นไป) บริการต่าง ๆ จะเขียนข้อมูลลงบันทึก journal ของ systemdแทนไฟล์ข้อความทั่วไป journalctl -f เป็นเครื่องมือเทียบเท่า tail -F สำหรับบันทึก journal
ตัวเลือกที่มีประโยชน์:
-u myapp.service— ติดตามเฉพาะหน่วยที่ระบุ-p err— กรองตามระดับความสำคัญ (emerg, alert, crit, err, warning, notice, info, debug)--since '5 min ago'— เริ่มจากเวลาย้อนหลังที่สัมพันธ์กับปัจจุบัน-o json— ส่งออก JSON แบบมีโครงสร้างเพื่อให้เครื่องประมวลผล
# Follow only error-and-above entries for nginx
journalctl -f -u nginx.service -p err
# Stream journal as JSON and extract MESSAGE field with jq
journalctl -f -u myapp.service -o json | \
jq --unbuffered -r 'select(.PRIORITY <= "3") | .MESSAGE'multitail และการตรวจสอบหลายแหล่งด้วยสี
เมื่อต้องเฝ้าดูแหล่งบันทึกหลายแหล่งพร้อมกัน multitail จะแบ่งเทอร์มินัลเป็นช่องย่อย แต่ละช่องติดตามไฟล์หรือคำสั่งต่างกัน และสามารถกำหนดสีตามรูปแบบได้
หากยังไม่ได้ติดตั้ง multitail ทางเลือกแบบ BASH ล้วนที่มีน้ำหนักเบาคือเติมชื่อแหล่งข้อมูลไว้หน้ากระแสข้อมูลแต่ละชุด แล้วรวมทั้งหมดเป็นมุมมองเดียว
# multitail: watch nginx access + error + app log in split panes
# (requires: apt install multitail or brew install multitail)
multitail /var/log/nginx/access.log /var/log/nginx/error.log /var/log/myapp/app.log
# Pure-Bash alternative — merge three streams with labeled prefixes
(
tail -F /var/log/nginx/access.log | sed --unbuffered 's/^/[nginx-access] /' &
tail -F /var/log/nginx/error.log | sed --unbuffered 's/^/[nginx-error] /' &
tail -F /var/log/myapp/app.log | sed --unbuffered 's/^/[myapp] /' &
wait
)การสร้างดีมอนแจ้งเตือนแบบครบในตัว
เมื่อนำทุกอย่างในบทเรียนนี้มารวมกัน ดีมอนแจ้งเตือนระดับใช้งานจริงควรทำสิ่งต่อไปนี้:
- ติดตามไฟล์บันทึกอย่างทนทานด้วย
tail -F - กรองรูปแบบสำคัญด้วย
grepที่ใช้บัฟเฟอร์ - จำกัดอัตราการแจ้งเตือนเพื่อหลีกเลี่ยงความเหนื่อยล้าจากการแจ้งเตือน
- บันทึกกิจกรรมของตัวเองเพื่อให้คุณตรวจสอบได้ว่าส่งอะไรไปบ้าง
- ทำงานเป็นกระบวนการเบื้องหลังที่จัดการโดย systemd หรือโปรแกรมควบคุม
สคริปต์ด้านล่างเป็นดีมอนขนาดเล็กแต่ครบถ้วน ซึ่งคุณสามารถวางไว้ใน /usr/local/bin/ และจัดการด้วย systemd ได้
#!/usr/bin/env bash
# log_alert_daemon.sh — tail a log and fire Slack alerts with cooldown
set -euo pipefail
LOGFILE=${1:-'/var/log/myapp/app.log'}
PATTERN=${2:-'error|critical|fatal'}
WEBHOOK_URL=${SLACK_WEBHOOK_URL:?'Set SLACK_WEBHOOK_URL env var'}
COOLDOWN=${ALERT_COOLDOWN:-120}
DAEMON_LOG='/var/log/log_alert_daemon.log'
LAST_SENT_FILE='/tmp/log_alert_last_sent'
log() { echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" | tee -a "$DAEMON_LOG"; }
log "Starting alert daemon: watching $LOGFILE for pattern: $PATTERN"
tail -F "$LOGFILE" | grep --line-buffered -Ei "$PATTERN" | while IFS= read -r line; do
now=$(date +%s)
last=0
[ -f "$LAST_SENT_FILE" ] && last=$(cat "$LAST_SENT_FILE")
if (( now - last >= COOLDOWN )); then
echo "$now" > "$LAST_SENT_FILE"
msg=$(printf '{"text":"*[ALERT]* %s\n%s"}' "$(hostname)" "$line")
if curl -s -o /dev/null -w '%{http_code}' -X POST \
-H 'Content-Type: application/json' -d "$msg" "$WEBHOOK_URL" | grep -q '^200$'; then
log "Alert sent: $line"
else
log "Alert FAILED to send: $line"
fi
else
log "Suppressed (cooldown ${COOLDOWN}s): $line"
fi
doneตรวจสอบความรู้: สายงานบันทึกแบบสตรีม
ทดสอบความเข้าใจของคุณเกี่ยวกับการติดตามบันทึกแบบเรียลไทม์และการแจ้งเตือนแบบสตรีม
สายงาน Bash ติดตามไฟล์บันทึกและส่งการแจ้งเตือน Slack สำหรับทุกบรรทัดที่ตรงเงื่อนไข ระหว่างที่บันทึกท่วมท้น มีการเขียนบรรทัดข้อผิดพลาด 3,000 บรรทัดภายใน 10 วินาที การเปลี่ยนแปลงเพียงอย่างเดียวข้อใดช่วยป้องกันไม่ให้สคริปต์ส่งข้อความ 3,000 ข้อความจนท่วมช่อง Slack ได้ดีที่สุด
สรุปบทเรียน: การติดตามบันทึกแบบเรียลไทม์และการแจ้งเตือนแบบสตรีม
ในบทเรียนนี้ คุณได้สร้างสายงานตรวจสอบบันทึกแบบเรียลไทม์ที่ครบถ้วนตั้งแต่พื้นฐาน:
- tail -F ติดตามไฟล์บันทึกตามชื่อและรับมือการหมุนเวียนบันทึกได้ — ในระบบที่ใช้งานจริงให้เลือกใช้แทน
tail -fเสมอ - grep --line-buffered กรองกระแสข้อมูลสดโดยไม่เพิ่มเวลาแฝง — เพิ่มตัวเลือกนี้เสมอในคำสั่ง grep ที่ส่งต่อข้อมูล
- awk พร้อม fflush() เพิ่มการประทับเวลาหรือฟิลด์ที่ดึงออกมาให้แต่ละบรรทัดได้อย่างปลอดภัยในโหมดสตรีม
- เว็บฮุก Slack ผ่าน curl ส่งการแจ้งเตือนด้วย HTTP POST เพียงครั้งเดียว — ไม่จำเป็นต้องใช้ SDK
- ไฟล์ช่วงพัก ป้องกันความเหนื่อยล้าจากการแจ้งเตือนระหว่างบันทึกท่วมท้น โดยบังคับให้มีช่วงห่างขั้นต่ำระหว่างการแจ้งเตือน
- ตัวนับแบบหน้าต่างเลื่อน ตรวจจับการปะทุของข้อผิดพลาด (การแจ้งเตือนตามอัตรา) แทนการตอบสนองต่อทุกบรรทัด
- journalctl -f เป็นเครื่องมือเทียบเท่า tail -F แบบ native ของ systemd พร้อมการกรองตามระดับความสำคัญและการส่งออก JSON ในตัว
- สคริปต์ดีมอนแจ้งเตือนแบบครบในตัวรวมรูปแบบทั้งหมดนี้ไว้ด้วยกัน และสามารถจัดการโดย systemd เพื่อความน่าเชื่อถือในการใช้งานจริง
พื้นฐานเหล่านี้ประกอบกันเป็นรากฐานของสายงานตรวจสอบแบบกำหนดเองทุกประเภท โดยไม่ต้องใช้ตัวแทนจากผู้ให้บริการภายนอก
เรียนรู้ Bash ด้วย AI tutor — ฟรี
เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป
- คอร์ส
- 22
- บทเรียน
- 88
คำถามที่พบบ่อย
บทเรียน “การติดตามบันทึกแบบเรียลไทม์และการแจ้งเตือนแบบสตรีม” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “การติดตามบันทึกแบบเรียลไทม์และการแจ้งเตือนแบบสตรีม” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Linux Command Line & Bash Scripting Mastery ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Linux Command Line & Bash Scripting Mastery มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “การติดตามบันทึกแบบเรียลไทม์และการแจ้งเตือนแบบสตรีม”
ติดตามและกรองกระแสบันทึกแบบสด เพื่อเรียกการแจ้งเตือนทันทีที่พบรูปแบบข้อผิดพลาด คุณปฏิบัติ Linux Command Line & Bash Scripting Mastery ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Linux Command Line & Bash Scripting Mastery หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน Linux Command Line & Bash Scripting Mastery บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน
บทเรียน “การติดตามบันทึกแบบเรียลไทม์และการแจ้งเตือนแบบสตรีม” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน Linux Command Line & Bash Scripting Mastery นี้ได้ไหม
ได้ บทเรียน Linux Command Line & Bash Scripting Mastery ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- การแยกวิเคราะห์บันทึกเว็บและแอปพลิเคชันในระดับใหญ่
- การติดตามบันทึกแบบเรียลไทม์และการแจ้งเตือนแบบสตรีม
- การสอบถาม journald ด้วย journalctl ในสคริปต์
- การคำนวณตัวชี้วัดและฮิสโตแกรมจากกระแสบันทึก