Posted in

Laptop Butut Juga Butuh “Check-Up”: Monitoring Server Rumahan dengan Prometheus & Grafana

by Achmad Diar Ajiprasetia•

Melanjutkan petualangan self-hosting di atas netbook Intel Atom.

Uptime Kuma sudah jalan. Cloudflare Tunnel sudah tembus. Blog WordPress sudah online. Layanan-layanan self-hosted sudah berjejer rapi di dalam Docker.

Tapi ada satu pertanyaan yang mulai mengganggu: apakah laptop butut itu baik-baik saja di dalam?

Uptime Kuma memang hebat — ia tahu kalau Nextcloud tidak bisa diakses, kalau FileBrowser timeout, kalau WordPress lemot merespons. Tapi Uptime Kuma tidak tahu kenapa. Apakah RAM sudah habis? CPU sudah merangkak di 100%? Disk tinggal beberapa persen? Suhu prosesor sudah bikin khawatir?

Untuk server komersial, pertanyaan seperti ini dijawab oleh tim ops dengan dashboard monitoring yang selalu menyala. Untuk server rumahan di atas netbook Intel Atom N550 dengan RAM 2GB — pertanyaannya sama, tapi jawabannya harus gratis, open-source, dan bisa diinstall sendiri.

Jawabannya: Prometheus + Grafana.

Kenapa Monitoring Resource Itu Penting untuk Server Rumahan?

Sebelum masuk ke teknis, izinkan sedikit cerita dulu.

Netbook yang jadi server ini punya RAM 2GB. Itu sudah termasuk ketat untuk satu layanan, apalagi untuk menjalankan puluhan container Docker sekaligus — WordPress, Vaultwarden, Navidrome, FileBrowser, Memos, YOURLS, phpMyAdmin, dan beberapa lagi. Tidak ada yang memberitahu kamu kalau MariaDB tiba-tiba makan RAM lebih dari biasanya. Tidak ada yang peringatkan kalau disk sudah di 80%. Tidak ada yang mencatat pola load average setiap hari.

Kamu baru tahu ada masalah ketika layanan sudah terasa lambat — atau lebih buruk, sudah tidak bisa dibuka sama sekali.

Ini masalah klasik self-hosting: visibilitasnya rendah. Kamu tahu server hidup, tapi kamu tidak tahu server sehat.

Monitoring resource menjawab itu. Bukan untuk gaya-gayaan. Bukan karena ingin terlihat seperti tim DevOps perusahaan besar. Tapi karena kalau hardware-nya terbatas, kamu justru lebih perlu tahu kapan batas itu mulai tercapai.

Kenapa Prometheus dan Grafana?

Ada banyak tool monitoring di luar sana — Zabbix, Netdata, Checkmk, dan sejenisnya. Tapi Prometheus + Grafana adalah kombinasi yang paling banyak dipakai di dunia, dari startup kecil sampai infrastruktur skala besar, dengan alasan yang sederhana:

Keduanya open-source. Keduanya gratis. Keduanya tidak kirim data ke server siapapun.

Prometheus adalah mesin pengumpul data — ia secara berkala mengambil (scrape) metrik dari target yang kamu tentukan, lalu menyimpannya dalam database time-series miliknya sendiri. Node Exporter adalah agen kecil yang berjalan di server dan mengekspos metrik hardware ke Prometheus: CPU, RAM, disk, network, filesystem — semuanya.

Grafana adalah mesin visualisasi — ia membaca data dari Prometheus dan menampilkannya dalam bentuk grafik, chart, gauge, dan dashboard yang cantik. Dan karena komunitas Grafana sangat besar, ribuan dashboard siap pakai sudah tersedia untuk diimpor secara gratis, termasuk dashboard Node Exporter yang legendaris dengan ID 1860.

Stack ini tidak membutuhkan akun berbayar, tidak perlu daftar ke layanan cloud manapun, tidak ada data yang meninggalkan server kamu. Semua jalan di atas hardware yang sama yang sudah kamu miliki.

Apa yang Akan Kita Bangun?

Di akhir panduan ini, kamu akan punya:

  • Prometheus — mengumpulkan metrik server setiap 15 detik
  • Node Exporter — menyediakan metrik hardware ke Prometheus
  • Grafana — menampilkan semua metrik dalam dashboard yang bisa diakses dari browser
  • Semua dijalankan via Docker Compose di /opt/monitoring
  • Dashboard bisa diakses dari luar via monitoring.diaraji.my.id melalui Cloudflare Zero Trust

Prasyarat

Panduan ini melanjutkan dari setup sebelumnya. Pastikan kamu sudah punya:

  • Server Linux dengan Docker dan Docker Compose terpasang
  • Caddy sebagai reverse proxy (sudah dibahas di artikel sebelumnya)
  • Domain yang terhubung ke Cloudflare dengan Tunnel aktif

Bagian 1: Buat Direktori Kerja

Semua file konfigurasi dan data akan disimpan di /opt/monitoring. Ini kebiasaan yang rapi — semua layanan punya rumah masing-masing di bawah /opt.

mkdir -p /opt/monitoring/prometheus
cd /opt/monitoring

Bagian 2: Konfigurasi Prometheus

Prometheus perlu tahu apa yang harus di-scrape. Kita buat file konfigurasinya:

cat > /opt/monitoring/prometheus/prometheus.yml << 'EOF'
global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']

  - job_name: 'node-exporter'
    static_configs:
      - targets: ['node-exporter:9100']
EOF

scrape_interval: 15s artinya Prometheus mengambil data setiap 15 detik. Untuk server rumahan ini sudah sangat cukup — kamu dapat gambaran real-time tanpa memberatkan CPU yang memang tidak besar.

Di scrape_configs, kita daftarkan dua target: Prometheus itu sendiri (untuk self-monitoring) dan Node Exporter yang akan mengekspos metrik hardware. Perhatikan node-exporter:9100 — ini menggunakan nama service Docker, bukan localhost, karena keduanya container yang berbeda.

Bagian 3: Docker Compose

Sekarang kita buat docker-compose.yml yang menjalankan ketiga service sekaligus:

cat > /opt/monitoring/docker-compose.yml << 'EOF'
services:
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    restart: unless-stopped
    volumes:
      - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus_data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--storage.tsdb.retention.time=15d'
    ports:
      - "9090:9090"

  node-exporter:
    image: prom/node-exporter:latest
    container_name: node-exporter
    restart: unless-stopped
    volumes:
      - /proc:/host/proc:ro
      - /sys:/host/sys:ro
      - /:/rootfs:ro
    command:
      - '--path.procfs=/host/proc'
      - '--path.rootfs=/rootfs'
      - '--path.sysfs=/host/sys'
      - '--collector.filesystem.mount-points-exclude=^/(sys|proc|dev|host|etc)($$|/)'
    ports:
      - "9100:9100"

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    restart: unless-stopped
    environment:
      - GF_SECURITY_ADMIN_USER=admin
      - GF_SECURITY_ADMIN_PASSWORD=admin123
      - GF_USERS_ALLOW_SIGN_UP=false
    volumes:
      - grafana_data:/var/lib/grafana
    ports:
      - "3000:3000"
    depends_on:
      - prometheus

volumes:
  prometheus_data:
  grafana_data:
EOF

Beberapa hal yang perlu diperhatikan:

Node Exporter di-mount ke /proc, /sys, dan / dari host — tapi semuanya read-only (:ro). Ini yang membuat Node Exporter bisa membaca metrik hardware secara langsung dari kernel, tanpa punya akses untuk mengubah apapun. Aman.

--storage.tsdb.retention.time=15d berarti Prometheus menyimpan data selama 15 hari lalu menghapus yang lama. Ini penting untuk menjaga ukuran disk — pada server dengan storage terbatas, kamu tidak ingin database metrik tumbuh tak terbatas.

grafana_data dan prometheus_data adalah Docker named volumes — data tetap aman meski container dihapus atau diupdate.

Bagian 4: Jalankan Stack

cd /opt/monitoring
docker compose up -d

Tunggu beberapa detik sampai semua image terunduh. Cek statusnya:

docker compose ps

Kalau ketiganya menunjukkan status Up, berarti stack monitoring sudah berjalan.

Bagian 5: Hubungkan ke Caddy

Karena setup ini menggunakan Cloudflare Zero Trust, Grafana cukup diekspos via Caddy secara lokal — tidak perlu membuka port ke internet secara langsung. Tambahkan satu blok di /etc/caddy/Caddyfile:

http://monitoring.diaraji.my.id {
    reverse_proxy localhost:3000
}

Reload Caddy:

systemctl reload caddy

Kemudian di dashboard Cloudflare Zero Trust, tambahkan public hostname baru di tunnel yang sudah ada:

  • Subdomain: monitoring
  • Domain: diaraji.my.id
  • Type: HTTP
  • URL: localhost:3000

Simpan, tunggu beberapa detik, lalu buka https://monitoring.diaraji.my.id di browser.

Bagian 6: Setup Awal Grafana

Halaman login Grafana akan menyambut kamu. Masuk dengan:

  • Username: admin
  • Password: admin123

Ganti password segera setelah login pertama — Grafana akan memintanya sendiri.

Tambahkan Prometheus sebagai Data Source

  1. Pergi ke Connections → Data Sources → Add data source
  2. Pilih Prometheus
  3. Di kolom URL, isi: http://prometheus:9090 Perhatikan: ini bukan localhost — ini nama service Docker. Dari dalam container Grafana, prometheus adalah hostname yang valid karena keduanya berada di satu Docker Compose stack.
  4. Klik Save & Test

Kalau muncul tulisan hijau “Successfully queried the Prometheus API”, koneksi berhasil.

Import Dashboard Node Exporter Full

Ini bagian yang menyenangkan. Daripada membangun dashboard dari nol, kita pakai dashboard yang sudah dibuat komunitas:

  1. Pergi ke Dashboards → Import
  2. Masukkan ID: 1860
  3. Klik Load
  4. Pilih datasource Prometheus yang baru dibuat
  5. Klik Import

Dalam hitungan detik, dashboard lengkap dengan puluhan panel akan muncul: CPU usage, memory usage, disk I/O, network traffic, filesystem usage, load average, uptime — semuanya dalam satu layar.

Yang Bisa Kamu Pantau Sekarang

Dengan dashboard ini terpasang, kamu bisa melihat:

  • CPU — seberapa sibuk prosesor Atom N550-mu, per core
  • RAM — berapa yang terpakai, berapa yang masih tersedia, seberapa besar swap yang dipakai
  • Disk — kecepatan baca/tulis storage, dan berapa persen filesystem sudah terisi
  • Network — berapa banyak data yang masuk dan keluar dari server
  • Load Average — gambaran beban server dalam 1, 5, dan 15 menit terakhir
  • Uptime — sudah berapa lama server berjalan tanpa restart

Semua data ini diperbarui setiap 15 detik, dan tersimpan selama 15 hari ke belakang. Kamu bisa melihat pola — kapan biasanya CPU spike, kapan RAM mulai terasa sempit, apakah ada container yang tiba-tiba rakus resource.

Catatan untuk Server Spesifikasi Terbatas

Prometheus, Node Exporter, dan Grafana bukan stack yang berat. Di server dengan RAM 2GB seperti netbook Intel Atom ini, ketiganya berjalan dengan konsumsi memori sekitar 150–250MB total dalam kondisi normal — angka yang masih masuk akal.

Kalau ingin lebih berhemat, kamu bisa tambahkan mem_limit di docker-compose.yml untuk masing-masing container, seperti yang dilakukan di setup Uptime Kuma sebelumnya.

Penutup

Uptime Kuma memberitahu kamu kalau ada yang tidak bisa diakses. Prometheus dan Grafana memberitahu kamu kenapa dan sudah seberapa lama sebelum kamu bahkan menyadarinya.

Keduanya gratis. Keduanya open-source. Keduanya tidak mengirimkan data ke mana pun selain ke database di servermu sendiri.

Laptop butut itu tidak cuma hidup — sekarang kamu juga tahu seberapa sehat ia setiap saat.

Artikel ini bagian dari seri self-hosting di atas netbook bekas. Baca juga: Bayar 300 Ribu Sekali, Dapat “Hosting” Seumur Hidup dan Uptime Kuma: Monitor Website Sendiri via Cloudflare Tunnel.