Memantau Kubernetes dengan Prometheus: Panduan Praktis untuk Stabilitas Aplikasi

1. Pendahuluan

Bayangkan Anda sedang mengendarai mobil di jalan tol. Anda ingin tahu seberapa cepat Anda melaju, berapa banyak bensin yang tersisa, atau apakah ada masalah dengan mesin. Nah, monitoring di dunia aplikasi itu seperti dashboard mobil Anda. Ia memberi tahu Anda tentang “kesehatan” dan “performa” aplikasi Anda.

Di era microservices dan containerization yang kian populer, Kubernetes menjadi orkestrator de-facto untuk aplikasi-aplikasi modern. Namun, mengelola dan memahami apa yang terjadi di dalam klaster Kubernetes yang dinamis bisa jadi tantangan besar. Pod bisa datang dan pergi, node bisa bermasalah, dan aplikasi bisa mengalami bottleneck performa. Tanpa monitoring yang efektif, Anda seperti mengendarai mobil tanpa dashboard: Anda tidak akan tahu kapan harus mengisi bensin atau kapan mesin akan mogok.

Di sinilah Prometheus hadir sebagai pahlawan. Prometheus adalah sistem monitoring dan alerting open-source yang sangat populer, terutama di ekosistem cloud-native. Kemampuannya untuk secara otomatis menemukan target di Kubernetes dan mengumpulkan metrik secara efisien menjadikannya pilihan utama bagi banyak tim DevOps dan developer.

Artikel ini akan memandu Anda memahami mengapa Prometheus begitu penting untuk Kubernetes, bagaimana arsitekturnya, dan yang terpenting, bagaimana cara mengimplementasikannya secara praktis. Siap untuk membuat klaster Kubernetes Anda lebih transparan dan stabil? Mari kita mulai!

2. Apa Itu Prometheus dan Mengapa Ideal untuk Kubernetes?

Prometheus adalah sistem monitoring berbasis metrik. Berbeda dengan sistem logging yang fokus pada event atau kejadian, Prometheus fokus pada time-series data—data yang diukur sepanjang waktu, seperti penggunaan CPU, memori, atau jumlah request per detik.

📌 Konsep Utama Prometheus:

Model Pull: Alih-alih menunggu aplikasi mengirim metrik, Prometheus menarik (pull) metrik dari endpoint HTTP /metrics yang diekspos oleh aplikasi atau exporter.
Time-Series Database: Semua metrik disimpan dalam format time-series dengan label yang kaya, memungkinkan query yang fleksibel.
PromQL: Bahasa query yang powerful untuk menganalisis metrik.
Alertmanager: Komponen terpisah untuk mengelola dan mengirim notifikasi alert.

✅ Mengapa Prometheus Jodoh Ideal untuk Kubernetes?

Service Discovery Otomatis: Kubernetes adalah lingkungan yang sangat dinamis. Pod dan Service bisa muncul dan hilang dengan cepat. Prometheus memiliki integrasi bawaan yang luar biasa dengan Kubernetes, memungkinkannya secara otomatis menemukan Service, Pod, dan Node baru yang perlu dimonitor tanpa konfigurasi manual.
Fleksibilitas Metrik: Prometheus mendukung berbagai jenis metrik (counter, gauge, histogram, summary) dan memungkinkan Anda mengumpulkan metrik kustom dari aplikasi Anda sendiri.
Ekosistem yang Kaya: Ada banyak “exporter” yang tersedia untuk mengumpulkan metrik dari berbagai sumber, seperti node-exporter (untuk host), kube-state-metrics (untuk objek Kubernetes), dan database seperti Redis atau PostgreSQL.
Skalabilitas: Prometheus dirancang untuk menangani ribuan metrik dari ratusan target.

3. Arsitektur Monitoring Kubernetes dengan Prometheus

Untuk memantau klaster Kubernetes secara komprehensif, kita tidak hanya membutuhkan Prometheus server itu sendiri, tetapi juga beberapa komponen pendukung lainnya.

🎯 Komponen Kunci:

Prometheus Server: Ini adalah inti dari sistem. Ia bertugas menarik metrik, menyimpannya, dan mengekspos API untuk query.
Exporters: Aplikasi kecil yang mengubah metrik dari sistem non-Prometheus menjadi format yang bisa dibaca Prometheus.
- kube-state-metrics: Mengumpulkan metrik tentang status objek Kubernetes itu sendiri (misalnya, berapa banyak Pod yang pending, berapa banyak Deployment yang gagal).
- node-exporter: Mengumpulkan metrik tentang sumber daya host (CPU, memori, disk, network) dari setiap node di klaster.
Prometheus Operator: Ini adalah Controller Kubernetes yang menyederhanakan deployment dan konfigurasi Prometheus, Alertmanager, dan Grafana. Ia memperkenalkan Custom Resource Definitions (CRDs) seperti ServiceMonitor dan PodMonitor.
Alertmanager: Menerima alert dari Prometheus, mengelompokkannya, dan mengirimkannya ke berbagai receiver (Slack, email, PagerDuty).
Grafana: Tools visualisasi yang sangat populer. Ia dapat terintegrasi dengan Prometheus sebagai sumber data untuk membuat dashboard yang indah dan informatif.

💡 Analogi Sederhana Arsitektur Monitoring

Bayangkan sebuah pabrik (klaster Kubernetes). * **Prometheus Server** adalah manajer pusat yang berkeliling pabrik secara berkala, menanyakan "Bagaimana status mesin A? Berapa banyak produk yang dibuat mesin B hari ini?" * **Exporters** adalah sensor-sensor yang terpasang di setiap mesin (Node, Pod, Database). Sensor ini tahu cara mengukur performa mesinnya dan memberitahukan informasinya kepada manajer. * **Prometheus Operator** adalah kepala teknisi yang memastikan semua sensor terpasang dengan benar dan manajer tahu lokasi semua sensor baru. * **Alertmanager** adalah sistem alarm pabrik. Jika ada mesin yang rusak atau produksi turun drastis, ia akan mengirimkan notifikasi ke kepala teknisi atau tim perbaikan. * **Grafana** adalah layar besar di kantor manajer yang menampilkan semua data dari sensor dalam bentuk grafik yang mudah dibaca, sehingga manajer bisa melihat tren dan performa keseluruhan.

4. Langkah-langkah Implementasi Praktis

Cara termudah untuk menginstal dan mengelola Prometheus di Kubernetes adalah dengan menggunakan Prometheus Operator melalui Helm.

🛠️ Instalasi Prometheus Operator dengan Helm

Pertama, pastikan Anda memiliki Helm terinstal.

# Tambahkan repo Prometheus Community Helm
helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm repo update

# Buat namespace untuk monitoring
kubectl create namespace monitoring

# Instal Prometheus Operator
helm install prometheus prometheus-community/kube-prometheus-stack \
  --namespace monitoring \
  --set grafana.service.type=NodePort \
  --set grafana.service.nodePort=30000 \
  --set alertmanager.service.type=NodePort \
  --set alertmanager.service.nodePort=30001 \
  --set prometheus.service.type=NodePort \
  --set prometheus.service.nodePort=30002

⚠️ Catatan: Menggunakan NodePort untuk Grafana, Alertmanager, dan Prometheus service di lingkungan produksi tidak disarankan tanpa lapisan keamanan tambahan (misalnya Ingress Controller). Ini hanya untuk kemudahan demo. Untuk produksi, pertimbangkan ClusterIP dengan Ingress.

Setelah instalasi, Anda akan memiliki:

Prometheus Server
Alertmanager
Grafana
kube-state-metrics
node-exporter
Dan CRDs (Custom Resource Definitions) seperti ServiceMonitor dan PodMonitor.

Anda bisa mengakses Grafana di http://<IP_Node_Anda>:30000, Prometheus di http://<IP_Node_Anda>:30002, dan Alertmanager di http://<IP_Node_Anda>:30001. Login default Grafana adalah admin/prom-operator.

🎯 Memonitor Aplikasi Kustom dengan `ServiceMonitor`

Setelah Prometheus Operator terinstal, Prometheus secara otomatis akan memonitor metrik dari klaster Kubernetes itu sendiri melalui kube-state-metrics dan node-exporter. Tapi bagaimana dengan aplikasi Anda sendiri?

Misalnya, Anda memiliki aplikasi Go atau Node.js yang mengekspos metrik di endpoint /metrics pada port 8080.

Pastikan Aplikasi Anda Mengekspos Metrik: Aplikasi Anda harus memiliki endpoint /metrics yang menghasilkan output dalam format Prometheus. Contoh sederhana di Node.js dengan prom-client:

const client = require("prom-client");
const express = require("express");
const app = express();

// Register default metrics
client.collectDefaultMetrics();

// Custom metric example
const httpRequestCounter = new client.Counter({
  name: "http_requests_total",
  help: "Total number of HTTP requests",
  labelNames: ["method", "route", "code"],
});

app.get("/", (req, res) => {
  httpRequestCounter.inc({ method: req.method, route: "/", code: 200 });
  res.send("Hello World!");
});

app.get("/metrics", async (req, res) => {
  res.set("Content-Type", client.register.contentType);
  res.end(await client.register.metrics());
});

app.listen(8080, () => console.log("App listening on port 8080"));

Deployment Aplikasi Anda:

# app-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-web-app
  labels:
    app: my-web-app
spec:
  replicas: 2
  selector:
    matchLabels:
      app: my-web-app
  template:
    metadata:
      labels:
        app: my-web-app
        # Label ini penting untuk ServiceMonitor!
        release: prometheus # Sesuai nama release Helm Prometheus Anda
    spec:
      containers:
        - name: my-web-app-container
          image: your-dockerhub-user/my-web-app:1.0.0 # Ganti dengan image Anda
          ports:
            - name: http-metrics
              containerPort: 8080
          # Tambahkan environment variable jika diperlukan
---
apiVersion: v1
kind: Service
metadata:
  name: my-web-app-service
  labels:
    app: my-web-app
    # Label ini juga penting untuk ServiceMonitor!
    release: prometheus
spec:
  selector:
    app: my-web-app
  ports:
    - name: http-metrics
      protocol: TCP
      port: 8080
      targetPort: http-metrics

kubectl apply -f app-deployment.yaml

Buat ServiceMonitor: Ini adalah CRD yang akan digunakan Prometheus Operator untuk menemukan Service aplikasi Anda dan menginstruksikan Prometheus untuk menarik metrik dari sana.

# my-app-servicemonitor.yaml
apiVersion: monitoring.coreos.com/v1
kind: ServiceMonitor
metadata:
  name: my-web-app-monitor
  labels:
    # Label ini harus cocok dengan selector di Prometheus instance
    # Biasanya 'release: <nama_release_helm_prometheus>'
    release: prometheus
spec:
  selector:
    matchLabels:
      app: my-web-app # Cocokkan dengan label Service aplikasi Anda
      release: prometheus # Cocokkan dengan label Service aplikasi Anda
  endpoints:
    - port: http-metrics # Nama port di Service aplikasi Anda
      path: /metrics # Path endpoint metrik aplikasi Anda
      interval: 15s # Interval scraping metrik
  namespaceSelector:
    matchNames:
      - default # Namespace tempat aplikasi Anda di-deploy

kubectl apply -f my-app-servicemonitor.yaml

Setelah ServiceMonitor dibuat, Prometheus Operator akan mendeteksi ServiceMonitor tersebut, kemudian mengupdate konfigurasi Prometheus server agar mulai scraping metrik dari my-web-app-service pada port http-metrics dengan path /metrics. Anda bisa memverifikasinya di UI Prometheus (http://<IP_Node_Anda>:30002/targets).

5. Visualisasi Metrik dengan Grafana

Melihat metrik mentah di Prometheus memang penting, tapi memvisualisasikannya di Grafana jauh lebih informatif. Grafana memungkinkan Anda membuat dashboard kustom dengan berbagai panel (grafik, tabel, gauge) untuk menampilkan metrik Anda.

📊 Integrasi Grafana dengan Prometheus

Saat Anda menginstal kube-prometheus-stack dengan Helm, Grafana sudah terinstal dan dikonfigurasi untuk menggunakan Prometheus sebagai data source secara otomatis. Bahkan, beberapa dashboard penting seperti “Kubernetes / Compute Resources / Namespace (Pods)” atau “Node Exporter Full” sudah terinstal.

📈 Membuat Dashboard Kustom

Login ke Grafana: http://<IP_Node_Anda>:30000 (user: admin, pass: prom-operator).
Buat Dashboard Baru: Klik ikon ”+” di sidebar kiri, lalu pilih “New dashboard”.
Tambahkan Panel Baru: Klik “Add new panel”.
Pilih Data Source: Pastikan “Prometheus” terpilih sebagai data source.
Tulis PromQL Query: Di kolom “Query”, Anda bisa mulai menulis query PromQL.
- Contoh untuk metrik aplikasi Anda: http_requests_total{job="my-web-app"}
- Contoh untuk penggunaan CPU Pod: sum(rate(container_cpu_usage_seconds_total{namespace="default", pod="my-web-app-..."}[5m])) by (pod)
- Contoh untuk penggunaan memori Node: node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes
Konfigurasi Visualisasi: Pilih jenis visualisasi (Graph, Stat, Gauge, dll.), beri judul, dan atur sumbu.
Simpan Dashboard: Beri nama dashboard Anda.

💡 Tips: Jelajahi Grafana Labs untuk menemukan ribuan dashboard komunitas yang bisa Anda import dan modifikasi. Cukup cari “Kubernetes Prometheus Dashboard” dan import JSON-nya.

6. Mengatur Alerting dengan Alertmanager

Monitoring tanpa alerting itu seperti memiliki sensor kebakaran tapi tidak ada alarm. Alertmanager adalah komponen yang akan memberi tahu Anda ketika ada sesuatu yang tidak beres.

🚨 Konfigurasi Alertmanager

Prometheus Operator secara otomatis menginstal Alertmanager. Anda dapat mengkonfigurasinya menggunakan PrometheusRule dan AlertmanagerConfig CRDs.

Buat Aturan Alert dengan PrometheusRule: Ini adalah file YAML yang mendefinisikan kondisi untuk memicu alert.

# app-alerts.yaml
apiVersion: monitoring.coreos.com/v1
kind: PrometheusRule
metadata:
  name: my-app-alerts
  labels:
    # Label ini harus cocok dengan selector di Prometheus instance
    release: prometheus
spec:
  groups:
    - name: my-app-alerts
      rules:
        - alert: HighHttpRequestRate
          expr: sum(rate(http_requests_total{job="my-web-app", code="200"}[5m])) by (app) > 100
          for: 5m
          labels:
            severity: warning
          annotations:
            summary: "Tingkat request HTTP tinggi pada {{ $labels.app }}"
            description: "Aplikasi {{ $labels.app }} menerima lebih dari 100 request/detik selama 5 menit."
        - alert: PodCrashing
          expr: sum(kube_pod_container_status_restarts_total{pod=~"my-web-app-.*"} - kube_pod_container_status_restarts_total{pod=~"my-web-app-.*"} offset 5m) > 0
          for: 1m
          labels:
            severity: critical
          annotations:
            summary: "Pod {{ $labels.pod }} mengalami restart"
            description: "Pod {{ $labels.pod }} telah restart dalam 5 menit terakhir."

kubectl apply -f app-alerts.yaml

expr: Query PromQL yang jika menghasilkan nilai true, maka alert akan aktif.
for: Durasi alert harus true sebelum benar-benar terpicu.
labels: Label kustom untuk alert (misal severity).
annotations: Informasi tambahan untuk alert (misal summary, description).

Konfigurasi Receiver di Alertmanager: Anda perlu memberi tahu Alertmanager ke mana harus mengirim alert. Ini dilakukan dengan AlertmanagerConfig CRD. Contoh di sini untuk Slack.

# alertmanager-config.yaml
apiVersion: monitoring.coreos.com/v1alpha1
kind: AlertmanagerConfig
metadata:
  name: main-config
  namespace: monitoring # Pastikan di namespace yang sama dengan Alertmanager
  labels:
    alertmanagerConfig: main
spec:
  route:
    groupBy: ["alertname", "severity"]
    groupWait: 30s
    groupInterval: 5m
    repeatInterval: 1h
    receiver: "slack-notifications" # Nama receiver yang akan kita definisikan
  receivers:
    - name: "slack-notifications"
      slackConfigs:
        - apiURL:
            name: alertmanager-slack-webhook
            key: webhook_url
          channel: "#alerts-dev" # Ganti dengan channel Slack Anda
          sendResolved: true
          title: "[{{ .Status | toUpper }}] {{ .CommonLabels.alertname }}"
          text: '{{ range .Alerts }}*Summary:* {{ .Annotations.summary }}\n*Description:* {{ .Annotations.description }}\n*Severity:* {{ .Labels.severity }}\n*Instance:* {{ .Labels.instance }}\n*Details:* {{ range .Labels.SortedPairs }} - {{ .Name }}: {{ .Value }}\n{{ end }}{{ end }}'

⚠️ Penting: apiURL mengambil webhook URL dari Secret. Anda perlu membuat Secret terlebih dahulu:

kubectl create secret generic alertmanager-slack-webhook --from-literal=webhook_url='https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX' -n monitoring

Ganti URL dengan webhook Slack Anda yang sebenarnya.

kubectl apply -f alertmanager-config.yaml

Sekarang, jika salah satu aturan alert Anda terpicu, Alertmanager akan mengirim notifikasi ke channel Slack yang telah Anda konfigurasi.

Kesimpulan

Selamat! Anda telah mempelajari dasar-dasar monitoring Kubernetes dengan Prometheus. Mulai dari memahami komponen utamanya, menginstal Prometheus Operator, memonitor aplikasi kustom dengan ServiceMonitor, memvisualisasikan data di Grafana, hingga mengkonfigurasi alert dengan Alertmanager.

Monitoring adalah tulang punggung dari setiap sistem yang stabil dan reliable. Dengan Prometheus dan Kubernetes, Anda tidak hanya dapat melihat apa yang terjadi di dalam klaster Anda, tetapi juga proaktif dalam mengidentifikasi dan menyelesaikan masalah sebelum berdampak besar pada pengguna. Teruslah bereksperimen dengan PromQL, bangun dashboard yang informatif, dan sesuaikan alert Anda agar benar-benar relevan dengan kebutuhan operasional Anda.

Jangan biarkan klaster Kubernetes Anda berjalan tanpa pengawasan. Jadilah pilot yang tahu persis kondisi pesawatnya!