0Pricing
Linux Command Line & Bash Scripting Mastery · Pelajaran

Mengurai Log Web dan Aplikasi dalam Skala Besar

Ekstrak kode status, latensi, dan field klien dari log akses menggunakan grep, cut, dan awk.

Mengurai Log Web dan Aplikasi dalam Skala Besar adalah pelajaran Linux Command Line & Bash Scripting Mastery gratis di CoddyKit. Ini adalah pelajaran 1 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.

Apa Itu Log Akses Web?

Setiap server HTTP — Apache, Nginx, Caddy — menulis satu baris ke log akses untuk setiap permintaan. Memahami struktur baris-baris ini adalah dasar dari semua pekerjaan analisis log.

Contoh baris Combined Log Format (CLF) yang umum terlihat seperti ini:

  • IP Klien — pihak yang membuat permintaan
  • Stempel waktu — waktu terjadinya
  • Baris permintaan — metode, jalur, protokol
  • Kode status — respons HTTP (200, 404, 500…)
  • Byte yang dikirim — ukuran isi respons
  • Referer — halaman asal
  • User-Agent — string peramban atau bot

Contoh baris dari /var/log/nginx/access.log:

192.168.1.10 - alice [11/Jun/2026:14:32:01 +0000] "GET /api/orders HTTP/1.1" 200 1482 "-" "curl/7.88.1"

Pada skala besar, berkas-berkas ini dapat bertambah hingga jutaan baris per hari. Tujuan pelajaran ini adalah mengekstrak, memfilter, dan mengagregasi bidang-bidang tersebut secara efisien menggunakan alat BASH standar.

Mengambil Sampel Log Langsung dengan tail dan grep

Sebelum menulis alur apa pun, periksa log untuk memahami bentuknya. tail memungkinkan Anda mengamati aliran langsung; grep segera mempersempitnya menjadi baris-baris yang relevan.

Pola yang umum:

  • tail -n 1000 access.log — 1000 baris terakhir
  • tail -f access.log — mengikuti secara waktu nyata
  • tail -f access.log | grep '" 5' — hanya kesalahan 5xx saat muncul

Hal penting yang perlu dipahami adalah bahwa grep mencocokkan seluruh baris, sehingga penempatan jangkar pada pola sangat penting. Mencocokkan ' 500 ' (dengan spasi) mencegah pencocokan tidak sengaja pada jalur URL yang memuat string 500.

#!/usr/bin/env bash
# Watch only HTTP 5xx errors arriving in real time
tail -f /var/log/nginx/access.log \
  | grep --line-buffered '" 5[0-9][0-9] '

Mengekstrak Kode Status dengan cut

cut memisahkan setiap baris berdasarkan pembatas dan mencetak bidang yang dipilih. Dalam Combined Log Format, kode status berada di bidang 9 jika dipisahkan berdasarkan spasi — tetapi tanda kutip pada baris permintaan membuat penghitungan dari jangkar yang diketahui menjadi lebih aman.

Trik yang dapat diandalkan: karena baris permintaan selalu diapit tanda kutip, kode status selalu menjadi token pertama setelah tanda kutip penutup bidang permintaan. Menggunakan cut -d'"' -f3 mengisolasi semua bagian setelah tanda kutip permintaan, lalu cut -d' ' -f2 kedua memilih kode status.

Pemotongan dua tahap ini adalah idiom klasik untuk log CLF — cepat dan tanpa dependensi eksternal.

#!/usr/bin/env bash
# Print only the HTTP status code from each log line
# Input format: ... "GET /path HTTP/1.1" 200 1482 ...
cut -d'"' -f3 /var/log/nginx/access.log \
  | cut -d' ' -f2 \
  | sort \
  | uniq -c \
  | sort -rn

Menghitung Kode Status dengan awk

awk lebih kuat daripada cut karena dapat mengakumulasi keadaan di seluruh baris. Pola idiomatis untuk menghitung kemunculan adalah menggunakan array asosiatif yang kuncinya berupa nilai yang ingin Anda hitung.

Dalam CLF, bidang $9 (indeks mulai dari 1, dipisahkan spasi) adalah kode status. awk memproses setiap baris, menambah penghitung, lalu mencetak ringkasan terurut di blok END.

Mengapa memilih awk daripada cut | sort | uniq -c? Karena awk melakukannya dalam satu lintasan tanpa mengurutkan seluruh berkas terlebih dahulu — hal yang sangat penting ketika log berukuran ratusan gigabita.

#!/usr/bin/env bash
# Count HTTP status codes in a single awk pass
awk '{ count[$9]++ }
END {
  for (status in count)
    printf "%6d  %s\n", count[status], status
}' /var/log/nginx/access.log \
  | sort -rn

Memfilter Kesalahan dan Mengekstrak IP Klien

Salah satu tugas operasional yang paling umum adalah menemukan IP klien mana yang menghasilkan kesalahan terbanyak. Ini menggabungkan pemfilteran (hanya baris kesalahan) dengan ekstraksi bidang (IP pada bidang 1).

Strategi alurnya:

  • Gunakan awk untuk memfilter berdasarkan rentang kode status dan mengekstrak IP dalam satu langkah — hindari lintasan grep terpisah
  • Teruskan ke sort | uniq -c | sort -rn | head untuk tampilan cepat N teratas

Pola ini cukup cepat untuk dijalankan pada berkas log berukuran 10 GB di satu server tanpa memuat berkas ke memori.

#!/usr/bin/env bash
# Top 10 IPs generating HTTP 4xx or 5xx errors
awk '$9 ~ /^[45][0-9][0-9]$/ { print $1 }' \
    /var/log/nginx/access.log \
  | sort \
  | uniq -c \
  | sort -rn \
  | head -10

Mengurai Latensi Respons dari Log Aplikasi

Server aplikasi (Rails, Gunicorn, Express dengan morgan, dan sebagainya) sering mencatat durasi permintaan. Nginx dapat dikonfigurasi untuk mengeluarkan $request_time sebagai bidang tambahan di akhir setiap baris.

Contoh format log Nginx khusus dalam nginx.conf:

log_format timed '$remote_addr - $remote_user [$time_local] "$request" $status $body_bytes_sent "$http_referer" "$http_user_agent" rt=$request_time';

Setelah latensi tercatat di log, Anda dapat menggunakan awk untuk menghitung rata-rata, maksimum, dan perkiraan persentil pada jutaan permintaan tanpa memuat data ke basis data.

#!/usr/bin/env bash
# Compute average and max request_time from Nginx timed log
# Assumes last field is rt=<seconds> e.g. rt=0.042
awk '{
  # Extract numeric value after rt=
  n = split($NF, a, "=")
  if (n == 2 && a[1] == "rt") {
    t = a[2] + 0
    sum += t
    count++
    if (t > max) max = t
  }
}
END {
  if (count > 0)
    printf "Requests: %d  Avg: %.4fs  Max: %.4fs\n", count, sum/count, max
}' /var/log/nginx/timed_access.log

Membangun Histogram Latensi dengan awk

Satu nilai rata-rata menyembunyikan latensi ekor. Histogram menampilkan distribusinya — apakah sebagian besar permintaan cepat dan beberapa sangat lambat (ekor panjang), atau distribusinya seragam.

Triknya adalah memasukkan setiap nilai ke dalam rentang yang dibulatkan menggunakan aritmetika bilangan bulat di dalam awk. Mengalikan dengan 1000 (mengubah detik menjadi milidetik), lalu menggunakan pembagian bilangan bulat, menghasilkan batas kelompok yang rapi.

Hasilnya adalah histogram teks yang dapat Anda baca langsung di terminal, yang sering kali lebih cepat daripada mengirim data ke Grafana untuk penyelidikan singkat.

#!/usr/bin/env bash
# Latency histogram (50ms buckets) from Nginx timed log
awk '{
  n = split($NF, a, "=")
  if (n == 2 && a[1] == "rt") {
    ms = int(a[2] * 1000)      # convert to ms
    bucket = int(ms / 50) * 50 # round down to 50ms boundary
    hist[bucket]++
  }
}
END {
  for (b in hist)
    printf "%6dms  %d\n", b, hist[b]
}' /var/log/nginx/timed_access.log \
  | sort -n

Mengekstrak User-Agent dan Mendeteksi Bot

Bidang User-Agent (bidang 6 saat pemisahan berdasarkan ") mengidentifikasi klien. Perayap, pengikis, dan bot berbahaya sering mengotori metrik serta memperbesar jumlah kesalahan. Dengan memfilternya, Anda mendapatkan gambaran lalu lintas pengguna nyata yang lebih bersih.

Signature bot yang umum: bot, crawler, spider, curl, python-requests, Googlebot, Bingbot.

Gunakan grep -iv (pembalikan tanpa membedakan huruf besar-kecil) untuk mengecualikan bot yang telah diketahui, atau gunakan awk untuk memisahkan berdasarkan " dan mencocokkan bidang UA secara langsung.

#!/usr/bin/env bash
# Count top 15 User-Agent strings, excluding known bots
awk -F'"' '{ print $6 }' /var/log/nginx/access.log \
  | grep -iv -e 'bot' -e 'crawler' -e 'spider' -e 'curl' \
              -e 'python' -e 'wget' -e 'Go-http-client' \
  | sort \
  | uniq -c \
  | sort -rn \
  | head -15

Mengagregasi Lalu Lintas berdasarkan Titik Akhir

Mengetahui titik akhir mana yang menerima lalu lintas terbanyak — dan menghasilkan kesalahan terbanyak — membantu memprioritaskan pengoptimalan dan perencanaan kapasitas. Jalur permintaan berada di dalam bidang permintaan yang diapit tanda kutip.

Pisahkan berdasarkan ", ambil bidang 2 (baris permintaan), lalu potong metode dan protokol untuk mengisolasi jalurnya. Untuk API dengan parameter jalur seperti /users/12345, Anda mungkin juga ingin menormalkan ID menjadi /users/:id menggunakan sed atau pola awk yang lebih kompleks.

#!/usr/bin/env bash
# Top 20 requested endpoints (method + path, no query string)
awk -F'"' '{ print $2 }' /var/log/nginx/access.log \
  | awk '{ print $1, $2 }' \
  | sed 's|/[0-9][0-9]*\b|/:id|g' \
  | sort \
  | uniq -c \
  | sort -rn \
  | head -20

Mengorelasikan Kesalahan dengan Titik Akhir Menggunakan awk

Analisis satu lintasan yang paling kuat menggabungkan beberapa bidang sekaligus: titik akhir, kode status, dan secara opsional latensi. Array asosiatif awk dengan kunci berupa nilai gabungan membuatnya rapi dan cepat.

Pola di bawah menghitung kesalahan 5xx untuk setiap titik akhir dalam satu lintasan — tanpa berkas sementara dan tanpa pengurutan perantara hingga tahap paling akhir. Inilah pendekatan yang digunakan dalam skrip observabilitas produksi ketika Anda memerlukan jawaban dalam waktu kurang dari satu menit pada log berukuran besar.

#!/usr/bin/env bash
# Count 5xx errors per endpoint path in a single pass
awk -F'"' '{
  # $2 = request line e.g. "GET /api/orders HTTP/1.1"
  # $0 in original space-split: $9 = status
  split($0, fields, " ")
  status = fields[9]
  if (status ~ /^5/) {
    split($2, req, " ")
    path = req[2]
    # Normalise numeric IDs
    gsub(/\/[0-9]+/, "/:id", path)
    errors[path]++
  }
}
END {
  for (p in errors)
    printf "%6d  %s\n", errors[p], p
}' /var/log/nginx/access.log \
  | sort -rn \
  | head -20

Memproses Log yang Diputar dan Dikompresi

Di sebagian besar server, log diputar setiap hari. Berkas lama dikompresi dengan gzip menjadi access.log.1.gz, access.log.2.gz, dan seterusnya. Alat standar tidak dapat membacanya secara langsung, tetapi dua pendekatan berikut bekerja dengan baik:

  • zcat — mengompresi kembali ke keluaran standar, lalu meneruskannya ke alur Anda
  • zgrep — melakukan grep langsung di dalam berkas gzip tanpa mengekstraknya

Untuk menganalisis log selama satu minggu penuh yang mencakup berkas terkompresi dan tidak terkompresi, gunakan substitusi proses atau gabungkan dengan zcat. Cuplikan di bawah memproses 7 berkas log terputar terakhir beserta log langsung saat ini dalam satu pemanggilan awk — tanpa memerlukan berkas sementara.

#!/usr/bin/env bash
# Aggregate status codes across a week of rotated logs
# Handles both plain and gzip-compressed rotation files

LOG_DIR="/var/log/nginx"

{
  cat  "${LOG_DIR}/access.log" 2>/dev/null
  zcat "${LOG_DIR}/access.log".*.gz 2>/dev/null
} | awk '
{ count[$9]++ }
END {
  for (s in count)
    printf "%6d  %s\n", count[s], s
}' | sort -rn

Bidang awk mana yang menyimpan kode status HTTP dalam Combined Log Format?

Anda sedang menulis satu baris perintah awk untuk menyaring hanya respons HTTP 4xx dari access log Nginx standar dalam Combined Log Format (dipisahkan spasi, dengan baris permintaan diapit tanda kutip). Nomor bidang manakah yang dengan tepat mengidentifikasi kode status HTTP?

Ringkasan Pelajaran: Pipeline Analisis Log

Dalam pelajaran ini, Anda membangun seperangkat alat lengkap untuk menganalisis log web dan aplikasi dalam skala besar hanya dengan utilitas standar BASH.

Teknik utama yang dibahas:

  • Utamakan struktur — Combined Log Format memiliki susunan bidang yang dapat diprediksi; dengan memahaminya, Anda dapat membaginya secara andal menggunakan cut -d'"' atau referensi bidang awk.
  • Ekstraksi kode status — awk '{ count[$9]++ }' menghitung semua kode dalam satu lintasan; gunakan penyaringan dengan $9 ~ /^5/ untuk galat server.
  • Analisis latensi — uraikan bidang khusus rt= dengan awk untuk menghitung rata-rata, nilai maksimum, dan kelompok histogram tanpa alat eksternal apa pun.
  • Analisis klien dan bot — pisahkan berdasarkan " dengan -F'"' untuk mengakses bidang User-Agent; teruskan melalui grep -iv untuk mengecualikan bot sebelum melakukan agregasi.
  • Normalisasi endpoint — gunakan gsub(/\/[0-9]+/, "/:id") di dalam awk untuk menyederhanakan jalur berparameter sebelum menghitungnya.
  • Log yang dirotasi — gabungkan cat dan zcat dalam subproses untuk memasukkan semua file rotasi ke dalam satu lintasan pipeline.

Pola-pola ini dapat dikomposisikan: Anda dapat merangkai penyaringan, ekstraksi, normalisasi, dan agregasi dalam satu pipeline yang memproses ratusan juta baris pada perangkat keras standar. Kuasai primitif ini dan Anda akan jarang memerlukan layanan agregasi log khusus untuk investigasi insiden secara ad hoc.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Mengurai Log Web dan Aplikasi dalam Skala Besar” gratis?

Ya — teks lengkap “Mengurai Log Web dan Aplikasi dalam Skala Besar” 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 “Mengurai Log Web dan Aplikasi dalam Skala Besar”?

Ekstrak kode status, latensi, dan field klien dari log akses menggunakan grep, cut, dan awk. 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 1 dari 4.

Berapa lama pelajaran “Mengurai Log Web dan Aplikasi dalam Skala Besar” 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

  1. Mengurai Log Web dan Aplikasi dalam Skala Besar
  2. Mengikuti Log secara Real-Time dan Mengalirkan Peringatan
  3. Mengkueri journald dengan journalctl dalam Skrip
  4. Menghitung Metrik dan Histogram dari Aliran Log
← Kembali ke Linux Command Line & Bash Scripting Mastery