Bagi seorang Linux sysadmin, bekerja dari terminal bukan hanya tentang menjalankan command satu per satu. Dalam banyak kasus, administrator perlu mengambil data dari API, memilih informasi tertentu, kemudian memantau perubahan data tersebut secara berkala.

Di sinilah dua utility sederhana tetapi sangat berguna dapat dikombinasikan: jq dan watch.

jq digunakan untuk membaca, memfilter, dan mengolah data JSON. Sementara itu, watch digunakan untuk menjalankan command secara berulang pada interval tertentu dan menampilkan hasil terbaru di terminal.

Jika digabungkan, keduanya dapat membentuk workflow sederhana seperti:

API
 ↓
curl
 ↓
JSON
 ↓
jq
 ↓
Data yang dibutuhkan
 ↓
watch
 ↓
Monitoring berkala

Contohnya, sebuah API monitoring mungkin menghasilkan data server seperti:

{
  "servers": [
    {
      "hostname": "web01",
      "status": "running",
      "cpu": 35,
      "memory": 52
    },
    {
      "hostname": "web02",
      "status": "running",
      "cpu": 87,
      "memory": 73
    },
    {
      "hostname": "db01",
      "status": "running",
      "cpu": 92,
      "memory": 81
    }
  ]
}

Dengan jq, kita dapat mengambil hanya server yang memiliki CPU tinggi.

Kemudian dengan watch, query tersebut dapat dijalankan setiap beberapa detik.

Hasilnya, administrator dapat membuat monitoring sederhana langsung dari terminal tanpa harus membuka dashboard web.

---

Apa Itu jq?

jq adalah command-line JSON processor yang dirancang untuk membaca dan memproses data JSON.

JSON banyak digunakan oleh:

• REST API
• aplikasi web
• Docker
• Kubernetes
• cloud platform
• monitoring system
• automation tools
• aplikasi internal
• microservices

Contoh JSON:

{
  "hostname": "web01",
  "ip": "192.168.1.10",
  "status": "running"
}

Untuk mengambil hostname:

echo '{"hostname":"web01","ip":"192.168.1.10","status":"running"}' | jq '.hostname'

Output:

"web01"

Jika ingin output tanpa tanda kutip:

echo '{"hostname":"web01","ip":"192.168.1.10","status":"running"}' | jq -r '.hostname'

Output:

web01

Parameter -r sangat berguna ketika output akan digunakan dalam Bash script atau pipeline command lainnya.

---

Apa Itu watch?

watch adalah utility Linux yang digunakan untuk menjalankan command secara berulang dan menampilkan output terbarunya.

Contoh:

watch uptime

Atau menentukan interval:

watch -n 5 uptime

Artinya command uptime dijalankan kembali setiap 5 detik.

Untuk menghentikannya:

Ctrl + C

Secara sederhana:

watch
 ↓
jalankan command
 ↓
tunggu
 ↓
jalankan lagi
 ↓
refresh output

Jika jq bertugas memahami isi JSON, maka watch bertugas mengulang proses tersebut.

---

Mengapa jq dan watch Menarik Jika Digabungkan?

Kekuatan sebenarnya muncul ketika keduanya digunakan bersama.

Misalnya kita mempunyai API:

https://monitor.example/api/servers

API mengembalikan data JSON.

Tanpa jq, kita harus membaca seluruh response.

Dengan jq:

curl -s https://monitor.example/api/servers \
| jq -r '.servers[].hostname'

Kita mendapatkan daftar hostname saja.

Kemudian jika ingin memantau hasil tersebut secara berkala:

watch -n 5 'curl -s https://monitor.example/api/servers | jq -r ".servers[].hostname"'

Sekarang API akan dipanggil setiap 5 detik dan output diproses kembali oleh jq.

Workflow-nya menjadi:

watch
 ↓
curl
 ↓
API
 ↓
JSON
 ↓
jq
 ↓
filtered output

Ini merupakan konsep sederhana tetapi sangat powerful untuk troubleshooting dan observasi sistem.

---

Instalasi jq dan watch di Ubuntu/Debian

Pada Ubuntu dan Debian, jq dapat dipasang menggunakan:

sudo apt update
sudo apt install jq

Untuk watch, pada sistem Debian/Ubuntu modern biasanya utility ini sudah tersedia melalui paket procps.

Jika belum tersedia:

sudo apt install procps

Periksa jq:

jq --version

Periksa watch:

watch --version

Jika keduanya tersedia, kita sudah dapat mulai membuat pipeline monitoring.

---

Memahami Konsep Pipeline Linux

Sebelum masuk ke contoh gabungan, pahami konsep pipe |.

Contoh:

command1 | command2

Output dari command1 menjadi input untuk command2.

Misalnya:

curl -s https://example.com/api | jq

Artinya:

curl
 ↓
JSON
 ↓
jq
 ↓
formatted JSON

Kemudian kita menambahkan watch:

watch 'curl -s https://example.com/api | jq'

Sekarang:

watch
 ↓
curl
 ↓
API
 ↓
jq
 ↓
output
 ↓
refresh
 ↓
curl
 ↓
API
 ↓
jq
 ↓
output

Inilah dasar penggunaan jq dan watch secara bersamaan.

---

Contoh Dasar jq + watch

Misalkan kita memiliki data:

{
  "server": {
    "hostname": "web01",
    "cpu": 35,
    "memory": 52
  }
}

Jika JSON tersebut disimpan sebagai server.json, kita dapat menggunakan:

watch 'cat server.json | jq'

Atau hanya mengambil CPU:

watch 'cat server.json | jq ".server.cpu"'

Output akan diperbarui sesuai interval watch.

Namun jika file JSON tidak berubah, hasilnya tentu juga tidak berubah.

Workflow menjadi lebih menarik ketika sumber data berasal dari API atau command yang menghasilkan data dinamis.

---

Menggunakan curl + jq + watch

Contoh paling umum:

watch -n 5 'curl -s https://monitor.example/api/servers | jq'

Artinya setiap 5 detik:

1. curl mengambil data API.
2. API mengembalikan JSON.
3. jq memformat JSON.
4. watch menampilkan hasil terbaru.
5. Setelah 5 detik proses diulang.

Ini merupakan bentuk monitoring API paling sederhana.

---

Mengambil Field Tertentu

Daripada menampilkan seluruh JSON, kita dapat memilih field tertentu.

Misalnya:

watch -n 5 'curl -s https://monitor.example/api/server | jq -r ".hostname"'

Jika API mengembalikan:

{
  "hostname": "web01",
  "ip": "192.168.1.20",
  "status": "running"
}

Output:

web01

---

Monitoring Status Server

Misalnya API mengembalikan:

{
  "hostname": "web01",
  "status": "running"
}

Kita dapat memantau status:

watch -n 2 'curl -s https://monitor.example/api/server | jq -r ".status"'

Jika server berubah status dari:

running

menjadi:

stopped

perubahan tersebut dapat terlihat ketika watch melakukan refresh berikutnya.

---

Monitoring Banyak Server

Misalkan API menghasilkan:

{
  "servers": [
    {
      "hostname": "web01",
      "status": "running"
    },
    {
      "hostname": "web02",
      "status": "running"
    },
    {
      "hostname": "db01",
      "status": "stopped"
    }
  ]
}

Untuk melihat semua hostname:

watch -n 5 'curl -s https://monitor.example/api/servers | jq -r ".servers[].hostname"'

Output:

web01
web02
db01

---

Memfilter Server yang Running

Gunakan select():

watch -n 5 'curl -s https://monitor.example/api/servers | jq -r ".servers[] | select(.status == \"running\") | .hostname"'

Output:

web01
web02

Server yang berstatus stopped tidak ditampilkan.

---

Memantau Server dengan CPU Tinggi

Ini salah satu contoh yang sangat berguna untuk sysadmin.

Misalkan API menghasilkan:

{
  "servers": [
    {
      "hostname": "web01",
      "cpu": 35
    },
    {
      "hostname": "web02",
      "cpu": 87
    },
    {
      "hostname": "db01",
      "cpu": 92
    }
  ]
}

Untuk mencari server dengan CPU di atas 80%:

watch -n 5 'curl -s https://monitor.example/api/servers | jq -r ".servers[] | select(.cpu > 80) | \"\(.hostname) CPU=\(.cpu)%\""'

Output:

web02 CPU=87%
db01 CPU=92%

Setiap 5 detik, data diperbarui.

Jika CPU web02 turun menjadi 60%, server tersebut tidak lagi muncul dalam hasil filter.

Ini membuat kombinasi jq + watch sangat berguna untuk observasi threshold sederhana.

---

Monitoring CPU dan Memory Bersamaan

Kita dapat membuat output custom:

watch -n 5 'curl -s https://monitor.example/api/servers | jq -r ".servers[] | \"\(.hostname) CPU=\(.cpu)% MEM=\(.memory)%\""'

Contoh:

web01 CPU=35% MEM=52%
web02 CPU=87% MEM=73%
db01 CPU=92% MEM=81%

Output tersebut jauh lebih mudah dibaca dibandingkan response JSON mentah.

---

Monitoring Hanya Server Bermasalah

Misalnya kita mendefinisikan server bermasalah jika:

CPU > 80%
atau
Memory > 80%

Kita dapat menggunakan:

watch -n 5 'curl -s https://monitor.example/api/servers | jq -r ".servers[] | select(.cpu > 80 or .memory > 80) | \"\(.hostname) CPU=\(.cpu)% MEM=\(.memory)%\""'

Contoh:

web02 CPU=87% MEM=73%
db01 CPU=92% MEM=81%

Ini dapat membantu administrator fokus pada resource yang membutuhkan perhatian.

---

Menggunakan watch -d untuk Melihat Perubahan

Option -d dapat membantu menyoroti perubahan output.

Contoh:

watch -d -n 2 'curl -s https://monitor.example/api/servers | jq -r ".servers[] | \"\(.hostname) CPU=\(.cpu)% MEM=\(.memory)%\""'

Jika nilai CPU atau memory berubah, bagian output yang berubah akan lebih mudah dikenali.

Untuk troubleshooting, fitur ini cukup praktis.

---

Menggunakan watch untuk API Monitoring

Bayangkan Anda memiliki monitoring API yang menyediakan data:

{
  "status": "healthy",
  "cpu": 42,
  "memory": 61,
  "disk": 73
}

Untuk memantau seluruh data:

watch -n 5 'curl -s https://monitor.example/api/status | jq'

Untuk hanya menampilkan status:

watch -n 5 'curl -s https://monitor.example/api/status | jq -r ".status"'

Untuk membuat tampilan ringkas:

watch -n 5 'curl -s https://monitor.example/api/status | jq -r "\"STATUS=\(.status) CPU=\(.cpu)% RAM=\(.memory)% DISK=\(.disk)%\""'

Output:

STATUS=healthy CPU=42% RAM=61% DISK=73%

Sekarang terminal berubah menjadi semacam mini dashboard.

---

jq + watch untuk Docker

Docker juga dapat digunakan sebagai contoh nyata.

Untuk melihat container secara berkala:

watch -n 2 'docker ps'

Namun jika membutuhkan output terstruktur dari Docker:

docker ps --format '{{json .}}'

Output tersebut dapat diproses menggunakan jq.

Contoh:

docker ps --format '{{json .}}' | jq

Untuk menjalankannya dengan watch:

watch -n 2 'docker ps --format "{{json .}}" | jq'

Ini berguna ketika ingin mengamati perubahan container.

---

jq + watch untuk Kubernetes

Kubernetes menghasilkan banyak data dalam format JSON.

Misalnya:

kubectl get pods -o json

Kita dapat memprosesnya dengan jq.

Untuk mengambil nama pod:

kubectl get pods -o json \
| jq -r '.items[].metadata.name'

Untuk monitoring berkala:

watch -n 5 'kubectl get pods -o json | jq -r ".items[] | \"\(.metadata.name) \(.status.phase)\""'

Output dapat berupa:

web-7d9f7d8f9c-x2abc Running
database-0 Running
redis-0 Pending

Ini menunjukkan bagaimana jq dapat digunakan untuk mengubah data Kubernetes menjadi output yang lebih mudah dibaca.

---

jq + watch untuk Network Administration

Konsep yang sama dapat diterapkan pada networking.

Memantau interface:

watch -n 2 'ip -br addr'

Memantau routing:

watch -n 5 'ip route'

Memantau listening port:

watch -n 2 'ss -lntp'

Jika command menghasilkan JSON, kita dapat memasukkan jq dalam pipeline.

Dengan demikian, konsepnya tidak terbatas pada API server saja.

---

jq + watch dalam Bash Script

Kombinasi ini juga dapat dimasukkan ke script.

Contoh:

#!/bin/bash

API="https://monitor.example/api/servers"

watch -n 5 "
curl -s '$API' |
jq -r '.servers[] |
select(.cpu > 80) |
\"\(.hostname) CPU=\(.cpu)%\"'
"

Script tersebut akan memantau server yang CPU-nya melewati 80%.

Namun untuk automation production yang lebih kompleks, sebaiknya gunakan script monitoring khusus atau platform observability.

watch lebih cocok sebagai tool interaktif.

---

Menangani Field JSON yang Tidak Ada

API tidak selalu konsisten.

Misalnya sebuah server tidak memiliki field memory.

Daripada menghasilkan null, kita dapat menggunakan:

jq -r '.memory // 0'

Atau:

jq -r '.hostname // "unknown"'

Contoh pipeline:

watch -n 5 'curl -s https://monitor.example/api/server | jq -r "\"\(.hostname // \"unknown\") CPU=\(.cpu // 0)% MEM=\(.memory // 0)%\""'

Teknik ini membuat command lebih tahan terhadap data yang tidak lengkap.

---

Mengapa Menggunakan jq Lebih Baik daripada grep untuk JSON?

Administrator Linux mungkin tergoda menggunakan:

grep

atau:

awk

untuk mengambil data JSON.

Untuk data sederhana, mungkin berhasil.

Namun JSON memiliki struktur object dan array yang tidak cocok diproses sebagai teks biasa.

Misalnya:

{
  "server": {
    "name": "web01",
    "status": "running"
  }
}

jq memahami struktur tersebut:

jq -r '.server.name'

Sementara pendekatan berbasis teks dapat menjadi rapuh ketika format JSON berubah.

Jika input memang JSON, gunakan parser JSON.

---

Kesalahan yang Sering Terjadi

Lupa menggunakan tanda kutip pada pipeline

Perintah:

watch curl -s API | jq

tidak bekerja seperti yang diharapkan karena shell dapat memproses pipe terlebih dahulu.

Gunakan:

watch 'curl -s API | jq'

Atau:

watch "curl -s API | jq"

---

Lupa menggunakan -r

Perintah:

jq '.hostname'

menghasilkan:

"web01"

Sedangkan:

jq -r '.hostname'

menghasilkan:

web01

Untuk shell scripting, raw output biasanya lebih nyaman.

---

Interval Terlalu Cepat

Jangan langsung menggunakan:

watch -n 0.1 ...

terutama jika command melakukan request API atau query yang berat.

Jika API membutuhkan waktu lama atau memiliki rate limit, interval terlalu pendek justru dapat menimbulkan masalah.

Gunakan interval berdasarkan kebutuhan.

Contoh:

watch -n 1

untuk data yang sangat dinamis.

watch -n 5

untuk monitoring umum.

watch -n 30

untuk informasi yang berubah lebih lambat.

---

API Rate Limit

Jika menggunakan:

watch -n 1 'curl -s https://api.example.com | jq'

maka API dipanggil setiap satu detik.

Jika API memiliki rate limit, pendekatan tersebut dapat menyebabkan request ditolak.

Untuk API eksternal, perhatikan dokumentasi rate limit.

---

Menggunakan Command yang Mengubah Sistem

Ingat bahwa watch menjalankan command berulang.

Jangan sembarangan memasukkan command yang memiliki efek samping.

Contoh buruk:

watch 'rm -f /tmp/file'

Command tersebut akan dijalankan berulang kali.

Gunakan watch terutama untuk command observasi atau read-only.

---

Best Practice jq + watch

Beberapa praktik yang disarankan:

Gunakan jq untuk memproses JSON, bukan parsing teks secara manual.

Gunakan watch untuk observasi sementara, bukan sebagai sistem monitoring production.

Gunakan interval yang sesuai.

Perhatikan rate limit API.

Gunakan -r jika output akan diproses oleh shell.

Gunakan -d jika ingin lebih mudah melihat perubahan.

Gunakan quote untuk pipeline kompleks.

Gunakan filter jq sespesifik mungkin.

Tangani field JSON yang mungkin bernilai null.

Uji command jq secara manual sebelum memasukkannya ke watch.

---

Contoh Workflow Troubleshooting

Misalnya administrator menerima laporan bahwa beberapa server mengalami penggunaan CPU tinggi.

API monitoring menyediakan:

/api/servers

Langkah pertama, lihat response:

curl -s https://monitor.example/api/servers | jq

Kemudian cari server CPU tinggi:

curl -s https://monitor.example/api/servers \
| jq -r '.servers[] | select(.cpu > 80)'

Setelah filter terbukti benar, buat monitoring berkala:

watch -n 5 'curl -s https://monitor.example/api/servers | jq -r ".servers[] | select(.cpu > 80) | \"\(.hostname) CPU=\(.cpu)%\""'

Kemudian gunakan:

watch -d -n 5 'curl -s https://monitor.example/api/servers | jq -r ".servers[] | select(.cpu > 80) | \"\(.hostname) CPU=\(.cpu)%\""'

untuk melihat perubahan.

Workflow ini lebih baik daripada langsung membuat command kompleks karena setiap tahap dapat diuji terlebih dahulu.

---

Pola Berpikir yang Perlu Dikuasai

Daripada menghafal banyak command, pahami pola berikut:

SUMBER DATA
    ↓
curl / kubectl / docker / command lain
    ↓
JSON
    ↓
jq
    ↓
FILTER
    ↓
OUTPUT
    ↓
watch
    ↓
REFRESH

Atau secara lebih sederhana:

jq = pilih dan olah data
watch = ulangi dan pantau data

Ini adalah konsep utama yang perlu diingat.

---

Contoh Command Siap Pakai

Monitoring seluruh JSON:

watch -n 5 'curl -s https://example.com/api | jq'

Monitoring hostname:

watch -n 5 'curl -s https://example.com/api | jq -r ".hostname"'

Monitoring server running:

watch -n 5 'curl -s https://example.com/api/servers | jq -r ".servers[] | select(.status == \"running\") | .hostname"'

Monitoring CPU tinggi:

watch -n 5 'curl -s https://example.com/api/servers | jq -r ".servers[] | select(.cpu > 80) | \"\(.hostname) CPU=\(.cpu)%\""'

Monitoring CPU dan memory:

watch -n 5 'curl -s https://example.com/api/servers | jq -r ".servers[] | \"\(.hostname) CPU=\(.cpu)% MEM=\(.memory)%\""'

Menyoroti perubahan:

watch -d -n 5 'curl -s https://example.com/api/servers | jq -r ".servers[] | \"\(.hostname) CPU=\(.cpu)% MEM=\(.memory)%\""'

Monitoring Kubernetes:

watch -n 5 'kubectl get pods -o json | jq -r ".items[] | \"\(.metadata.name) \(.status.phase)\""'

Monitoring Docker:

watch -n 2 'docker ps --format "{{json .}}" | jq'

---

jq + watch vs Monitoring Platform

Penting untuk memahami batasannya.

jq + watch sangat cocok untuk:

• troubleshooting
• debugging API
• observasi sementara
• validasi data
• pengecekan server
• pemeriksaan deployment
• eksperimen
• administrasi server melalui SSH

Namun bukan pengganti:

• Prometheus
• Grafana
• Zabbix
• Icinga
• VictoriaMetrics
• Netdata
• sistem observability production lainnya

Platform monitoring menyediakan histori data, alerting, dashboard, retention, aggregation, notification, dan berbagai fitur lain yang tidak dimiliki watch.

Karena itu, gunakan jq + watch sebagai tactical troubleshooting tool, bukan sebagai pengganti monitoring infrastructure.

---

Kesimpulan

jq dan watch adalah dua utility Linux yang sederhana tetapi dapat menjadi sangat powerful ketika digabungkan.

jq membantu administrator memahami dan memproses JSON. Ia dapat mengambil field tertentu, membaca nested object, memproses array, melakukan filter, menghitung data, dan menghasilkan output custom.

Sementara watch menjalankan command secara berkala sehingga hasilnya dapat dipantau secara real-time dari terminal.

Ketika digabungkan dengan curl, workflow menjadi:

curl
 ↓
API
 ↓
JSON
 ↓
jq
 ↓
filter
 ↓
watch
 ↓
monitoring

Pendekatan ini sangat berguna bagi sysadmin, DevOps engineer, network administrator, cloud engineer, developer, maupun siswa TKJ/TJKT yang sedang belajar administrasi Linux dan API.

Kuncinya bukan menghafal command sebanyak mungkin, tetapi memahami bagaimana setiap utility menjalankan tugasnya.

jq memilih data.

watch mengulang proses.

curl mengambil data.

Pipe | menghubungkan semuanya.

Dari beberapa utility sederhana tersebut, kita dapat membangun workflow monitoring yang cukup powerful langsung dari terminal.

Sudah pernah menggunakan jq dan watch dalam troubleshooting server Linux?

Bagikan command favorit atau workflow yang biasa Anda gunakan di kolom komentar.

Jika artikel ini bermanfaat, bagikan kepada rekan sysadmin, DevOps engineer, network administrator, developer, maupun siswa TKJ/TJKT yang sedang belajar Linux.

Jangan lupa eksplorasi artikel lainnya tentang Linux, Bash scripting, Docker, Kubernetes, networking, monitoring, cloud computing, DevOps, dan cybersecurity.