Linux Command Line & Bash Scripting Mastery · Pelajaran

Membangun Skrip Pemeriksaan Kesehatan Sistem dan Peringatan

Kumpulkan metrik beban, memori, dan disk, lalu picu peringatan berdasarkan ambang batas dari skrip terjadwal.

Pelajaran 4 dari 413 langkah

Membangun Skrip Pemeriksaan Kesehatan Sistem dan Peringatan adalah pelajaran Linux Command Line & Bash Scripting Mastery gratis di CoddyKit. Ini adalah pelajaran 4 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 Pemeriksaan Kesehatan Sistem Penting

Server produksi dapat mengalami penurunan kinerja secara diam-diam. Lonjakan CPU, kebocoran memori, dan disk yang penuh menyebabkan gangguan — tetapi hanya jika tidak ada yang menyadarinya tepat waktu. Skrip pemeriksaan kesehatan sistem mengotomatiskan siklus pemantauan: mengumpulkan metrik, membandingkannya dengan ambang batas, dan mengirimkan peringatan sebelum pengguna merasakan dampaknya.

Dijadwalkan melalui cron, skrip berjalan setiap beberapa menit tanpa perhatian manusia
Menghasilkan keluaran yang konsisten dan memiliki penanda waktu, sehingga cocok untuk penggabungan log
Logika berbasis ambang batas membuat peringatan tetap bermakna — tidak setiap gangguan kecil menghubungi tim yang sedang bertugas

Dalam pelajaran ini, Anda akan membangun skrip pemeriksaan kesehatan siap produksi dari awal, lapis demi lapis, yang mencakup rata-rata beban, tekanan memori, dan penggunaan disk.

Mengambil Rata-Rata Beban

Linux menyediakan rata-rata beban 1 menit, 5 menit, dan 15 menit melalui /proc/loadavg dan perintah uptime. Untuk pembuatan skrip, /proc/loadavg adalah sumber yang paling bersih — tanpa masalah lokal dan tanpa variasi penguraian antar-distro.

Cuplikan di bawah membaca rata-rata beban 1 menit dan menyimpannya dalam variabel untuk dibandingkan dengan ambang batas. cut mengambil bidang pertama; awk menghapus bagian desimal untuk perbandingan bilangan bulat menggunakan bc untuk aritmetika pecahan.

#!/usr/bin/env bash
# Read 1-minute load average from /proc/loadavg
LOAD_RAW=$(cut -d' ' -f1 /proc/loadavg)
echo "Raw load average: $LOAD_RAW"

# Number of CPU cores — used to normalise load
CPU_CORES=$(nproc)
echo "CPU cores: $CPU_CORES"

# Compute load percentage (load / cores * 100) using bc
LOAD_PCT=$(echo "scale=2; $LOAD_RAW / $CPU_CORES * 100" | bc)
echo "Load %: $LOAD_PCT"

Membandingkan Ambang Batas dengan Nilai Pecahan

Bash tidak dapat membandingkan bilangan pecahan secara bawaan — [ 1.5 -gt 1.2 ] akan menghasilkan kesalahan. Dua solusi idiomatisnya adalah:

bc — menghasilkan 1 (benar) atau 0 (salah) dari ekspresi perbandingan
awk — dapat mengevaluasi kondisi pecahan di dalam alur

Menggunakan bc membuat logika mudah dibaca dan diuji. Pola $(echo "$A > $B" | bc) menghasilkan 1 ketika kondisi terpenuhi, yang Anda uji dengan [ ... -eq 1 ].

#!/usr/bin/env bash
LOAD_RAW=$(cut -d' ' -f1 /proc/loadavg)
CPU_CORES=$(nproc)
THRESHOLD=80  # alert when load % exceeds 80%

LOAD_PCT=$(echo "scale=2; $LOAD_RAW / $CPU_CORES * 100" | bc)

# bc returns 1 if the expression is true
if [ "$(echo "$LOAD_PCT > $THRESHOLD" | bc)" -eq 1 ]; then
    echo "ALERT: Load is ${LOAD_PCT}% (threshold ${THRESHOLD}%)"
else
    echo "OK: Load is ${LOAD_PCT}%"
fi

Mengumpulkan Metrik Memori

/proc/meminfo adalah sumber otoritatif untuk statistik memori di Linux. Bidang penting:

MemTotal — total RAM fisik dalam kB
MemAvailable — perkiraan kB yang tersedia untuk alokasi baru tanpa melakukan swapping (lebih baik daripada MemFree)

awk dengan pencocokan pola adalah cara paling bersih untuk mengekstrak nilai-nilai ini. Membagi MemAvailable dengan MemTotal lalu mengurangkannya dari 100 menghasilkan persentase memori yang digunakan, yang menjadi dasar ambang batas peringatan.

#!/usr/bin/env bash
# Extract memory figures from /proc/meminfo (values in kB)
MEM_TOTAL=$(awk '/^MemTotal:/ {print $2}' /proc/meminfo)
MEM_AVAIL=$(awk '/^MemAvailable:/ {print $2}' /proc/meminfo)

# Used memory percentage
MEM_USED_PCT=$(echo "scale=2; (1 - $MEM_AVAIL / $MEM_TOTAL) * 100" | bc)

echo "Total RAM : ${MEM_TOTAL} kB"
echo "Available : ${MEM_AVAIL} kB"
echo "Used      : ${MEM_USED_PCT}%"

Mengumpulkan Metrik Penggunaan Disk

Perintah df melaporkan penggunaan sistem berkas. Untuk pembuatan skrip, dua tanda berikut penting:

-h — ukuran yang mudah dibaca manusia (hanya untuk tampilan; hindari dalam aritmetika)
--output=pcent,target — kolom yang dapat diurai mesin (GNU coreutils)

Melakukan iterasi pada semua sistem berkas yang terpasang memungkinkan skrip menandai partisi mana pun yang hampir penuh secara kritis, bukan hanya /. Tanda % dihapus dengan tr -d '%' sebelum perbandingan bilangan bulat.

#!/usr/bin/env bash
DISK_THRESHOLD=85

# Skip header line with tail -n +2
# --output=pcent,target gives "85% /var" style lines
df --output=pcent,target | tail -n +2 | while read -r USED_PCT MOUNT; do
    # Remove the % sign for arithmetic
    USED_INT=${USED_PCT//%/}

    if [ "$USED_INT" -ge "$DISK_THRESHOLD" ]; then
        echo "ALERT: Disk $MOUNT is ${USED_PCT} full"
    else
        echo "OK   : Disk $MOUNT is ${USED_PCT} full"
    fi
done

Keluaran Peringatan Terstruktur dengan Penanda Waktu

Pesan peringatan tanpa penanda waktu hampir tidak berguna dalam file log atau laporan email. Awalan yang konsisten membuat penguraian log menjadi mudah dengan grep atau agen pengiriman log.

Definisikan fungsi peringatan kecil di bagian atas skrip Anda. Fungsi ini menambahkan penanda waktu ISO-8601, tingkat keparahan, dan nama pemeriksaan di awal pesan. Semua peringatan ditulis ke stdout dan file log melalui tee.

date -u +"%Y-%m-%dT%H:%M:%SZ" — penanda waktu UTC yang tidak bergantung pada lokal
Menulis ke stderr untuk ALERT dan ke stdout untuk OK memisahkan sinyal dari gangguan dalam alur

#!/usr/bin/env bash
LOG_FILE="/var/log/healthcheck.log"

alert() {
    local LEVEL="$1"   # OK | WARN | ALERT
    local CHECK="$2"
    local MSG="$3"
    local TS
    TS=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
    local LINE="[$TS] [$LEVEL] [$CHECK] $MSG"

    if [ "$LEVEL" = "ALERT" ]; then
        echo "$LINE" | tee -a "$LOG_FILE" >&2
    else
        echo "$LINE" | tee -a "$LOG_FILE"
    fi
}

# Usage examples
alert "OK"    "DISK"  "/ is 42% full"
alert "ALERT" "DISK"  "/var is 91% full"

Mengirim Peringatan Email dengan mail dan sendmail

Mekanisme pemberian peringatan di server yang paling sederhana adalah email melalui MTA lokal (postfix, sendmail, atau msmtp). Perintah mail (dari mailutils atau bsd-mailx) menyusun dan mengirimkan pesan dalam satu baris.

-s — baris subjek
Salurkan isi pesan melalui stdin
Pada server tanpa MTA lokal, ganti mail dengan pemanggilan curl ke API email transaksional

Lindungi pengiriman dengan kunci deduplikasi agar satu kondisi yang berisik tidak membanjiri kotak masuk.

#!/usr/bin/env bash
ALERT_EMAIL="ops@example.com"
LOCK_DIR="/tmp/healthcheck_locks"
mkdir -p "$LOCK_DIR"

send_alert() {
    local CHECK="$1"
    local MSG="$2"
    local LOCK="$LOCK_DIR/${CHECK}.lock"

    # Only send if no lock exists (prevents repeated emails within the hour)
    if [ ! -f "$LOCK" ]; then
        echo "$MSG" | mail -s "[ALERT] $CHECK on $(hostname)" "$ALERT_EMAIL"
        touch "$LOCK"
        # Lock expires after 1 hour via cron or find+delete
        echo "Alert sent for $CHECK"
    else
        echo "Alert suppressed for $CHECK (lock active)"
    fi
}

send_alert "HIGH_LOAD" "Load average exceeded 80% on $(hostname) at $(date)"

Menyusun Skrip Pemeriksaan Kesehatan Lengkap

Sekarang gabungkan ketiga pemeriksaan — beban, memori, dan disk — ke dalam satu skrip yang padu, dengan ambang batas yang dapat dikonfigurasi di bagian atas. Inilah pola yang digunakan dalam otomatisasi admin sistem di lingkungan produksi:

Konstanta dideklarasikan di bagian atas agar mudah disesuaikan tanpa mengubah logika
Setiap pemeriksaan dipisahkan dalam sebuah fungsi agar mudah dibaca dan diuji secara unit
Sebuah fungsi main mengatur pemanggilan fungsi-fungsi tersebut
Kode keluar 1 jika ada peringatan yang dipicu, dan 0 jika tidak — sehingga skrip dapat digunakan bersama kerangka kerja pemantauan seperti Nagios/Icinga

#!/usr/bin/env bash
set -euo pipefail

# ── Thresholds ───────────────────────────────────────────
LOAD_THRESHOLD=80   # percent of CPU capacity
MEM_THRESHOLD=90    # percent used
DISK_THRESHOLD=85   # percent used
ALERT_EMAIL="ops@example.com"
LOG_FILE="/var/log/healthcheck.log"
ALERT_FIRED=0

# ── Helpers ──────────────────────────────────────────────
ts()    { date -u +"%Y-%m-%dT%H:%M:%SZ"; }
log()   { echo "[$(ts)] $*" | tee -a "$LOG_FILE"; }
alert() { log "ALERT: $*"; echo "$*" | mail -s "[ALERT] $(hostname)" "$ALERT_EMAIL" 2>/dev/null; ALERT_FIRED=1; }

# ── Checks ───────────────────────────────────────────────
check_load() {
    local raw cores pct
    raw=$(cut -d' ' -f1 /proc/loadavg)
    cores=$(nproc)
    pct=$(echo "scale=2; $raw / $cores * 100" | bc)
    if [ "$(echo "$pct > $LOAD_THRESHOLD" | bc)" -eq 1 ]; then
        alert "Load ${pct}% exceeds ${LOAD_THRESHOLD}%"
    else
        log "OK load=${pct}%"
    fi
}

check_memory() {
    local total avail pct
    total=$(awk '/^MemTotal:/    {print $2}' /proc/meminfo)
    avail=$(awk '/^MemAvailable:/{print $2}' /proc/meminfo)
    pct=$(echo "scale=2; (1 - $avail / $total) * 100" | bc)
    if [ "$(echo "$pct > $MEM_THRESHOLD" | bc)" -eq 1 ]; then
        alert "Memory ${pct}% used (threshold ${MEM_THRESHOLD}%)"
    else
        log "OK memory=${pct}%"
    fi
}

check_disk() {
    df --output=pcent,target | tail -n +2 | while read -r used mnt; do
        local pct_int=${used//%/}
        if [ "$pct_int" -ge "$DISK_THRESHOLD" ]; then
            alert "Disk $mnt at ${used}"
        else
            log "OK disk $mnt=${used}"
        fi
    done
}

main() {
    log "=== Health check START ==="
    check_load
    check_memory
    check_disk
    log "=== Health check END (alerts=$ALERT_FIRED) ==="
    exit "$ALERT_FIRED"
}

main

Menjadwalkan dengan Cron

Skrip pemeriksaan kesehatan hanya bermanfaat jika dijalankan secara otomatis. cron adalah penjadwal Unix standar. Edit crontab seluruh sistem atau berkas khusus di /etc/cron.d/ untuk menjadwalkan skrip Anda.

Jalankan setiap 5 menit: */5 * * * *
Selalu gunakan jalur absolut di cron — $PATH sangat terbatas di lingkungan cron
Arahkan keluaran untuk mencegah cron mengirim email pada setiap eksekusi: >> /var/log/healthcheck.log 2>&1
Gunakan MAILTO="" di bagian atas crontab untuk menonaktifkan email bawaan cron

# /etc/cron.d/healthcheck
# Run the health check every 5 minutes as root
MAILTO=""
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin

*/5 * * * * root /usr/local/sbin/healthcheck.sh >> /var/log/healthcheck.log 2>&1

Mencegah Banjir Peringatan dengan Kunci Jeda

Jika sebuah ambang batas terus-menerus terlampaui, skrip sederhana akan memicu peringatan setiap 5 menit — puluhan email dapat terkirim sebelum engineer sempat merespons. Kunci jeda menekan peringatan berulang selama jangka waktu yang dapat dikonfigurasi.

Polanya: tulis berkas kunci saat peringatan pertama; lewati peringatan berikutnya selama berkas tersebut lebih baru daripada periode jeda; find dengan -mmin memeriksa usia berkas secara atomik tanpa perhitungan tanggal.

#!/usr/bin/env bash
LOCK_DIR="/tmp/hc_locks"
COOLDOWN_MIN=60  # suppress repeat alerts for 60 minutes
mkdir -p "$LOCK_DIR"

should_alert() {
    local check="$1"
    local lock="$LOCK_DIR/${check}.lock"

    if [ ! -f "$lock" ]; then
        # No lock — allow alert and create lock
        touch "$lock"
        return 0  # true: send alert
    fi

    # Lock exists — check if it is older than the cooldown
    # find returns the filename only if it's OLDER than COOLDOWN_MIN
    local expired
    expired=$(find "$lock" -mmin +"$COOLDOWN_MIN" 2>/dev/null)

    if [ -n "$expired" ]; then
        touch "$lock"  # refresh lock timestamp
        return 0       # cooldown expired — allow alert
    fi

    return 1  # still within cooldown — suppress
}

# Usage
if should_alert "HIGH_LOAD"; then
    echo "Sending load alert..."
    # mail -s "..." ops@example.com <<< "Load too high"
else
    echo "Load alert suppressed (cooldown active)"
fi

Menguji dan Memvalidasi Skrip Pemeriksaan Kesehatan

Sebelum diterapkan, validasi skrip dengan tiga cara:

Pemeriksaan sintaks: bash -n healthcheck.sh mendeteksi kesalahan penguraian tanpa menjalankan skrip
Mode pelacakan: bash -x healthcheck.sh mencetak setiap perintah saat dijalankan — sangat berguna untuk penelusuran kesalahan
Penggantian ambang batas: untuk sementara turunkan ambang batas hingga mendekati nol agar skrip memicu peringatan pada host yang sehat, sehingga Anda dapat memastikan jalur peringatan berfungsi dari awal hingga akhir

Untuk jalur email, arahkan mail ke berkas log selama pengujian menggunakan tanda MOCK_MAIL:

#!/usr/bin/env bash
# Smoke-test the alert path without sending real email
MOCK_MAIL=true
ALERT_EMAIL="ops@example.com"

send_mail() {
    local subject="$1"
    local body="$2"
    if [ "$MOCK_MAIL" = true ]; then
        echo "[MOCK MAIL] To: $ALERT_EMAIL | Subject: $subject"
        echo "[MOCK MAIL] Body: $body"
    else
        echo "$body" | mail -s "$subject" "$ALERT_EMAIL"
    fi
}

# Override threshold to guarantee an alert fires
LOAD_THRESHOLD=0   # Any load will exceed 0%
LOAD_RAW=$(cut -d' ' -f1 /proc/loadavg)
CPU_CORES=$(nproc)
PCT=$(echo "scale=2; $LOAD_RAW / $CPU_CORES * 100" | bc)

if [ "$(echo "$PCT > $LOAD_THRESHOLD" | bc)" -eq 1 ]; then
    send_mail "[ALERT] Load on $(hostname)" "Load is ${PCT}%"
fi

Pemeriksaan Pengetahuan: Strategi Jeda

Pertimbangkan skenario berikut: tugas cron pemeriksaan kesehatan Anda berjalan setiap 5 menit. Penggunaan disk di /var melewati 85% dan tetap berada di sana selama 3 jam. Anda ingin engineer yang sedang bertugas menerima peringatan satu kali per jam, bukan setiap 5 menit. Strategi implementasi manakah yang paling tepat?

Jawab di pelajaran interaktif

Rangkuman Pelajaran: Skrip Pemeriksaan Kesehatan Sistem

Dalam pelajaran ini, Anda membangun pemeriksaan kesehatan sistem dan alur peringatan yang lengkap serta siap digunakan di lingkungan produksi. Berikut prinsip-prinsip utama yang perlu Anda terapkan selanjutnya:

Sumber kebenaran: Baca metrik dari /proc/loadavg dan /proc/meminfo — keduanya stabil, tidak bergantung pada lokal, dan tersedia di setiap host Linux
Aritmetika pecahan: Gunakan bc untuk membandingkan ambang batas bilangan pecahan; perbandingan bilangan bulat Bash (-gt) hanya berlaku untuk bilangan bulat
Iterasi disk: Gunakan df --output=pcent,target untuk memeriksa setiap sistem berkas yang terpasang, bukan hanya /
Pencatatan terstruktur: Awali setiap baris dengan stempel waktu UTC dan tingkat keparahan agar log mudah diproses dengan grep dan dapat dikirim dengan baik ke sistem pencatatan terpusat
Kunci jeda: Berkas kunci yang diperiksa dengan find -mmin mencegah banjir peringatan tanpa mengubah jadwal cron
Kemampuan komposisi: Keluar dengan kode 1 saat ada peringatan yang dipicu agar skrip terintegrasi dengan Nagios, Icinga, atau kerangka kerja pemantauan lainnya
Pengujian: Gunakan bash -n untuk pemeriksaan sintaks, bash -x untuk penelusuran saat mencari kesalahan, dan tanda MOCK_MAIL untuk memvalidasi jalur peringatan pada host yang sehat

Jadwalkan skrip yang telah selesai melalui /etc/cron.d/ agar infrastruktur Anda terus memantau dirinya sendiri dan hanya mengirim peringatan ketika ambang batas benar-benar terlampaui secara signifikan.

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 “Membangun Skrip Pemeriksaan Kesehatan Sistem dan Peringatan” gratis?

Ya — teks lengkap “Membangun Skrip Pemeriksaan Kesehatan Sistem dan Peringatan” 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 “Membangun Skrip Pemeriksaan Kesehatan Sistem dan Peringatan”?

Kumpulkan metrik beban, memori, dan disk, lalu picu peringatan berdasarkan ambang batas dari skrip terjadwal. 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 4 dari 4.

Berapa lama pelajaran “Membangun Skrip Pemeriksaan Kesehatan Sistem dan Peringatan” 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

Mengotomatiskan Penyediaan Pengguna dan Grup
Mengendalikan Layanan systemd dan Menulis File Unit
Otomatisasi Disk, Sistem File, dan Mount
Membangun Skrip Pemeriksaan Kesehatan Sistem dan Peringatan

← Kembali ke Linux Command Line & Bash Scripting Mastery