Membangun Dashboard Monitoring Server Real-Time dengan Grafana dan Prometheus

TL;DR

• Monitoring server yang berguna dimulai dari metric dan alert yang menjawab keputusan operasional, bukan dari jumlah panel.
• Untuk baseline yang sehat, pasang node_exporter, scrape dari Prometheus, lalu bangun dashboard Grafana yang fokus pada saturation, errors, dan capacity.
• Jalur yang benar bukan hanya install tool, tetapi juga memverifikasi target scrape, retention, dan query yang dipakai saat incident.

Pendahuluan

Prometheus dan Grafana adalah kombinasi yang sangat umum untuk monitoring server, tetapi banyak instalasi berhenti pada tahap “dashboard sudah muncul”. Itu belum cukup. Saat incident datang, operator perlu sinyal yang ringkas, query yang cepat, dan panel yang membantu menjawab apa yang salah dan apa yang perlu dicek berikutnya.

Tutorial ini membangun baseline monitoring host real-time yang realistis untuk Linux server. Fokus utamanya adalah implementasi yang bisa dijalankan dan cukup rapi untuk tumbuh ke production.

Prerequisites

• Server Ubuntu 22.04/24.04 atau Linux setara.
• Akses root atau sudo.
• Satu host untuk Prometheus dan Grafana, plus satu atau lebih host target yang dipantau.
• Port yang relevan dapat dibuka secara terbatas:
  • 9100 untuk node_exporter
  • 9090 untuk Prometheus
  • 3000 untuk Grafana
• Docker dan Docker Compose plugin tersedia, atau gunakan binary native jika lebih cocok.

Problem di Production

Banyak tim punya grafik CPU dan memory, tetapi tetap lambat merespons incident karena dashboard tidak memberi konteks. Prometheus kadang juga dipasang dengan retention yang tidak dihitung, scrape target tidak tervalidasi, atau query terlalu mahal saat dipakai di jam kritis.

Mental Model

Monitoring host harus menjawab tiga pertanyaan:

1. ada deviasi atau tidak
2. seberapa mendesak deviasinya
3. ke panel atau metric mana operator bergerak berikutnya

Jika panel tidak membantu menjawab salah satu dari tiga hal itu, panel tersebut tidak pantas berada di dashboard utama.

Konsep Utama

Dashboard dan alert adalah dua alat berbeda

Dashboard dipakai untuk orientasi dan diagnosis. Alert dipakai untuk memicu perhatian manusia. Menyamakan keduanya biasanya menghasilkan noise.

Host metric harus dikaitkan ke service impact

CPU 95% belum tentu incident, tetapi CPU 95% bersamaan dengan latency naik dan disk queue panjang lebih layak direspons.

Retention dan cardinality harus dihitung

Prometheus yang kehabisan disk atau memproses terlalu banyak series akan menjadi masalah baru, bukan solusi observability.

Arsitektur / Context

Arsitektur baseline:

1. node_exporter berjalan di setiap host Linux
2. Prometheus melakukan scrape ke tiap exporter
3. Grafana membaca data dari Prometheus
4. dashboard overview menampilkan CPU, memory, disk, network, dan uptime
5. alert rule dipisahkan dari dashboard utama

Untuk skala kecil sampai menengah, satu Prometheus instance sering cukup. Begitu metric bertambah besar atau retention memanjang, baru pertimbangkan remote write, long-term storage, atau federation.

Practical Implementation

Step 1: Install Docker dan Compose

Jika host monitoring belum punya Docker:

curl -fsSL https://get.docker.com | sudo sh
sudo usermod -aG docker $USER
newgrp docker
docker version
docker compose version

Step 2: Buat direktori monitoring stack

mkdir -p ~/monitoring/prometheus
mkdir -p ~/monitoring/grafana/provisioning/datasources
cd ~/monitoring

Step 3: Buat konfigurasi Prometheus

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

scrape_configs:
  - job_name: prometheus
    static_configs:
      - targets:
          - localhost:9090

  - job_name: linux-nodes
    static_configs:
      - targets:
          - 10.0.1.11:9100
          - 10.0.1.12:9100
EOF

Gunakan IP private atau hostname internal yang stabil. Jangan scrape lewat alamat yang berubah-ubah.

Step 4: Provision datasource Grafana

cat > ~/monitoring/grafana/provisioning/datasources/prometheus.yml <<'EOF'
apiVersion: 1
datasources:
  - name: Prometheus
    type: prometheus
    access: proxy
    url: http://prometheus:9090
    isDefault: true
EOF

Step 5: Jalankan Prometheus dan Grafana

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

  grafana:
    image: grafana/grafana:11.1.0
    container_name: grafana
    environment:
      - GF_SECURITY_ADMIN_USER=admin
      - GF_SECURITY_ADMIN_PASSWORD=change-this-now
    volumes:
      - grafana-data:/var/lib/grafana
      - ./grafana/provisioning:/etc/grafana/provisioning
    ports:
      - "3000:3000"
    restart: unless-stopped

volumes:
  prometheus-data:
  grafana-data:
EOF

docker compose up -d

Step 6: Install node_exporter di host target

Di setiap server Linux yang ingin dipantau:

cd /tmp
curl -LO https://github.com/prometheus/node_exporter/releases/download/v1.8.1/node_exporter-1.8.1.linux-amd64.tar.gz
tar -xzf node_exporter-1.8.1.linux-amd64.tar.gz
sudo cp node_exporter-1.8.1.linux-amd64/node_exporter /usr/local/bin/
sudo useradd --no-create-home --shell /usr/sbin/nologin node_exporter || true

Buat service:

sudo tee /etc/systemd/system/node_exporter.service > /dev/null <<'EOF'
[Unit]
Description=Prometheus Node Exporter
After=network-online.target
Wants=network-online.target

[Service]
User=node_exporter
Group=node_exporter
ExecStart=/usr/local/bin/node_exporter
Restart=always

[Install]
WantedBy=multi-user.target
EOF

Aktifkan:

sudo systemctl daemon-reload
sudo systemctl enable --now node_exporter
sudo systemctl status node_exporter

Step 7: Buka akses firewall seperlunya

Contoh dengan UFW di target host:

sudo ufw allow from 10.0.1.10 to any port 9100 proto tcp
sudo ufw reload

Batasi hanya dari IP Prometheus.

Step 8: Validasi target scrape

Di host Prometheus:

curl -s http://localhost:9090/api/v1/targets | jq '.data.activeTargets[] | {scrapeUrl: .scrapeUrl, health: .health}'

Target harus health: "up".

Step 9: Bangun dashboard baseline

Di Grafana, buat panel dengan query seperti:

CPU busy:

100 - (avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)

Memory available:

(node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes) * 100

Disk usage:

100 - ((node_filesystem_avail_bytes{fstype!~"tmpfs|overlay"} / node_filesystem_size_bytes{fstype!~"tmpfs|overlay"}) * 100)

Load average:

node_load15

Step 10: Tambahkan alert rule dasar

Simpan file rule:

cat > ~/monitoring/prometheus/alerts.yml <<'EOF'
groups:
  - name: linux-node-alerts
    rules:
      - alert: HighCPUUsage
        expr: 100 - (avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 90
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: "CPU tinggi di {{ $labels.instance }}"

      - alert: LowDiskSpace
        expr: (node_filesystem_avail_bytes{fstype!~"tmpfs|overlay"} / node_filesystem_size_bytes{fstype!~"tmpfs|overlay"}) * 100 < 15
        for: 15m
        labels:
          severity: critical
        annotations:
          summary: "Disk space menipis di {{ $labels.instance }}"
EOF

Lalu referensikan di prometheus.yml:

rule_files:
  - /etc/prometheus/alerts.yml

Mount file tersebut pada docker-compose.yml, lalu restart:

docker compose down
docker compose up -d

Verification

Cek container:

docker compose ps

Cek target scrape:

curl -s http://localhost:9090/api/v1/targets | jq '.data.activeTargets[] | {labels: .labels, health: .health}'

Cek query dasar:

curl -g 'http://localhost:9090/api/v1/query?query=up'

Validasi node_exporter di target:

curl http://TARGET_IP:9100/metrics | head

Sukses berarti:

• Prometheus dan Grafana berjalan
• semua target linux-nodes berstatus up
• query dasar mengembalikan data
• panel Grafana terisi angka yang bergerak

Studi Kasus / Masalah Nyata

Alert terus berbunyi saat deploy

Biasanya threshold terlalu agresif atau metrik tidak dipilih dengan benar. Alert production harus punya konteks dan durasi for yang masuk akal.

Grafana indah tetapi lambat saat incident

Penyebab umumnya query dashboard terlalu berat atau terlalu banyak panel pada satu halaman overview.

Troubleshooting

Target scrape down

Periksa service exporter:

sudo systemctl status node_exporter
ss -lntp | grep 9100

Jika port tidak terbuka, service belum aktif atau firewall memblokir.

Prometheus tidak memuat config

Validasi syntax:

docker exec -it prometheus promtool check config /etc/prometheus/prometheus.yml

Grafana tidak bisa konek ke datasource

Pastikan datasource menunjuk ke hostname service Docker, bukan localhost dari container Grafana.

docker exec -it grafana wget -qO- http://prometheus:9090/-/ready

Production Notes

• Jangan publish Grafana dan Prometheus ke internet tanpa auth tambahan atau reverse proxy.
• Gunakan retention yang dihitung terhadap ukuran disk nyata.
• Tambahkan backup untuk dashboard Grafana dan config Prometheus.
• Pisahkan dashboard overview untuk NOC/ops dari dashboard deep-dive untuk debugging.
• Untuk skala lebih besar, pertimbangkan Alertmanager, remote write, dan centralized log correlation.

Trade-offs

• Docker Compose cepat dipasang, tetapi bukan model deployment paling kuat untuk skala besar.
• Retention panjang memberi konteks historis, tetapi memakan disk.
• Dashboard detail membantu diagnosis, tetapi menambah beban query jika tidak disiplin.

Failure Modes

• Prometheus kehabisan disk karena retention tidak dihitung.
• Query panel terlalu berat dan dashboard melambat saat incident.
• node_exporter berjalan, tetapi firewall mencegah scrape sehingga operator mengira host tidak sehat.

Best Practices

• Mulai dari panel yang menjawab keputusan operasional, bukan dari template raksasa.
• Batasi akses ke exporter dan UI monitoring.
• Gunakan recording rules untuk query yang sering dipakai.
• Audit alert setiap beberapa minggu untuk mengurangi noise.

Kesalahan Umum

• memasang semua exporter tanpa tujuan jelas
• memonitor host tanpa memikirkan dampak ke service
• mengabaikan disk usage Prometheus
• membuka port monitoring terlalu lebar

Kesimpulan

Grafana dan Prometheus bisa memberi monitoring server yang sangat efektif jika dipasang sebagai sistem operasional, bukan sekadar dashboard cantik. Dengan scrape yang tervalidasi, query yang fokus, dan alert yang disiplin, tim akan punya sinyal yang benar-benar berguna saat produksi mulai menyimpang.